using System;
using System.Buffers;
using System.Buffers.Binary;
using System.Buffers.Text;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Tracing;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
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.Serialization;
using API;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FxResources.System.Buffers;
using FxResources.System.Memory;
using FxResources.System.Numerics.Vectors;
using GUIFramework;
using Groups;
using Guilds;
using HarmonyLib;
using HarmonyLib.Tools;
using ItemDataManager;
using ItemManager;
using JetBrains.Annotations;
using Jewelcrafting;
using LiteDB;
using LiteDB.Client.Shared;
using LiteDB.Engine;
using LiteDB.Utils;
using LiteDB.Utils.Extensions;
using LiteDB.Vector;
using Marketplace.DB;
using Marketplace.DiscordStuff;
using Marketplace.ExternalLoads;
using Marketplace.Hammer;
using Marketplace.Modules.Banker;
using Marketplace.Modules.Buffer;
using Marketplace.Modules.CMS;
using Marketplace.Modules.Dialogues;
using Marketplace.Modules.Factions;
using Marketplace.Modules.Feedback;
using Marketplace.Modules.Gambler;
using Marketplace.Modules.Global_Options;
using Marketplace.Modules.Leaderboard;
using Marketplace.Modules.MainMarketplace;
using Marketplace.Modules.NPC;
using Marketplace.Modules.Quests;
using Marketplace.Modules.ServerInfo;
using Marketplace.Modules.Teleporter;
using Marketplace.Modules.TerritorySystem;
using Marketplace.Modules.Trader;
using Marketplace.Modules.Transmogrification;
using Marketplace.OtherModsAPIs;
using Marketplace.Paths;
using Marketplace.Stats;
using Marketplace.UI_OptimizationHandler;
using Microsoft.CodeAnalysis;
using Microsoft.Win32.SafeHandles;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
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;
using fastJSON;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("kg.Marketplace")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("kg.Marketplace")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("F2FB0636-63D4-48B6-8B6D-4DB68E177299")]
[assembly: AssemblyFileVersion("9.8.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("9.8.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
	internal static class IsExternalInit
	{
	}
}
namespace ServerSync
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	public class SyncedConfigEntry<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;
			}
		}
	}
	public abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		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;

		public void Update()
		{
			this.ValueChanged?.Invoke();
		}

		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]
	public sealed class CustomSyncedValue<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]
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[CompilerGenerated]
			private sealed class <<Postfix>g__WatchAdminListChanges|0_0>d : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				private <>c__DisplayClass0_0 <>8__1;

				private List<string> <CurrentList>5__2;

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

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

				[DebuggerHidden]
				public <<Postfix>g__WatchAdminListChanges|0_0>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>8__1 = null;
					<CurrentList>5__2 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_006a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0074: Expected O, but got Unknown
					//IL_0095: Unknown result type (might be due to invalid IL or missing references)
					//IL_009f: Expected O, but got Unknown
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						if (!<>8__1.adminList.GetList().SequenceEqual(<CurrentList>5__2))
						{
							<CurrentList>5__2 = new List<string>(<>8__1.adminList.GetList());
							List<ZNetPeer> list = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)<>8__1.listContainsId != null) ? ((bool)<>8__1.listContainsId.Invoke(ZNet.instance, new object[2] { <>8__1.adminList, hostName })) : <>8__1.adminList.Contains(hostName);
							}).ToList();
							List<ZNetPeer> peers = ZNet.instance.GetPeers().Except(list).ToList();
							<Postfix>g__SendAdmin|0_1(peers, isAdmin: false);
							<Postfix>g__SendAdmin|0_1(list, isAdmin: true);
						}
					}
					else
					{
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass0_0();
						<>8__1.listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						<>8__1.adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						<CurrentList>5__2 = new List<string>(<>8__1.adminList.GetList());
					}
					<>2__current = (object)new WaitForSeconds(30f);
					<>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();
				}
			}

			[CompilerGenerated]
			private sealed class <>c__DisplayClass0_0
			{
				public MethodInfo listContainsId;

				public SyncedList adminList;

				public Func<ZNetPeer, bool> <>9__2;

				internal bool <Postfix>b__2(ZNetPeer p)
				{
					string hostName = p.m_rpc.GetSocket().GetHostName();
					if ((object)listContainsId != null)
					{
						return (bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName });
					}
					return adminList.Contains(hostName);
				}
			}

			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<long, ZPackage>)configSync.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				[IteratorStateMachine(typeof(<<Postfix>g__WatchAdminListChanges|0_0>d))]
				static IEnumerator WatchAdminListChanges()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<Postfix>g__WatchAdminListChanges|0_0>d(0);
				}
			}

			[CompilerGenerated]
			internal static void <Postfix>g__SendAdmin|0_1(List<ZNetPeer> peers, bool isAdmin)
			{
				ZPackage package = ConfigsToPackage(null, null, new <>z__ReadOnlySingleElementList<PackageEntry>(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));
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			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);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		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;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, 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;
					((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_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
			{
				public ZRpc rpc;

				public ZNet __instance;

				public Dictionary<Assembly, BufferingSocket> __state;

				public ZNetPeer peer;
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				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)
			{
				<>c__DisplayClass2_0 CS$<>8__locals0 = new <>c__DisplayClass2_0();
				CS$<>8__locals0.rpc = rpc;
				CS$<>8__locals0.__instance = __instance;
				CS$<>8__locals0.__state = __state;
				if (CS$<>8__locals0.__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(CS$<>8__locals0.__instance, new object[1] { CS$<>8__locals0.rpc });
					CS$<>8__locals0.peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (CS$<>8__locals0.peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)CS$<>8__locals0.__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (CS$<>8__locals0.rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(CS$<>8__locals0.rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(CS$<>8__locals0.__instance, new object[1] { CS$<>8__locals0.rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = CS$<>8__locals0.__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();
					}
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass2_0.<<Postfix>g__sendAsync|1>d))]
				IEnumerator sendAsync()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass2_0.<<Postfix>g__sendAsync|1>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}
		}

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			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")]
		private static class PreventConfigRereadChangingValues
		{
			[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;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

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

			public ConfigSync <>4__this;

			public ZRoutedRpc rpc;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass57_0
		{
			public ConfigSync <>4__this;

			public ZPackage package;

			internal IEnumerator<bool> <sendZPackage>b__1(ZNetPeer p)
			{
				return <>4__this.distributeConfigToPeers(p, package);
			}
		}

		[CompilerGenerated]
		private sealed class <distributeConfigToPeers>d__55 : IEnumerator<bool>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private bool <>2__current;

			public ZNetPeer peer;

			public ConfigSync <>4__this;

			public ZPackage package;

			private <>c__DisplayClass55_0 <>8__1;

			private ArraySegment<byte> <seg>5__2;

			private int <len>5__3;

			private int <fragments>5__4;

			private long <packageIdentifier>5__5;

			private int <fragment>5__6;

			private IEnumerator<bool> <>7__wrap6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>8__1 = null;
				<seg>5__2 = default(ArraySegment<byte>);
				<>7__wrap6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Expected O, but got Unknown
				try
				{
					int num;
					int num2;
					ZPackage val;
					int num3;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass55_0();
						<>8__1.peer = peer;
						<>8__1.<>4__this = <>4__this;
						<>8__1.rpc = ZRoutedRpc.instance;
						if (<>8__1.rpc == null)
						{
							return false;
						}
						if (package.Size() > 40000)
						{
							if (!package.m_stream.TryGetBuffer(out <seg>5__2))
							{
								byte[] array = package.m_stream.ToArray();
								<seg>5__2 = new ArraySegment<byte>(array, 0, array.Length);
							}
							<len>5__3 = <seg>5__2.Count;
							<fragments>5__4 = (<len>5__3 + 40000 - 1) / 40000;
							<packageIdentifier>5__5 = ++packageCounter;
							<fragment>5__6 = 0;
							goto IL_0269;
						}
						<>7__wrap6 = waitForQueue().GetEnumerator();
						<>1__state = -4;
						goto IL_02d0;
					case 1:
						<>1__state = -3;
						goto IL_0160;
					case 2:
						<>1__state = -1;
						goto IL_0257;
					case 3:
						{
							<>1__state = -4;
							goto IL_02d0;
						}
						IL_0269:
						if (<fragment>5__6 < <fragments>5__4)
						{
							<>7__wrap6 = waitForQueue().GetEnumerator();
							<>1__state = -3;
							goto IL_0160;
						}
						<seg>5__2 = default(ArraySegment<byte>);
						break;
						IL_02d0:
						if (<>7__wrap6.MoveNext())
						{
							bool current = <>7__wrap6.Current;
							<>2__current = current;
							<>1__state = 3;
							return true;
						}
						<>m__Finally2();
						<>7__wrap6 = null;
						SendPackage(package);
						break;
						IL_0160:
						if (<>7__wrap6.MoveNext())
						{
							bool current2 = <>7__wrap6.Current;
							<>2__current = current2;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap6 = null;
						if (!<>8__1.peer.m_socket.IsConnected())
						{
							return false;
						}
						num = <fragment>5__6 * 40000;
						num2 = Math.Min(40000, <len>5__3 - num);
						val = new ZPackage();
						val.Write((byte)2);
						val.Write(<packageIdentifier>5__5);
						val.Write(<fragment>5__6);
						val.Write(<fragments>5__4);
						val.Write(num2);
						val.m_stream.Write(<seg>5__2.Array, <seg>5__2.Offset + num, num2);
						SendPackage(val);
						if (<fragment>5__6 != <fragments>5__4 - 1)
						{
							<>2__current = true;
							<>1__state = 2;
							return true;
						}
						goto IL_0257;
						IL_0257:
						num3 = <fragment>5__6 + 1;
						<fragment>5__6 = num3;
						goto IL_0269;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				void SendPackage(ZPackage pkg)
				{
					string text = ((<>c__DisplayClass55_0)this).<>4__this.Name + " ConfigSync";
					if (isServer)
					{
						((<>c__DisplayClass55_0)this).peer.m_rpc.Invoke(text, new object[1] { pkg });
					}
					else
					{
						((<>c__DisplayClass55_0)this).rpc.InvokeRoutedRPC(((<>c__DisplayClass55_0)this).peer.m_server ? 0 : ((<>c__DisplayClass55_0)this).peer.m_uid, text, new object[1] { pkg });
					}
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass55_0.<<distributeConfigToPeers>g__waitForQueue|0>d))]
				IEnumerable<bool> waitForQueue()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass55_0.<<distributeConfigToPeers>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__wrap6 != null)
				{
					<>7__wrap6.Dispose();
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <sendZPackage>d__57 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ConfigSync <>4__this;

			public ZPackage package;

			public List<ZNetPeer> peers;

			private List<IEnumerator<bool>> <writers>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>c__DisplayClass57_0 CS$<>8__locals0 = new <>c__DisplayClass57_0
					{
						<>4__this = <>4__this,
						package = package
					};
					if (!Object.op_Implicit((Object)(object)ZNet.instance))
					{
						return false;
					}
					if (CS$<>8__locals0.package.Size() > 10000)
					{
						MemoryStream stream = CS$<>8__locals0.package.m_stream;
						stream.Position = 0L;
						CS$<>8__locals0.package = new ZPackage();
						CS$<>8__locals0.package.m_stream.WriteByte(4);
						CS$<>8__locals0.package.m_stream.Position = 5L;
						using (DeflateStream destination = new DeflateStream(CS$<>8__locals0.package.m_stream, CompressionLevel.Optimal, leaveOpen: true))
						{
							stream.CopyTo(destination);
						}
						long position = CS$<>8__locals0.package.m_stream.Position;
						int value = (int)(position - 5);
						CS$<>8__locals0.package.m_stream.Position = 1L;
						CS$<>8__locals0.package.m_stream.Write(BitConverter.GetBytes(value), 0, 4);
					}
					<writers>5__2 = (from peer in peers
						where peer.IsReady()
						select peer into p
						select CS$<>8__locals0.<>4__this.distributeConfigToPeers(p, CS$<>8__locals0.package)).ToList();
					<writers>5__2.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
					break;
				}
				case 1:
					<>1__state = -1;
					<writers>5__2.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
					break;
				}
				if (<writers>5__2.Count > 0)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				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();
			}
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		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;

		private OwnConfigEntryBase? lockedConfig;

		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[]>>();

		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_0051;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (num)
				{
					return !lockExempt;
				}
				goto IL_0051;
				IL_0051:
				return false;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin
		{
			get
			{
				if (!lockExempt)
				{
					return isSourceOfTruth;
				}
				return true;
			}
		}

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

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		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<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new <>z__ReadOnlySingleElementList<object>(syncedEntry)).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new <>z__ReadOnlySingleElementList<string>("serverversion")).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		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_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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(delegate(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 SortedDictionary<int, byte[]> 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((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;
					val2.Save();
				}
				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((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (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)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			if (!configSync.IsSourceOfTruth && config2.SynchronizedConfig && config2.LocalBaseValue != null)
			{
				if (!configSync.IsLocked)
				{
					if (config2 == configSync.lockedConfig)
					{
						return lockExempt;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		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((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((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		[IteratorStateMachine(typeof(<distributeConfigToPeers>d__55))]
		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <distributeConfigToPeers>d__55(0)
			{
				<>4__this = this,
				peer = peer,
				package = package
			};
		}

		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((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		[IteratorStateMachine(typeof(<sendZPackage>d__57))]
		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <sendZPackage>d__57(0)
			{
				<>4__this = this,
				peers = peers,
				package = package
			};
		}

		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));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<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)
		{
			if (!type.IsEnum)
			{
				return type;
			}
			return Enum.GetUnderlyingType(type);
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write(partial ? ((byte)1) : ((byte)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, 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();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		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
			{
				string text = minimumRequiredVersion;
				if (text == null)
				{
					if (!ModRequired)
					{
						return "0.0.0";
					}
					text = CurrentVersion;
				}
				return text;
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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((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 <>z__ReadOnlySingleElementList<Type>(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.";
			}
			if (!(new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)))
			{
				return DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".";
			}
			return DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". 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(ZRpc? rpc = null)
		{
			if (rpc != null)
			{
				return ErrorServer(rpc);
			}
			return ErrorClient();
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).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, 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);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		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_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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>)delegate(ZRpc rpc, 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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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((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<KeyValuePair<string, string>, string>((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 ItemManager
{
	[PublicAPI]
	public enum CraftingTable
	{
		Disabled,
		Inventory,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("blackforge")]
		BlackForge,
		Custom
	}
	[PublicAPI]
	public enum ConversionPiece
	{
		Disabled,
		[InternalName("smelter")]
		Smelter,
		[InternalName("charcoal_kiln")]
		CharcoalKiln,
		[InternalName("blastfurnace")]
		BlastFurnace,
		[InternalName("windmill")]
		Windmill,
		[InternalName("piece_spinningwheel")]
		SpinningWheel,
		[InternalName("eitrrefinery")]
		EitrRefinery,
		Custom
	}
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[PublicAPI]
	public class RequiredResourceList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public bool Free;

		public void Add(string itemName, int amount, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amount = amount,
				quality = quality
			});
		}

		public void Add(string itemName, ConfigEntry<int> amountConfig, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amountConfig = amountConfig,
				quality = quality
			});
		}
	}
	[PublicAPI]
	public class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

		public void Add(CraftingTable table, int level)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = table,
				level = level
			});
		}

		public void Add(string customTable, int level)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				level = level,
				custom = customTable
			});
		}
	}
	[PublicAPI]
	public class ItemRecipe
	{
		public readonly RequiredResourceList RequiredItems = new RequiredResourceList();

		public readonly RequiredResourceList RequiredUpgradeItems = new RequiredResourceList();

		public readonly CraftingStationList Crafting = new CraftingStationList();

		public int CraftAmount = 1;

		public bool RequireOnlyOneIngredient;

		public float QualityResultAmountMultiplier = 1f;

		public ConfigEntryBase? RecipeIsActive;
	}
	[PublicAPI]
	public class Trade
	{
		public Trader Trader;

		public uint Price;

		public uint Stack = 1u;

		public string? RequiredGlobalKey;
	}
	[PublicAPI]
	[Flags]
	public enum Trader
	{
		None = 0,
		Haldor = 1,
		Hildir = 2
	}
	public struct Requirement
	{
		public string itemName;

		public int amount;

		public ConfigEntry<int>? amountConfig;

		[Description("Set to a non-zero value to apply the requirement only for a specific quality")]
		public int quality;
	}
	public struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		public string? custom;
	}
	[Flags]
	public enum Configurability
	{
		Disabled = 0,
		Recipe = 1,
		Stats = 2,
		Drop = 4,
		Trader = 8,
		Full = 0xF
	}
	[PublicAPI]
	public class DropTargets
	{
		public readonly List<DropTarget> Drops = new List<DropTarget>();

		public void Add(string creatureName, float chance, int min = 1, int? max = null, bool levelMultiplier = true)
		{
			Drops.Add(new DropTarget
			{
				creature = creatureName,
				chance = chance,
				min = min,
				max = max.GetValueOrDefault(min),
				levelMultiplier = levelMultiplier
			});
		}
	}
	public struct DropTarget
	{
		public string creature;

		public int min;

		public int max;

		public float chance;

		public bool levelMultiplier;
	}
	public enum Toggle
	{
		On = 1,
		Off = 0
	}
	[PublicAPI]
	public class Item
	{
		private class ItemConfig
		{
			public ConfigEntry<string>? craft;

			public ConfigEntry<string>? upgrade;

			public ConfigEntry<CraftingTable> table;

			public ConfigEntry<int> tableLevel;

			public ConfigEntry<string> customTable;

			public ConfigEntry<int>? maximumTableLevel;

			public ConfigEntry<Toggle> requireOneIngredient;

			public ConfigEntry<float> qualityResultAmountMultiplier;
		}

		private class TraderConfig
		{
			public ConfigEntry<Trader> trader;

			public ConfigEntry<uint> price;

			public ConfigEntry<uint> stack;

			public ConfigEntry<string> requiredGlobalKey;
		}

		private class RequirementQuality
		{
			public int quality;
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;

			public Func<bool>? browsability;
		}

		[PublicAPI]
		public enum DamageModifier
		{
			Normal,
			Resistant,
			Weak,
			Immune,
			Ignore,
			VeryResistant,
			VeryWeak,
			None
		}

		private delegate void setDmgFunc(ref DamageTypes dmg, float value);

		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

			public SerializedRequirements(List<Requirement> reqs)
			{
				Reqs = reqs;
			}

			public SerializedRequirements(string reqs)
				: this(reqs.Split(new char[1] { ',' }).Select(delegate(string r)
				{
					string[] array = r.Split(new char[1] { ':' });
					Requirement result = default(Requirement);
					result.itemName = array[0];
					result.amount = ((array.Length <= 1 || !int.TryParse(array[1], out var result2)) ? 1 : result2);
					result.quality = ((array.Length > 2 && int.TryParse(array[2], out var result3)) ? result3 : 0);
					return result;
				}).ToList())
			{
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select((Requirement r) => $"{r.itemName}:{r.amount}" + ((r.quality > 0) ? $":{r.quality}" : "")));
			}

			public static ItemDrop? fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("The required item '" + name + "' does not exist."));
				}
				return val;
			}

			public static Requirement[] toPieceReqs(ObjectDB objectDB, SerializedRequirements craft, SerializedRequirements upgrade)
			{
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Expected O, but got Unknown
				//IL_0194: Expected O, but got Unknown
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				ObjectDB objectDB2 = objectDB;
				Dictionary<string, Requirement> dictionary = craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)((Requirement r) => r.itemName), (Func<Requirement, Requirement>)delegate(Requirement r)
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: Expected O, but got Unknown
					ItemDrop val6 = ResItem(r);
					return (val6 != null) ? new Requirement
					{
						m_amount = (r.amountConfig?.Value ?? r.amount),
						m_resItem = val6,
						m_amountPerLevel = 0
					} : ((Requirement)null);
				});
				List<Requirement> list = dictionary.Values.Where((Requirement v) => v != null).ToList();
				foreach (Requirement item in upgrade.Reqs.Where((Requirement r) => r.itemName != ""))
				{
					if (item.quality > 0)
					{
						ItemDrop val = ResItem(item);
						if (val != null)
						{
							Requirement val2 = new Requirement
							{
								m_resItem = val,
								m_amountPerLevel = (item.amountConfig?.Value ?? item.amount),
								m_amount = 0
							};
							list.Add(val2);
							requirementQuality.Add(val2, new RequirementQuality
							{
								quality = item.quality
							});
						}
						continue;
					}
					if (!dictionary.TryGetValue(item.itemName, out var value) || value == null)
					{
						ItemDrop val3 = ResItem(item);
						if (val3 != null)
						{
							string itemName = item.itemName;
							Requirement val4 = new Requirement
							{
								m_resItem = val3,
								m_amount = 0
							};
							Requirement val5 = val4;
							dictionary[itemName] = val4;
							value = val5;
							list.Add(value);
						}
					}
					if (value != null)
					{
						value.m_amountPerLevel = item.amountConfig?.Value ?? item.amount;
					}
				}
				return list.ToArray();
				ItemDrop? ResItem(Requirement r)
				{
					return fetchByName(objectDB2, r.itemName);
				}
			}
		}

		private class SerializedDrop
		{
			public readonly List<DropTarget> Drops;

			public SerializedDrop(List<DropTarget> drops)
			{
				Drops = drops;
			}

			public SerializedDrop(string drops)
			{
				Drops = ((drops == "") ? ((IEnumerable<string>)Array.Empty<string>()) : ((IEnumerable<string>)drops.Split(new char[1] { ',' }))).Select(delegate(string r)
				{
					string[] array = r.Split(new char[1] { ':' });
					if (array.Length <= 2 || !int.TryParse(array[2], out var result))
					{
						result = 1;
					}
					if (array.Length <= 3 || !int.TryParse(array[3], out var result2))
					{
						result2 = result;
					}
					bool levelMultiplier = array.Length <= 4 || array[4] != "0";
					DropTarget result3 = default(DropTarget);
					result3.creature = array[0];
					result3.chance = ((array.Length > 1 && float.TryParse(array[1], out var result4)) ? result4 : 1f);
					result3.min = result;
					result3.max = result2;
					result3.levelMultiplier = levelMultiplier;
					return result3;
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Drops.Select((DropTarget r) => $"{r.creature}:{r.chance.ToString(CultureInfo.InvariantCulture)}:{r.min}:" + ((r.min == r.max) ? "" : $"{r.max}") + (r.levelMultiplier ? "" : ":0")));
			}

			private static Character? fetchByName(ZNetScene netScene, string name)
			{
				GameObject prefab = netScene.GetPrefab(name);
				Character val = ((prefab != null) ? prefab.GetComponent<Character>() : null);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("The drop target character '" + name + "' does not exist."));
				}
				return val;
			}

			public Dictionary<Character, Drop> toCharacterDrops(ZNetScene netScene, GameObject item)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: 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_006f: Expected O, but got Unknown
				Dictionary<Character, Drop> dictionary = new Dictionary<Character, Drop>();
				foreach (DropTarget drop in Drops)
				{
					Character val = fetchByName(netScene, drop.creature);
					if (val != null)
					{
						dictionary[val] = new Drop
						{
							m_prefab = item,
							m_amountMin = drop.min,
							m_amountMax = drop.max,
							m_chance = drop.chance,
							m_levelMultiplier = drop.levelMultiplier
						};
					}
				}
				return dictionary;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass83_0
		{
			public Quaternion? cameraRotation;

			public float lightIntensity;

			public ItemDrop item;

			public Quaternion? itemRotation;
		}

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

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructions;

			public IEnumerable<CodeInstruction> <>3__instructions;

			private List<CodeInstruction> <instrs>5__2;

			private FieldInfo <amountField>5__3;

			private int <i>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instrs>5__2 = null;
				<amountField>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Expected O, but got Unknown
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Expected O, but got Unknown
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Expected O, but got Unknown
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<instrs>5__2 = instructions.ToList();
					<amountField>5__3 = AccessTools.DeclaredField(typeof(Recipe), "m_amount");
					<i>5__4 = 0;
					break;
				case 1:
					<>1__state = -1;
					if (<i>5__4 > 1 && <instrs>5__2[<i>5__4 - 2].opcode == OpCodes.Ldfld && CodeInstructionExtensions.OperandIs(<instrs>5__2[<i>5__4 - 2], (MemberInfo)<amountField>5__3) && <instrs>5__2[<i>5__4 - 1].opcode == OpCodes.Ldc_I4_1 && <instrs>5__2[<i>5__4].operand is Label)
					{
						<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						<>1__state = 2;
						return true;
					}
					goto IL_01b2;
				case 2:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Item), "CheckItemIsUpgrade", (Type[])null, (Type[])null));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Brtrue, <instrs>5__2[<i>5__4].operand);
					<>1__state = 4;
					return true;
				case 4:
					{
						<>1__state = -1;
						goto IL_01b2;
					}
					IL_01b2:
					num = <i>5__4 + 1;
					<i>5__4 = num;
					break;
				}
				if (<i>5__4 < <instrs>5__2.Count)
				{
					<>2__current = <instrs>5__2[<i>5__4];
					<>1__state = 1;
					return true;
				}
				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]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<Transpile_InventoryGui>d__85 <Transpile_InventoryGui>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Transpile_InventoryGui>d__ = this;
				}
				else
				{
					<Transpile_InventoryGui>d__ = new <Transpile_InventoryGui>d__85(0);
				}
				<Transpile_InventoryGui>d__.instructions = <>3__instructions;
				return <Transpile_InventoryGui>d__;
			}

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

		private static readonly List<Item> registeredItems = new List<Item>();

		private static readonly Dictionary<ItemDrop, Item> itemDropMap = new Dictionary<ItemDrop, Item>();

		private static Dictionary<Item, Dictionary<string, List<Recipe>>> activeRecipes = new Dictionary<Item, Dictionary<string, List<Recipe>>>();

		private static Dictionary<Recipe, ConfigEntryBase?> hiddenCraftRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		private static Dictionary<Recipe, ConfigEntryBase?> hiddenUpgradeRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		private static Dictionary<Item, Dictionary<string, ItemConfig>> itemCraftConfigs = new Dictionary<Item, Dictionary<string, ItemConfig>>();

		private static Dictionary<Item, ConfigEntry<string>> itemDropConfigs = new Dictionary<Item, ConfigEntry<string>>();

		private Dictionary<CharacterDrop, Drop> characterDrops = new Dictionary<CharacterDrop, Drop>();

		private readonly Dictionary<ConfigEntryBase, Action> statsConfigs = new Dictionary<ConfigEntryBase, Action>();

		private static readonly ConditionalWeakTable<Requirement, RequirementQuality> requirementQuality = new ConditionalWeakTable<Requirement, RequirementQuality>();

		public static Configurability DefaultConfigurability = Configurability.Full;

		public Configurability? Configurable;

		private Configurability configurationVisible = Configurability.Full;

		private TraderConfig? traderConfig;

		public readonly GameObject Prefab;

		[Description("Specifies the maximum required crafting station level to upgrade and repair the item.\nDefault is calculated from crafting station level and maximum quality.")]
		public int MaximumRequiredStationLevel = int.MaxValue;

		[Description("Assigns the item as a drop item to a creature.\nUses a creature name, a drop chance and a minimum and maximum amount.")]
		public readonly DropTargets DropsFrom = new DropTargets();

		[Description("Configures whether the item can be bought at the trader.\nDon't forget to set cost to something above 0 or the item will be sold for free.")]
		public readonly Trade Trade = new Trade();

		internal List<Conversion> Conversions = new List<Conversion>();

		internal List<ItemConversion> conversions = new List<ItemConversion>();

		public Dictionary<string, ItemRecipe> Recipes = new Dictionary<string, ItemRecipe>();

		private LocalizeKey? _name;

		private LocalizeKey? _description;

		private static object? configManager;

		private static Localization? _english;

		private static BaseUnityPlugin? _plugin;

		private static bool hasConfigSync = true;

		private static object? _configSync;

		private Configurability configurability => Configurable ?? DefaultConfigurability;

		[Description("Specifies the resources needed to craft the item.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the item should need.")]
		public RequiredResourceList RequiredItems => this[""].RequiredItems;

		[Description("Specifies the resources needed to upgrade the item.\nUse .Add to add resources with their internal ID and an amount. This amount will be multipled by the item quality level.\nUse one .Add for each resource type the upgrade should need.")]
		public RequiredResourceList RequiredUpgradeItems => this[""].RequiredUpgradeItems;

		[Description("Specifies the crafting station needed to craft the item.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.\nUse one .Add for each crafting station.")]
		public CraftingStationList Crafting => this[""].Crafting;

		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase? RecipeIsActive
		{
			get
			{
				return this[""].RecipeIsActive;
			}
			set
			{
				this[""].RecipeIsActive = value;
			}
		}

		[Description("Specifies the number of items that should be given to the player with a single craft of the item.\nDefaults to 1.")]
		public int CraftAmount
		{
			get
			{
				return this[""].CraftAmount;
			}
			set
			{
				this[""].CraftAmount = value;
			}
		}

		public bool RequireOnlyOneIngredient
		{
			get
			{
				return this[""].RequireOnlyOneIngredient;
			}
			set
			{
				this[""].RequireOnlyOneIngredient = value;
			}
		}

		public float QualityResultAmountMultiplier
		{
			get
			{
				return this[""].QualityResultAmountMultiplier;
			}
			set
			{
				this[""].QualityResultAmountMultiplier = value;
			}
		}

		public ItemRecipe this[string name]
		{
			get
			{
				if (Recipes.TryGetValue(name, out ItemRecipe value))
				{
					return value;
				}
				return Recipes[name] = new ItemRecipe();
			}
		}

		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				SharedData shared = Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				if (shared.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(shared.m_name);
				}
				else
				{
					string text = "$item_" + ((Object)Prefab).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(shared.m_name);
					shared.m_name = text;
				}
				return _name;
			}
		}

		public LocalizeKey Description
		{
			get
			{
				LocalizeKey description = _description;
				if (description != null)
				{
					return description;
				}
				SharedData shared = Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				if (shared.m_description.StartsWith("$"))
				{
					_description = new LocalizeKey(shared.m_description);
				}
				else
				{
					string text = "$itemdesc_" + ((Object)Prefab).name.Replace(" ", "_");
					_description = new LocalizeKey(text).English(shared.m_description);
					shared.m_description = text;
				}
				return _description;
			}
		}

		private static Localization english => _english ?? (_english = LocalizationCache.ForLanguage("English"));

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		private static object? configSync
		{
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " ItemManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		public Item(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public Item(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName, addToObjectDb: true), skipRegistering: true)
		{
		}

		public Item(GameObject prefab, bool skipRegistering = false)
		{
			if (!skipRegistering)
			{
				PrefabManager.RegisterPrefab(prefab, addToObjectDb: true);
			}
			Prefab = prefab;
			registeredItems.Add(this);
			itemDropMap[Prefab.GetComponent<ItemDrop>()] = this;
			Prefab.GetComponent<ItemDrop>().m_itemData.m_dropPrefab = Prefab;
		}

		public void ToggleConfigurationVisibility(Configurability visible)
		{
			configurationVisible = visible;
			if (itemDropConfigs.TryGetValue(this, out ConfigEntry<string> value))
			{
				Toggle((ConfigEntryBase)(object)value, Configurability.Drop);
			}
			if (itemCraftConfigs.TryGetValue(this, out Dictionary<string, ItemConfig> value2))
			{
				foreach (ItemConfig value4 in value2.Values)
				{
					ToggleObj(value4, Configurability.Recipe);
				}
			}
			foreach (Conversion conversion in Conversions)
			{
				if (conversion.config != null)
				{
					ToggleObj(conversion.config, Configurability.Recipe);
				}
			}
			foreach (KeyValuePair<ConfigEntryBase, Action> statsConfig in statsConfigs)
			{
				Toggle(statsConfig.Key, Configurability.Stats);
				if ((visible & Configurability.Stats) != 0)
				{
					statsConfig.Value();
				}
			}
			reloadConfigDisplay();
			void Toggle(ConfigEntryBase cfg, Configurability check)
			{
				object[] tags = cfg.Description.Tags;
				foreach (object obj2 in tags)
				{
					if (obj2 is ConfigurationManagerAttributes configurationManagerAttributes)
					{
						configurationManagerAttributes.Browsable = (visible & check) != 0 && (configurationManagerAttributes.browsability == null || configurationManagerAttributes.browsability());
					}
				}
			}
			void ToggleObj(object obj, Configurability check)
			{
				FieldInfo[] fields = obj.GetType().GetFields();
				foreach (FieldInfo fieldInfo in fields)
				{
					object? value3 = fieldInfo.GetValue(obj);
					ConfigEntryBase val = (ConfigEntryBase)((value3 is ConfigEntryBase) ? value3 : null);
					if (val != null)
					{
						Toggle(val, check);
					}
				}
			}
		}

		internal static void reloadConfigDisplay()
		{
			object obj = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
			if (obj is bool && (bool)obj)
			{
				configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
			}
		}

		private void UpdateItemTableConfig(string recipeKey, CraftingTable table, string customTableValue)
		{
			if (activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(recipeKey, out List<Recipe> value))
			{
				value.First().m_enabled = table != CraftingTable.Disabled;
				if ((uint)table <= 1u)
				{
					value.First().m_craftingStation = null;
				}
				else if (table == CraftingTable.Custom)
				{
					Recipe obj = value.First();
					GameObject prefab = ZNetScene.instance.GetPrefab(customTableValue);
					obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
				}
				else
				{
					value.First().m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName(table)).GetComponent<CraftingStation>();
				}
			}
		}

		private void UpdateCraftConfig(string recipeKey, SerializedRequirements craftRequirements, SerializedRequirements upgradeRequirements)
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || !activeRecipes.ContainsKey(this) || !activeRecipes[this].TryGetValue(recipeKey, out List<Recipe> value))
			{
				return;
			}
			foreach (Recipe item in value)
			{
				item.m_resources = SerializedRequirements.toPieceReqs(ObjectDB.instance, craftRequirements, upgradeRequirements);
			}
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0eb6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ebb: Unknown result type (might be due to invalid IL or missing references)
			//IL_21b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_21be: Expected O, but got Unknown
			//IL_0f81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f84: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fda: Expected I4, but got Unknown
			//IL_0b9b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba5: Expected O, but got Unknown
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Expected O, but got Unknown
			//IL_1111: Unknown result type (might be due to invalid IL or missing references)
			//IL_1114: Unknown result type (might be due to invalid IL or missing references)
			//IL_1116: Invalid comparison between Unknown and I4
			//IL_1118: Unknown result type (might be due to invalid IL or missing references)
			//IL_111c: Invalid comparison between Unknown and I4
			//IL_0cc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cce: Expected O, but got Unknown
			//IL_0d6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d79: Expected O, but got Unknown
			//IL_111e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1122: Invalid comparison between Unknown and I4
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Expected O, but got Unknown
			//IL_0e23: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e2d: Expected O, but got Unknown
			//IL_1322: Unknown result type (might be due to invalid IL or missing references)
			//IL_1325: Unknown result type (might be due to invalid IL or missing references)
			//IL_1327: Invalid comparison between Unknown and I4
			//IL_1329: Unknown result type (might be due to invalid IL or missing references)
			//IL_132d: Unknown result type (might be due to invalid IL or missing references)
			//IL_132f: Invalid comparison between Unknown and I4
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Expected O, but got Unknown
			//IL_1331: Unknown result type (might be due to invalid IL or missing references)
			//IL_1335: Invalid comparison between Unknown and I4
			//IL_140c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1411: Unknown result type (might be due to invalid IL or missing references)
			//IL_1413: Unknown result type (might be due to invalid IL or missing references)
			//IL_1416: Invalid comparison between Unknown and I4
			//IL_1418: Unknown result type (might be due to invalid IL or missing references)
			//IL_141c: Invalid comparison between Unknown and I4
			//IL_06f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Expected O, but got Unknown
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Expected O, but got Unknown
			//IL_148c: Unknown result type (might be due to invalid IL or missing references)
			//IL_148f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1491: Invalid comparison between Unknown and I4
			//IL_0802: Unknown result type (might be due to invalid IL or missing references)
			//IL_080c: Expected O, but got Unknown
			//IL_1493: Unknown result type (might be due to invalid IL or missing references)
			//IL_1497: Unknown result type (might be due to invalid IL or missing references)
			//IL_1499: Invalid comparison between Unknown and I4
			//IL_149b: Unknown result type (might be due to invalid IL or missing references)
			//IL_149f: Invalid comparison between Unknown and I4
			//IL_15e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_15e5: Invalid comparison between Unknown and I4
			//IL_17e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_17ee: Invalid comparison between Unknown and I4
			//IL_18b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_18be: Unknown result type (might be due to invalid IL or missing references)
			//IL_18c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_18c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_18c6: Invalid comparison between Unknown and I4
			//IL_1936: Unknown result type (might be due to invalid IL or missing references)
			//IL_1939: Unknown result type (might be due to invalid IL or missing references)
			//IL_193b: Invalid comparison between Unknown and I4
			//IL_1557: Unknown result type (might be due to invalid IL or missing references)
			//IL_155c: Unknown result type (might be due to invalid IL or missing references)
			//IL_193d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1941: Invalid comparison between Unknown and I4
			//IL_1943: Unknown result type (might be due to invalid IL or missing references)
			//IL_1947: Invalid comparison between Unknown and I4
			//IL_1dc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1dc5: Invalid comparison between Unknown and I4
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			if (DefaultConfigurability != 0)
			{
				bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
				plugin.Config.SaveOnConfigSet = false;
				foreach (Item item4 in registeredItems.Where((Item i) => i.configurability != Configurability.Disabled))
				{
					Item item3 = item4;
					string name2 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
					string englishName = new Regex("['\\[\"\\]]").Replace(english.Localize(name2), "").Trim();
					string localizedName = Localization.instance.Localize(name2).Trim();
					int order = 0;
					if ((item3.configurability & Configurability.Recipe) != 0)
					{
						itemCraftConfigs[item3] = new Dictionary<string, ItemConfig>();
						foreach (string item5 in item3.Recipes.Keys.DefaultIfEmpty(""))
						{
							string configKey = item5;
							string text = ((configKey == "") ? "" : (" (" + configKey + ")"));
							if (!item3.Recipes.ContainsKey(configKey) || item3.Recipes[configKey].Crafting.Stations.Count <= 0)
							{
								continue;
							}
							ItemConfig itemConfig2 = (itemCraftConfigs[item3][configKey] = new ItemConfig());
							ItemConfig cfg = itemConfig2;
							List<ConfigurationManagerAttributes> hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
							cfg.table = config(englishName, "Crafting Station" + text, item3.Recipes[configKey].Crafting.Stations.First().Table, new ConfigDescription("Crafting station where " + englishName + " is available.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								}
							}));
							ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = CustomTableBrowsability,
								Browsable = (CustomTableBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							cfg.customTable = config(englishName, "Custom Crafting Station" + text, item3.Recipes[configKey].Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
							cfg.table.SettingChanged += TableConfigChanged;
							cfg.customTable.SettingChanged += TableConfigChanged;
							ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = TableLevelBrowsability,
								Browsable = (TableLevelBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							hideWhenNoneAttributes.Add(configurationManagerAttributes);
							cfg.tableLevel = config(englishName, "Crafting Station Level" + text, item3.Recipes[configKey].Crafting.Stations.First().level, new ConfigDescription("Required crafting station level to craft " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }));
							cfg.tableLevel.SettingChanged += delegate
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out List<Recipe> value6))
								{
									value6.First().m_minStationLevel = cfg.tableLevel.Value;
								}
							};
							if (item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1)
							{
								cfg.maximumTableLevel = config(englishName, "Maximum Crafting Station Level" + text, (item3.MaximumRequiredStationLevel == int.MaxValue) ? (item3.Recipes[configKey].Crafting.Stations.First().level + item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality - 1) : item3.MaximumRequiredStationLevel, new ConfigDescription("Maximum crafting station level to upgrade and repair " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }));
							}
							cfg.requireOneIngredient = config(englishName, "Require only one resource" + text, item3.Recipes[configKey].RequireOnlyOneIngredient ? Toggle.On : Toggle.Off, new ConfigDescription("Whether only one of the ingredients is needed to craft " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Category = localizedName
								}
							}));
							ConfigurationManagerAttributes qualityResultAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = QualityResultBrowsability,
								Browsable = (QualityResultBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							cfg.requireOneIngredient.SettingChanged += delegate
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out List<Recipe> value5))
								{
									foreach (Recipe item6 in value5)
									{
										item6.m_requireOnlyOneIngredient = cfg.requireOneIngredient.Value == Toggle.On;
									}
								}
								qualityResultAttributes.Browsable = QualityResultBrowsability();
								reloadConfigDisplay();
							};
							cfg.qualityResultAmountMultiplier = config(englishName, "Quality Multiplier" + text, item3.Recipes[configKey].QualityResultAmountMultiplier, new ConfigDescription("Multiplies the crafted amount based on the quality of the resources when crafting " + englishName + ". Only works, if Require Only One Resource is true.", (AcceptableValueBase)null, new object[1] { qualityResultAttributes }));
							cfg.qualityResultAmountMultiplier.SettingChanged += delegate
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out List<Recipe> value4))
								{
									foreach (Recipe item7 in value4)
									{
										item7.m_qualityResultAmountMultiplier = cfg.qualityResultAmountMultiplier.Value;
									}
								}
							};
							if ((!item3.Recipes[configKey].RequiredItems.Free || item3.Recipes[configKey].RequiredItems.Requirements.Count > 0) && item3.Recipes[configKey].RequiredItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.craft = itemConfig("Crafting Costs" + text, new SerializedRequirements(item3.Recipes[configKey].RequiredItems.Requirements).ToString(), "Item costs to craft " + englishName, isUpgrade: false);
							}
							if (item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1 && (!item3.Recipes[configKey].RequiredUpgradeItems.Free || item3.Recipes[configKey].RequiredUpgradeItems.Requirements.Count > 0) && item3.Recipes[configKey].RequiredUpgradeItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.upgrade = itemConfig("Upgrading Costs" + text, new SerializedRequirements(item3.Recipes[configKey].RequiredUpgradeItems.Requirements).ToString(), "Item costs per level to upgrade " + englishName, isUpgrade: true);
							}
							if (cfg.craft != null)
							{
								cfg.craft.SettingChanged += ConfigChanged;
							}
							if (cfg.upgrade != null)
							{
								cfg.upgrade.SettingChanged += ConfigChanged;
							}
							void ConfigChanged(object o, EventArgs e)
							{
								item3.UpdateCraftConfig(configKey, new SerializedRequirements(cfg.craft?.Value ?? ""), new SerializedRequirements(cfg.upgrade?.Value ?? ""));
							}
							bool CustomTableBrowsability()
							{
								return cfg.table.Value == CraftingTable.Custom;
							}
							bool ItemBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							bool QualityResultBrowsability()
							{
								return cfg.requireOneIngredient.Value == Toggle.On;
							}
							void TableConfigChanged(object o, EventArgs e)
							{
								item3.UpdateItemTableConfig(configKey, cfg.table.Value, cfg.customTable.Value);
								customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
								foreach (ConfigurationManagerAttributes item8 in hideWhenNoneAttributes)
								{
									item8.Browsable = cfg.table.Value != CraftingTable.Disabled;
								}
								reloadConfigDisplay();
							}
							bool TableLevelBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							ConfigEntry<string> itemConfig(string name, string value, string desc, bool isUpgrade)
							{
								//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
								//IL_00b1: Expected O, but got Unknown
								ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes
								{
									CustomDrawer = drawRequirementsConfigTable(item3, isUpgrade),
									Order = (order -= 1),
									browsability = ItemBrowsability,
									Browsable = (ItemBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								};
								hideWhenNoneAttributes.Add(configurationManagerAttributes3);
								return config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes3 }));
							}
						}
						if ((item3.configurability & Configurability.Drop) != 0)
						{
							ConfigEntry<string> val3 = (itemDropConfigs[item3] = config(englishName, "Drops from", new SerializedDrop(item3.DropsFrom.Drops).ToString(), new ConfigDescription(englishName + " drops from this creature.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									CustomDrawer = drawDropsConfigTable,
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Drop) != 0)
								}
							})));
							ConfigEntry<string> val4 = val3;
							val4.SettingChanged += delegate
							{
								item3.UpdateCharacterDrop();
							};
						}
						for (int j = 0; j < item3.Conversions.Count; j++)
						{
							string text2 = ((item3.Conversions.Count > 1) ? $"{j + 1}. " : "");
							Conversion conversion = item3.Conversions[j];
							conversion.config = new Conversion.ConversionConfig();
							int index = j;
							conversion.config.input = config(englishName, text2 + "Conversion Input Item", conversion.Input, new ConfigDescription("Input item to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.input.SettingChanged += delegate
							{
								if (index < item3.conversions.Count)
								{
									ObjectDB instance = ObjectDB.instance;
									if (instance != null)
									{
										ItemDrop from = SerializedRequirements.fetchByName(instance, conversion.config.input.Value);
										item3.conversions[index].m_from = from;
										UpdatePiece();
									}
								}
							};
							conversion.config.piece = config(englishName, text2 + "Conversion Piece", conversion.Piece, new ConfigDescription("Conversion piece used to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.piece.SettingChanged += delegate
							{
								UpdatePiece();
							};
							conversion.config.customPiece = config(englishName, text2 + "Conversion Custom Piece", conversion.customPiece ?? "", new ConfigDescription("Custom conversion piece to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.customPiece.SettingChanged += delegate
							{
								UpdatePiece();
							};
							void UpdatePiece()
							{
								if (index < item3.conversions.Count && Object.op_Implicit((Object)(object)ZNetScene.instance))
								{
									string text3 = ((conversion.config.piece.Value == ConversionPiece.Disabled) ? null : ((conversion.config.piece.Value == ConversionPiece.Custom) ? conversion.config.customPiece.Value : getInternalName(conversion.config.piece.Value)));
									string activePiece = conversion.config.activePiece;
									if (conversion.config.activePiece != null)
									{
										Smelter component = ZNetScene.instance.GetPrefab(conversion.config.activePiece).GetComponent<Smelter>();
										int num = component.m_conversion.IndexOf(item3.conversions[index]);
										if (num >= 0)
										{
											Smelter[] array3 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val6 in array3)
											{
												if (Utils.GetPrefabName(((Component)val6).gameObject) == activePiece)
												{
													val6.m_conversion.RemoveAt(num);
												}
											}
										}
										conversion.config.activePiece = null;
									}
									if (item3.conversions[index].m_from != null && conversion.config.piece.Value != 0)
									{
										GameObject prefab = ZNetScene.instance.GetPrefab(text3);
										if (((prefab != null) ? prefab.GetComponent<Smelter>() : null) != null)
										{
											conversion.config.activePiece = text3;
											Smelter[] array4 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val7 in array4)
											{
												if (Utils.GetPrefabName(((Component)val7).gameObject) == text3)
												{
													val7.m_conversion.Add(item3.conversions[index]);
												}
											}
										}
									}
								}
							}
						}
					}
					if ((item3.configurability & Configurability.Stats) != 0)
					{
						item3.statsConfigs.Clear();
						SharedData shared2 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ItemType itemType = shared2.m_itemType;
						statcfg<float>("Weight", "Weight of " + englishName + ".", (SharedData shared) => shared.m_weight, delegate(SharedData shared, float value)
						{
							shared.m_weight = value;
						});
						statcfg<int>("Trader Value", "Trader value of " + englishName + ".", (SharedData shared) => shared.m_value, delegate(SharedData shared, int value)
						{
							shared.m_value = value;
						});
						bool flag;
						switch (itemType - 3)
						{
						case 0:
						case 1:
						case 2:
						case 3:
						case 4:
						case 8:
						case 9:
						case 11:
						case 14:
						case 16:
						case 19:
							flag = true;
							break;
						default:
							flag = false;
							break;
						}
						if (flag)
						{
							statcfg<float>("Durability", "Durability of " + englishName + ".", (SharedData shared) => shared.m_maxDurability, delegate(SharedData shared, float value)
							{
								shared.m_maxDurability = value;
							});
							statcfg<float>("Durability per Level", "Durability gain per level of " + englishName + ".", (SharedData shared) => shared.m_durabilityPerLevel, delegate(SharedData shared, float value)
							{
								shared.m_durabilityPerLevel = value;
							});
							statcfg<float>("Movement Speed Modifier", "Movement speed modifier of " + englishName + ".", (SharedData shared) => shared.m_movementModifier, delegate(SharedData shared, float value)
							{
								shared.m_movementModifier = value;
							});
						}
						if ((itemType - 3 <= 2 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Block Armor", "Block armor of " + englishName + ".", (SharedData shared) => shared.m_blockPower, delegate(SharedData shared, float value)
							{
								shared.m_blockPower = value;
							});
							statcfg<float>("Block Armor per Level", "Block armor per level for " + englishName + ".", (SharedData shared) => shared.m_blockPowerPerLevel, delegate(SharedData shared, float value)
							{
								shared.m_blockPowerPerLevel = value;
							});
							statcfg<float>("Block Force", "Block force of " + englishName + ".", (SharedData shared) => shared.m_deflectionForce, delegate(SharedData shared, float value)
							{
								shared.m_deflectionForce = value;
							});
							statcfg<float>("Block Force per Level", "Block force per level for " + englishName + ".", (SharedData shared) => shared.m_deflectionForcePerLevel, delegate(SharedData shared, float value)
							{
								shared.m_deflectionForcePerLevel = value;
							});
							statcfg<float>("Parry Bonus", "Parry bonus of " + englishName + ".", (SharedData shared) => shared.m_timedBlockBonus, delegate(SharedData shared, float value)
							{
								shared.m_timedBlockBonus = value;
							});
						}
						else if ((itemType - 6 <= 1 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							statcfg<float>("Armor", "Armor of " + englishName + ".", (SharedData shared) => shared.m_armor, delegate(SharedData shared, float value)
							{
								shared.m_armor = value;
							});
							statcfg<float>("Armor per Level", "Armor per level for " + englishName + ".", (SharedData shared) => shared.m_armorPerLevel, delegate(SharedData shared, float value)
							{
								shared.m_armorPerLevel = value;
							});
						}
						SkillType skillType = shared2.m_skillType;
						if (((int)skillType == 7 || (int)skillType == 12) ? true : false)
						{
							statcfg<int>("Tool tier", "Tool tier of " + englishName + ".", (SharedData shared) => shared.m_toolTier, delegate(SharedData shared, int value)
							{
								shared.m_toolTier = value;
							});
						}
						if ((itemType - 5 <= 2 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							Dictionary<DamageType, DamageModifier> modifiers = shared2.m_damageModifiers.ToDictionary((DamageModPair d) => d.m_type, (DamageModPair d) => (DamageModifier)d.m_modifier);
							DamageType[] first = (DamageType[])Enum.GetValues(typeof(DamageType));
							DamageType[] array = new DamageType[5];
							RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
							foreach (DamageType item9 in first.Except(new <>z__ReadOnlyArray<DamageType>((DamageType[])(object)array)))
							{
								DamageType damageType = item9;
								statcfg<DamageModifier>(((object)(DamageType)(ref damageType)).ToString() + " Resistance", ((object)(DamageType)(ref damageType)).ToString() + " resistance of " + englishName + ".", (SharedData _) => (!modifiers.TryGetValue(damageType, out var value3)) ? DamageModifier.None : value3, delegate(SharedData shared, DamageModifier value)
								{
									//IL_0002: Unknown result type (might be due to invalid IL or missing references)
									//IL_000b: Unknown result type (might be due to invalid IL or missing references)
									//IL_0010: 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)
									//IL_001d: 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_002a: Unknown result type (might be due to invalid IL or missing references)
									//IL_002f: Unknown result type (might be due to invalid IL or missing references)
									//IL_0035: Unknown result type (might be due to invalid IL or missing references)
									//IL_0077: Unknown result type (might be due to invalid IL or missing references)
									//IL_0054: Unknown result type (might be due to invalid IL or missing references)
									DamageModPair val8 = default(DamageModPair);
									val8.m_type = damageType;
									val8.m_modifier = (DamageModifier)value;
									DamageModPair val9 = val8;
									for (int num2 = 0; num2 < shared.m_damageModifiers.Count; num2++)
									{
										if (shared.m_damageModifiers[num2].m_type == damageType)
										{
											if (value == DamageModifier.None)
											{
												shared.m_damageModifiers.RemoveAt(num2);
											}
											else
											{
												shared.m_damageModifiers[num2] = val9;
											}
											return;
										}
									}
									if (value != DamageModifier.None)
									{
										shared.m_damageModifiers.Add(val9);
									}
								});
							}
						}
						if ((int)itemType == 2 && shared2.m_food > 0f)
						{
							statcfg<float>("Health", "Health value of " + englishName + ".", (SharedData shared) => shared.m_food, delegate(SharedData shared, float value)
							{
								shared.m_food = value;
							});
							statcfg<float>("Stamina", "Stamina value of " + englishName + ".", (SharedData shared) => shared.m_foodStamina, delegate(SharedData shared, float value)
							{
								shared.m_foodStamina = value;
							});
							statcfg<float>("Eitr", "Eitr value of " + englishName + ".", (SharedData shared) => shared.m_foodEitr, delegate(SharedData shared, float value)
							{
								shared.m_foodEitr = value;
							});
							statcfg<float>("Duration", "Duration of " + englishName + ".", (SharedData shared) => shared.m_foodBurnTime, delegate(SharedData shared, float value)
							{
								shared.m_foodBurnTime = value;
							});
							statcfg<float>("Health Regen", "Health regen value of " + englishName + ".", (SharedData shared) => shared.m_foodRegen, delegate(SharedData shared, float value)
							{
								shared.m_foodRegen = value;
							});
						}
						if ((int)shared2.m_skillType == 10)
						{
							statcfg<float>("Health Cost", "Health cost of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackHealth, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackHealth = value;
							});
							statcfg<float>("Health Cost Percentage", "Health cost percentage of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackHealthPercentage, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackHealthPercentage = value;
							});
						}
						skillType = shared2.m_skillType;
						if (skillType - 9 <= 1)
						{
							statcfg<float>("Eitr Cost", "Eitr cost of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackEitr, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackEitr = value;
							});
						}
						if ((itemType - 3 <= 1 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Knockback", "Knockback of " + englishName + ".", (SharedData shared) => shared.m_attackForce, delegate(SharedData shared, float value)
							{
								shared.m_attackForce = value;
							});
							statcfg<float>("Backstab Bonus", "Backstab bonus of " + englishName + ".", (SharedData shared) => shared.m_backstabBonus, delegate(SharedData shared, float value)
							{
								shared.m_backstabBonus = value;
							});
							statcfg<float>("Attack Stamina", "Attack stamina of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackStamina, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackStamina = value;
							});
							SetDmg("True", (DamageTypes dmg) => dmg.m_damage, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_damage = val;
							});
							SetDmg("Slash", (DamageTypes dmg) => dmg.m_slash, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_slash = val;
							});
							SetDmg("Pierce", (DamageTypes dmg) => dmg.m_pierce, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pierce = val;
							});
							SetDmg("Blunt", (DamageTypes dmg) => dmg.m_blunt, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_blunt = val;
							});
							SetDmg("Chop", (DamageTypes dmg) => dmg.m_chop, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_chop = val;
							});
							SetDmg("Pickaxe", (DamageTypes dmg) => dmg.m_pickaxe, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pickaxe = val;
							});
							SetDmg("Fire", (DamageTypes dmg) => dmg.m_fire, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_fire = val;
							});
							SetDmg("Poison", (DamageTypes dmg) => dmg.m_poison, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_poison = val;
							});
							SetDmg("Frost", (DamageTypes dmg) => dmg.m_frost, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_frost = val;
							});
							SetDmg("Lightning", (DamageTypes dmg) => dmg.m_lightning, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_lightning = val;
							});
							SetDmg("Spirit", (DamageTypes dmg) => dmg.m_spirit, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_spirit = val;
							});
							if ((int)itemType == 4)
							{
								statcfg<int>("Projectiles", "Number of projectiles that " + englishName + " shoots at once.", (SharedData shared) => shared.m_attack.m_projectileBursts, delegate(SharedData shared, int value)
								{
									shared.m_attack.m_projectileBursts = value;
								});
								statcfg<float>("Burst Interval", "Time between the projectiles " + englishName + " shoots at once.", (SharedData shared) => shared.m_attack.m_burstInterval, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_burstInterval = value;
								});
								statcfg<float>("Minimum Accuracy", "Minimum accuracy for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileAccuracyMin, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileAccuracyMin = value;
								});
								statcfg<float>("Accuracy", "Accuracy for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileAccuracy, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileAccuracy = value;
								});
								statcfg<float>("Minimum Velocity", "Minimum velocity for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileVelMin, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileVelMin = value;
								});
								statcfg<float>("Velocity", "Velocity for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileVel, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileVel = value;
								});
								statcfg<float>("Maximum Draw Time", "Time until " + englishName + " is fully drawn at skill level 0.", (SharedData shared) => shared.m_attack.m_drawDurationMin, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_drawDurationMin = value;
								});
								statcfg<float>("Stamina Drain", "Stamina drain per second while drawing " + englishName + ".", (SharedData shared) => shared.m_attack.m_drawStaminaDrain, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_drawStaminaDrain = value;
								});
							}
						}
					}
					List<ConfigurationManagerAttributes> traderAttributes;
					if ((item3.configurability & Configurability.Trader) != 0)
					{
						traderAttributes = new List<ConfigurationManagerAttributes>();
						item3.traderConfig = new TraderConfig
						{
							trader = config(englishName, "Trader Selling", item3.Trade.Trader, new ConfigDescription("Which traders sell " + englishName + ".", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item3.configurationVisible & Configurability.Trader) != 0),
									Category = localizedName
								}
							}))
						};
						item3.traderConfig.trader.SettingChanged += delegate
						{
							item3.ReloadTraderConfiguration();
							foreach (ConfigurationManagerAttributes item10 in traderAttributes)
							{
								item10.Browsable = TraderBrowsability();
							}
							reloadConfigDisplay();
						};
						item3.traderConfig.price = traderConfig<uint>("Trader Price", item3.Trade.Price, "Price of " + englishName + " at the trader.");
						item3.traderConfig.stack = traderConfig<uint>("Trader Stack", item3.Trade.Stack, "Stack size of " + englishName + " in the trader. Also known as the number of items sold by a trader in one transaction.");
						item3.traderConfig.requiredGlobalKey = traderConfig<string>("Trader Required Global Key", item3.Trade.RequiredGlobalKey ?? "", "Required global key to unlock " + englishName + " at the trader.");
						if (item3.traderConfig.trader.Value != 0)
						{
							PrefabManager.AddItemToTrader(item3.Prefab, item3.traderConfig.trader.Value, item3.traderConfig.price.Value, item3.traderConfig.stack.Value, item3.traderConfig.requiredGlobalKey.Value);
						}
					}
					else if (item3.Trade.Trader != 0)
					{
						PrefabManager.AddItemToTrader(item3.Prefab, item3.Trade.Trader, item3.Trade.Price, item3.Trade.Stack, item3.Trade.RequiredGlobalKey);
					}
					void SetDmg(string dmgType, Func<DamageTypes, float> readDmg, setDmgFunc setDmg)
					{
						Func<DamageTypes, float> readDmg2 = readDmg;
						setDmgFunc setDmg2 = setDmg;
						statcfg<float>(dmgType + " Damage", dmgType + " damage dealt by " + englishName + ".", (SharedData shared) => readDmg2(shared.m_damages), delegate(SharedData shared, float val)
						{
							setDmg2(ref shared.m_damages, val);
						});
						statcfg<float>(dmgType + " Damage Per Level", dmgType + " damage dealt increase per level for " + englishName + ".", (SharedData shared) => readDmg2(shared.m_damagesPerLevel), delegate(SharedData shared, float val)
						{
							setDmg2(ref shared.m_damagesPerLevel, val);
						});
					}
					bool TraderBrowsability()
					{
						return item3.traderConfig.trader.Value != Trader.None;
					}
					void statcfg<T>(string configName, string description, Func<SharedData, T> readDefault, Action<SharedData, T> setValue) where T : notnull
					{
						//IL_0078: Unknown result type (might be due to invalid IL or missing references)
						//IL_0082: Expected O, but got Unknown
						Action<SharedData, T> setValue2 = setValue;
						SharedData shared3 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ConfigEntry<T> cfg2 = config(englishName, configName, readDefault(shared3), new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
						{
							new ConfigurationManagerAttributes
							{
								Category = localizedName,
								Browsable = ((item3.configurationVisible & Configurability.Stats) != 0)
							}
						}));
						if ((item3.configurationVisible & Configurability.Stats) != 0)
						{
							setValue2(shared3, cfg2.Value);
						}
						item3.statsConfigs.Add((ConfigEntryBase)(object)cfg2, ApplyConfig);
						cfg2.SettingChanged += delegate
						{
							if ((item3.configurationVisible & Configurability.Stats) != 0)
							{
								ApplyConfig();
							}
						};
						void ApplyConfig()
						{
							item3.ApplyToAllInstances(delegate(ItemData item)
							{
								setValue2(item.m_shared, cfg2.Value);
							});
						}
					}
					ConfigEntry<T> traderConfig<T>(string name, T value, string desc) where T : notnull
					{
						//IL_0099: Unknown result type (might be due to invalid IL or missing references)
						//IL_00a3: Expected O, but got Unknown
						ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes
						{
							Order = (order -= 1),
							browsability = TraderBrowsability,
							Browsable = (TraderBrowsability() && (item3.configurationVisible & Configurability.Trader) != 0),
							Category = localizedName
						};
						traderAttributes.Add(configurationManagerAttributes2);
						ConfigEntry<T> val5 = config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes2 }));
						val5.SettingChanged += delegate
						{
							item3.ReloadTraderConfiguration();
						};
						return val5;
					}
				}
				if (saveOnConfigSet)
				{
					plugin.Config.SaveOnConfigSet = true;
					plugin.Config.Save();
				}
			}
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			foreach (Item registeredItem in registeredItems)
			{
				Item item2 = registeredItem;
				foreach (KeyValuePair<string, ItemRecipe> recipe in item2.Recipes)
				{
					KeyValuePair<string, ItemRecipe> kv = recipe;
					RequiredResourceList[] array2 = new RequiredResourceList[2]
					{
						kv.Value.RequiredItems,
						kv.Value.RequiredUpgradeItems
					};
					foreach (RequiredResourceList requiredResourceList in array2)
					{
						for (int l = 0; l < requiredResourceList.Requirements.Count; l++)
						{
							ConfigEntry<int> amountCfg;
							int resourceIndex;
							if ((item2.configurability & Configurability.Recipe) != 0)
							{
								amountCfg = requiredResourceList.Requirements[l].amountConfig;
								if (amountCfg != null)
								{
									resourceIndex = l;
									amountCfg.SettingChanged += ConfigChanged;
								}
							}
							void ConfigChanged(object o, EventArgs e)
							{
								if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(item2) && activeRecipes[item2].TryGetValue(kv.Key, out List<Recipe> value2))
								{
									foreach (Recipe item11 in value2)
									{
										item11.m_resources[resourceIndex].m_amount = amountCfg.Value;
									}
								}
							}
						}
					}
				}
				item2.InitializeNewRegisteredItem();
			}
		}

		private void InitializeNewRegisteredItem()
		{
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				KeyValuePair<string, ItemRecipe> kv = recipe;
				ConfigEntryBase enabledCfg = kv.Value.RecipeIsActive;
				if (enabledCfg != null)
				{
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				void ConfigChanged(object o, EventArgs e)
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(kv.Key, out List<Recipe> value))
					{
						foreach (Recipe item in value)
						{
							item.m_enabled = (int)enabledCfg.BoxedValue != 0;
						}
					}
				}
			}
		}

		public void ReloadCraftingConfiguration()
		{
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name)) == null)
			{
				registerRecipesInObjectDB(ObjectDB.instance);
				ObjectDB.instance.m_items.Add(Prefab);
				ObjectDB.instance.m_itemByHash.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
				ZNetScene.instance.m_prefabs.Add(Prefab);
				ZNetScene.instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
			}
			foreach (string item in Recipes.Keys.DefaultIfEmpty(""))
			{
				if (Recipes.TryGetValue(item, out ItemRecipe value) && value.Crafting.Stations.Count > 0)
				{
					UpdateItemTableConfig(item, value.Crafting.Stations.First().Table, value.Crafting.Stations.First().custom ?? "");
					UpdateCraftConfig(item, new SerializedRequirements(value.RequiredItems.Requirements), new SerializedRequirements(value.RequiredUpgradeItems.Requirements));
				}
			}
		}

		private void ReloadTraderConfiguration()
		{
			if (traderConfig.trader.Value == Trader.None)
			{
				PrefabManager.RemoveItemFromTrader(Prefab);
			}
			else
			{
				PrefabManager.AddItemToTrader(Prefab, traderConfig.trader.Value, traderConfig.price.Value, traderConfig.stack.Value, traderConfig.requiredGlobalKey.Value);
			}
		}

		public static void ApplyToAllInstances(GameObject prefab, Action<ItemData> callback)
		{
			callback(prefab.GetComponent<ItemDrop>().m_itemData);
			string name = prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
			Inventory[] source = (from c in Player.s_players.Select((Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsOfType<Container>()
					select c.GetInventory())
				where c != null
				select c).ToArray();
			foreach (ItemData item in (from i in (from p in ObjectDB.instance.m_items
					select p.GetComponent<ItemDrop>() into c
					where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
					select c).Concat(ItemDrop.s_instances)
				select i.m_itemData).Concat(source.SelectMany((Inventory i) => i.GetAllItems())))
			{
				if (item.m_shared.m_name == name)
				{
					callback(item);
				}
			}
		}

		public void ApplyToAllInstances(Action<ItemData> callback)
		{
			ApplyToAllInstances(Prefab, callback);
		}

		private static string getInternalName<T>(T value) where T : struct
		{
			return ((InternalName)typeof(T).GetMember(value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
		}

		private void registerRecipesInObjectDB(ObjectDB objectDB)
		{
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Expected O, but got Unknown
			activeRecipes[this] = new Dictionary<string, List<Recipe>>();
			itemCraftConfigs.TryGetValue(this, out Dictionary<string, ItemConfig> value);
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				List<Recipe> list = new List<Recipe>();
				foreach (CraftingStationConfig station in recipe.Value.Crafting.Stations)
				{
					ItemConfig itemConfig = value?[recipe.Key];
					Recipe val = ScriptableObject.CreateInstance<Recipe>();
					string name = ((Object)Prefab).name;
					CraftingTable table = station.Table;
					((Object)val).name = name + "_Recipe_" + table;
					val.m_amount = recipe.Value.CraftAmount;
					bool enabled;
					if (itemConfig != null)
					{
						enabled = itemConfig.table.Value != CraftingTable.Disabled;
					}
					else
					{
						ConfigEntryBase? recipeIsActive = recipe.Value.RecipeIsActive;
						enabled = (int)(((recipeIsActive != null) ? recipeIsActive.BoxedValue : null) ?? ((object)1)) != 0;
					}
					val.m_enabled = enabled;
					val.m_item = Prefab.GetComponent<ItemDrop>();
					val.m_resources = SerializedRequirements.toPieceReqs(objectDB, (itemConfig?.craft == null) ? new SerializedRequirements(recipe.Value.RequiredItems.Requirements) : new SerializedRequirements(itemConfig.craft.Value), (itemConfig?.upgrade == null) ? new SerializedRequirements(recipe.Value.RequiredUpgradeItems.Requirements) : new SerializedRequirements(itemConfig.upgrade.Value));
					table = ((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value);
					if ((uint)table <= 1u)
					{
						val.m_craftingStation = null;
					}
					else if (((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value) == CraftingTable.Custom)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value);
						if (prefab != null)
						{
							val.m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)$"Custom crafting station '{((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value)}' does not exist ({Prefab})");
						}
					}
					else
					{
						val.m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value)).GetComponent<CraftingStation>();
					}
					val.m_minStationLevel = ((itemConfig == null || list.Count > 0) ? station.level : itemConfig.tableLevel.Value);
					val.m_requireOnlyOneIngredient = ((itemConfig == null) ? recipe.Value.RequireOnlyOneIngredient : (itemConfig.requireOneIngredient.Value == Toggle.On));
					val.m_qualityResultAmountMultiplier = itemConfig?.qualityResultAmountMultiplier.Value ?? recipe.Value.QualityResultAmountMultiplier;
					list.Add(val);
					RequiredResourceList requiredItems = recipe.Value.RequiredItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenCraftRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
					requiredItems = recipe.Value.RequiredUpgradeItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenUpgradeRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
				}
				activeRecipes[this].Add(recipe.Key, list);
				objectDB.m_recipes.AddRange(list);
			}
			conversions = new List<ItemConversion>();
			for (int i = 0; i < Conversions.Count; i++)
			{
				Conversion conversion = Conversions[i];
				conversions.Add(new ItemConversion
				{
					m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
					m_to = Prefab.GetComponent<ItemDrop>()
				});
				ConversionPiece conversionPiece = conversion.config?.piece.Value ?? conversion.Piece;
				string text = null;
				if (conversionPiece != 0 && conversions[i].m_from != null)
				{
					text = ((conversionPiece != ConversionPiece.Custom) ? getInternalName(conversionPiece) : (conversion.config?.customPiece.Value ?? conversion.customPiece));
					GameObject prefab2 = ZNetScene.instance.GetPrefab(text);
					Smelter val2 = ((prefab2 != null) ? prefab2.GetComponent<Smelter>() : null);
					if (val2 != null)
					{
						val2.m_conversion.Add(conversions[i]);
					}
					else
					{
						text = null;
					}
				}
				if (conversion.config != null)
				{
					conversion.config.activePiece = text;
				}
			}
		}

		[HarmonyPriority(0)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			if ((Object)(object)__instance.GetItemPrefab("Wood") == (Object)null)
			{
				return;
			}
			hiddenCraftRecipes.Clear();
			hiddenUpgradeRecipes.Clear();
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.registerRecipesInObjectDB(__instance);
			}
		}

		internal static void Patch_TraderGetAvailableItems(Trader __instance, ref List<TradeItem> __result)
		{
			string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
			Trader trader2 = ((prefabName == "Haldor") ? Trader.Haldor : ((prefabName == "Hildir") ? Trader.Hildir : Trader.None));
			Trader trader = trader2;
			__result.AddRange(from tuple in PrefabManager.CustomTradeItems.Values
				where (tuple.Item1 & trader) != 0
				select tuple.Item2 into tradeItem
				where string.IsNullOrEmpty(tradeItem.m_requiredGlobalKey) || ZoneSystem.instance.GetGlobalKey(tradeItem.m_requiredGlobalKey)
				select tradeItem);
		}

		internal static void Patch_OnAddSmelterInput(ItemData item, bool __result)
		{
			if (__result)
			{
				((Humanoid)Player.m_localPlayer).UnequipItem(item, true);
			}
		}

		internal static void Patch_MaximumRequiredStationLevel(Recipe __instance, ref int __result, int quality)
		{
			if (!itemDropMap.TryGetValue(__instance.m_item, out Item value))
			{
				return;
			}
			IEnumerable<ItemConfig> source;
			if (!itemCraftConfigs.TryGetValue(value, out Dictionary<string, ItemConfig> value2))
			{
				source = Array.Empty<ItemConfig>();
			}
			else
			{
				CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
				if (currentCraftingStation != null)
				{
					string stationName = Utils.GetPrefabName(((Component)currentCraftingStation).gameObject);
					source = from c in value2.Where(delegate(KeyValuePair<string, ItemConfig> c)
						{
							switch (c.Value.table.Value)
							{
							case CraftingTable.Disabled:
							case CraftingTable.Inventory:
								return false;
							case CraftingTable.Custom:
								return c.Value.customTable.Value == stationName;
							default:
								return getInternalName(c.Value.table.Value) == stationName;
							}
						})
						select c.Value;
				}
				else
				{
					source = value2.Values;
				}
			}
			__result = Mathf.Min(Mathf.Max(1, __instance.m_minStationLevel) + (quality - 1), (from cfg in source
				where cfg.maximumTableLevel != null
				select cfg.maximumTableLevel.Value).DefaultIfEmpty(value.MaximumRequiredStationLevel).Max());
		}

		internal static void Patch_GetAvailableRecipesPrefix(ref Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase?>>? __state)
		{
			if (__state == null)
			{
				__state = new Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>>();
			}
			Dictionary<Recipe, ConfigEntryBase> dictionary;
			if (InventoryGui.instance.InCraftTab())
			{
				dictionary = hiddenCraftRecipes;
			}
			else
			{
				if (!InventoryGui.instance.InUpradeTab())
				{
					return;
				}
				dictionary = hiddenUpgradeRecipes;
			}
			foreach (Recipe key in dictionary.Keys)
			{
				key.m_enabled = false;
			}
			__state[Assembly.GetExecutingAssembly()] = dictionary;
		}

		internal static void Patch_GetAvailableRecipesFinalizer(Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase?>> __state)
		{
			if (!__state.TryGetValue(Assembly.GetExecutingAssembly(), out Dictionary<Recipe, ConfigEntryBase> value))
			{
				return;
			}
			foreach (KeyValuePair<Recipe, ConfigEntryBase> item in value)
			{
				Recipe key = item.Key;
				ConfigEntryBase value2 = item.Value;
				key.m_enabled = (int)(((value2 != null) ? value2.BoxedValue : null) ?? ((object)1)) != 0;
			}
		}

		internal static IEnumerable<CodeInstruction> Transpile_SetupRequirementList(IEnumerable<CodeInstruction> instructionsEnumerable, ILGenerator ilg)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Expected O, but got Unknown
			List<CodeInstruction> list = instructionsEnumerable.ToList();
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirement", (Type[])null, (Type[])null);
			CodeInstruction val = null;
			CodeInstruction val2 = null;
			LocalBuilder localBuilder = ilg.DeclareLocal(typeof(int));
			Dictionary<Label, int> dictionary = new Dictionary<Label, int>();
			bool flag = false;
			int num = 0;
			int value = 0;
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					val = list[i + 2];
					val2 = list[i + 5];
					flag = true;
				}
				if (flag)
				{
					if (CodeInstructionExtensions.Branches(list[i], ref label) && dictionary.TryGetValue(label.Value, out value))
					{
						num = i;
						break;
					}
					continue;
				}
				foreach (Label label4 in list[i].labels)
				{
					dictionary[label4] = i;
				}
			}
			if (list[value - 3].opcode == OpCodes.Dup)
			{
				return list;
			}
			Label label2 = ilg.DefineLabel();
			Label label3 = ilg.DefineLabel();
			list[num + 1].labels.Add(label2);
			list.InsertRange(num + 1, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[11]
			{
				new CodeInstruction(OpCodes.Ldloc, (object)localBuilder),
				new CodeInstruction(OpCodes.Brfalse, (object)label2),
				val.Clone(),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(InventoryGui), "m_recipeRequirementList")),
				new CodeInstruction(OpCodes.Ldlen, (object)null),
				new CodeInstruction(OpCodes.Bgt, (object)label2),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				val2.Clone(),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				new CodeInstruction(OpCodes.Br, (object)label3)
			}));
			list.InsertRange(value - 2, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Dup, (object)null)
				{
					labels = new List<Label>(1) { label3 }
				},
				new CodeInstruction(OpCodes.Stloc, (object)localBuilder)
			}));
			return list;
		}

		internal static bool Patch_RequirementGetAmount(Requirement __instance, int qualityLevel, ref int __result)
		{
			if (requirementQuality.TryGetValue(__instance, out RequirementQuality value))
			{
				__result = ((value.quality == qualityLevel) ? __instance.m_amountPerLevel : 0);
				return false;
			}
			return true;
		}

		internal static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.AssignDropToCreature();
			}
		}

		public void AssignDropToCreature()
		{
			foreach (KeyValuePair<CharacterDrop, Drop> characterDrop in characterDrops)
			{
				if (Object.op_Implicit((Object)(object)characterDrop.Key))
				{
					characterDrop.Key.m_drops.Remove(characterDrop.Value);
				}
			}
			characterDrops.Clear();
			SerializedDrop serializedDrop = new SerializedDrop(DropsFrom.Drops);
			if (itemDropConfigs.TryGetValue(this, out ConfigEntry<string> value))
			{
				serializedDrop = new SerializedDrop(value.Value);
			}
			foreach (KeyValuePair<Character, Drop> item in serializedDrop.toCharacterDrops(ZNetScene.s_instance, Prefab))
			{
				CharacterDrop val = ((Component)item.Key).GetComponent<CharacterDrop>();
				if (val == null)
				{
					val = ((Component)item.Key).gameObject.AddComponent<CharacterDrop>();
				}
				val.m_drops.Add(item.Value);
				characterDrops.Add(val, item.Value);
			}
		}

		public void UpdateCharacterDrop()
		{
			if (Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				AssignDropToCreature();
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			SnapshotItem(Prefab.GetComponent<ItemDrop>(), lightIntensity, cameraRotation, itemRotation);
		}

		public static void SnapshotItem(ItemDrop item, float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			<>c__DisplayClass83_0 CS$<>8__locals0 = new <>c__DisplayClass83_0();
			CS$<>8__locals0.cameraRotation = cameraRotation;
			CS$<>8__locals0.lightIntensity = lightIntensity;
			CS$<>8__locals0.item = item;
			CS$<>8__locals0.itemRotation = itemRotation;
			if (Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				Do();
			}
			else
			{
				((MonoBehaviour)plugin).StartCoroutine(Delay());
			}
			[IteratorStateMachine(typeof(<>c__DisplayClass83_0.<<SnapshotItem>g__Delay|1>d))]
			IEnumerator Delay()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass83_0.<<SnapshotItem>g__Delay|1>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
			void Do()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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)
				//IL_007c: 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)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: 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_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: 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_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_0208: 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_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_0248: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_0288: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_029b: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_032b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0332: Expected O, but got Unknown
				//IL_0334: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_036f: Unknown result type (might be due to invalid IL or missing references)
				Camera component = new GameObject("Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				component.fieldOfView = 0.5f;
				component.farClipPlane = 10000000f;
				component.cullingMask = 1073741824;
				((Component)component).transform.rotation = (Quaternion)(((??)CS$<>8__locals0.cameraRotation) ?? Quaternion.Euler(90f, 0f, 45f));
				Light component2 = new GameObject("Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.rotation = Quaternion.Euler(150f, 0f, -5f);
				component2.type = (LightType)1;
				component2.cullingMask = 1073741824;
				component2.intensity = CS$<>8__locals0.lightIntensity;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(0f, 0f, 64f, 64f);
				Transform val2 = ((Component)CS$<>8__locals0.item).transform.Find("attach");
				GameObject val3;
				if (val2 != null)
				{
					val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
				}
				else
				{
					ZNetView.m_forceDisableInit = true;
					val3 = Object.Instantiate<GameObject>(((Component)CS$<>8__locals0.item).gameObject);
					ZNetView.m_forceDisableInit = false;
				}
				if (CS$<>8__locals0.itemRotation.HasValue)
				{
					val3.transform.rotation = CS$<>8__locals0.itemRotation.Value;
				}
				Transform[] componentsInChildren = val3.GetComponentsInChildren<Transform>();
				foreach (Transform val4 in componentsInChildren)
				{
					((Component)val4).gameObject.layer = 30;
				}
				Renderer[] componentsInChildren2 = val3.GetComponentsInChildren<Renderer>();
				Vector3 val5 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.positiveInfinity, delegate(Vector3 cur, Renderer renderer)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: 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)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds2 = renderer.bounds;
						return Vector3.Min(cur, ((Bounds)(ref bounds2)).min);
					}
					return cur;
				});
				Vector3 val6 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.negativeInfinity, delegate(Vector3 cur, Renderer renderer)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: 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)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds = renderer.bounds;
						return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
					}
					return cur;
				});
				Vector3 val7 = val6 - val5;
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height);
				float num = Mathf.Max(val7.x, val7.z);
				float num2 = Mathf.Min(val7.x, val7.z);
				float num3 = (num + num2) / Mathf.Sqrt(2f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f));
				Transform transform = ((Component)component).transform;
				Vector3 val8 = (val5 + val6) / 2f;
				val8.y = val6.y;
				transform.position = val8 + new Vector3(0f, num3, 0f);
				((Component)component2).transform.position = transform.position + new Vector3(-2f, 0f, 0.2f) / 3f * (0f - num3);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val9 = new Texture2D((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height, (TextureFormat)4, false);
				val9.ReadPixels(val, 0, 0);
				val9.Apply();
				RenderTexture.active = active;
				CS$<>8__locals0.item.m_itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { Sprite.Create(val9, val, new Vector2(0.5f, 0.5f)) };
				Object.DestroyImmediate((Object)(object)val3);
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
			}
		}

		private static bool CheckItemIsUpgrade(InventoryGui gui)
		{
			ItemData itemData = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData;
			if (itemData == null)
			{
				return false;
			}
			return itemData.m_quality > 0;
		}

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

		private static Action<ConfigEntryBase> drawRequirementsConfigTable(Item item, bool isUpgrade)
		{
			Item item2 = item;
			return delegate(ConfigEntryBase cfg)
			{
				bool locked = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
				List<Requirement> newReqs = new List<Requirement>();
				bool wasUpdated = false;
				int RightColumnWidth = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
					.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				List<Requirement> reqs = new SerializedRequirements((string)cfg.BoxedValue).Reqs;
				bool flag = false;
				int maxQuality = item2.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality;
				if (isUpgrade && maxQuality > 2)
				{
					flag = reqs.Any((Requirement r) => r.quality > 0);
					if (flag)
					{
						int count = reqs.Count;
						for (int i = 0; i < count; i++)
						{
							if (reqs[i].quality == 0)
							{
								List<Requirement> list = reqs;
								int index = i;
								Requirement value = reqs[i];
								value.quality = 2;
								list[index] = value;
								for (int j = 3; j <= maxQuality; j++)
								{
									List<Requirement> list2 = reqs;
									value = reqs[i];
									value.quality = j;
									list2.Add(value);
								}
							}
						}
					}
					if (flag != GUILayout.Toggle(flag, "Individual costs per upgrade level", Array.Empty<GUILayoutOption>()))
					{
						flag = !flag;
						wasUpdated = true;
						if (flag)
						{
							int count2 = reqs.Count;
							for (int k = 0; k < count2; k++)
							{
								List<Requirement> list3 = reqs;
								int index2 = k;
								Requirement value = reqs[k];
								value.quality = 2;
								list3[index2] = value;
								for (int l = 3; l <= maxQuality; l++)
								{
									List<Requirement> list4 = reqs;
									value = reqs[k];
									value.quality = l;
									list4.Add(value);
								}
							}
						}
						else
						{
							reqs.RemoveAll((Requirement req) => req.quality > 1);
							for (int m = 0; m < reqs.Count; m++)
							{
								List<Requirement> list5 = reqs;
								int index3 = m;
								Requirement value = reqs[m];
								value.quality = 0;
								list5[index3] = value;
							}
						}
					}
				}
				if (flag)
				{
					for (int n = 2; n <= maxQuality; n++)
					{
						GUILayout.Label($"Upgrade level {n - 1}:", Array.Empty<GUILayoutOption>());
						DisplayQuality(n);
					}
				}
				else
				{
					DisplayQuality(0);
				}
				GUILayout.EndVertical();
				if (wasUpdated)
				{
					cfg.BoxedValue = new SerializedRequirements(newReqs).ToString();
				}
				void DisplayQuality(int quality)
				{
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0086: Expected O, but got Unknown
					//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e0: Expected O, but got Unknown
					//IL_0123: Unknown result type (might be due to invalid IL or missing references)
					//IL_0128: Unknown result type (might be due to invalid IL or missing references)
					//IL_013d: Expected O, but got Unknown
					//IL_0193: Unknown result type (might be due to invalid IL or missing references)
					//IL_0198: Unknown result type (might be due to invalid IL or missing references)
					//IL_01ad: Expected O, but got Unknown
					foreach (Requirement item3 in reqs.Where((Requirement r) => r.quality == quality))
					{
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						int num = item3.amount;
						if (int.TryParse(GUILayout.TextField(num.ToString(), new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = 40f
						}, Array.Empty<GUILayoutOption>()), out var result) && result != num && !locked)
						{
							num = result;
							wasUpdated = true;
						}
						string text = GUILayout.TextField(item3.itemName, new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = RightColumnWidth - 40 - 21 - 21 - 9
						}, Array.Empty<GUILayoutOption>());
						string text2 = (locked ? item3.itemName : text);
						wasUpdated = wasUpdated || text2 != item3.itemName;
						if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
						}
						else
						{
							newReqs.Add(new Requirement
							{
								amount = num,
								itemName = text2,
								quality = quality
							});
						}
						if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
							newReqs.Add(new Requirement
							{
								amount = 1,
								itemName = "",
								quality = quality
							});
						}
						GUILayout.EndHorizontal();
					}
				}
			};
		}

		private static void drawDropsConfigTable(ConfigEntryBase cfg)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//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_01a0: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_0214: 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_022e: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<DropTarget> list = new List<DropTarget>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (DropTarget item in new SerializedDrop((string)cfg.BoxedValue).Drops.DefaultIfEmpty(new DropTarget
			{
				min = 1,
				max = 1,
				creature = "",
				chance = 1f
			}))
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(item.creature, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 21 - 21 - 6
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? item.creature : text);
				flag = flag || text2 != item.creature;
				bool flag2 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				bool flag3 = GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Chance: ", Array.Empty<GUILayoutOption>());
				float num2 = item.chance;
				if (float.TryParse(GUILayout.TextField((num2 * 100f).ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && !Mathf.Approximately(result / 100f, num2) && !valueOrDefault)
				{
					num2 = result / 100f;
					flag = true;
				}
				GUILayout.Label("% Amount: ", Array.Empty<GUILayoutOption>());
				int num3 = item.min;
				if (int.TryParse(GUILayout.TextField(num3.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num3 && !valueOrDefault)
				{
					num3 = result2;
					flag = true;
				}
				GUILayout.Label(" - ", Array.Empty<GUILayoutOption>());
				int num4 = item.max;
				if (int.TryParse(GUILayout.TextField(num4.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result3) && result3 != num4 && !valueOrDefault)
				{
					num4 = result3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				bool flag4 = item.levelMultiplier;
				if (GUILayout.Toggle(flag4, "Level scaling drop amount", Array.Empty<GUILayoutOption>()) != flag4)
				{
					flag4 = !flag4;
					flag = true;
				}
				GUILayout.EndHorizontal();
				if (flag2 && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new DropTarget
					{
						creature = text2,
						min = num3,
						max = num4,
						chance = num2,
						levelMultiplier = flag4
					});
				}
				if (flag3 && !valueOrDefault)
				{
					flag = true;
					list.Add(new DropTarget
					{
						min = 1,
						max = 1,
						creature = "",
						chance = 1f,
						levelMultiplier = true
					});
				}
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedDrop(list).ToString();
			}
		}

		private static ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[PublicAPI]
	public class LocalizeKey
	{
		private static readonly List<LocalizeKey> keys = new List<LocalizeKey>();

		public readonly string Key;

		public readonly Dictionary<string, string> Localizations = new Dictionary<string, string>();

		public LocalizeKey(string key)
		{
			Key = key.Replace("$", "");
			keys.Add(this);
		}

		public void Alias(string alias)
		{
			Localizations.Clear();
			if (!alias.Contains("$"))
			{
				alias = "$" + alias;
			}
			Localizations["alias"] = alias;
			Localization.instance.AddWord(Key, Localization.instance.Localize(alias));
		}

		public LocalizeKey English(string key)
		{
			return addForLang("English", key);
		}

		public LocalizeKey Swedish(string key)
		{
			return addForLang("Swedish", key);
		}

		public LocalizeKey French(string key)
		{
			return addForLang("French", key);
		}

		public LocalizeKey Italian(string key)
		{
			return addForLang("Italian", key);
		}

		public LocalizeKey German(string key)
		{
			return addForLang("German", key);
		}

		public LocalizeKey Spanish(string key)
		{
			return addForLang("Spanish", key);
		}

		public LocalizeKey Russian(string key)
		{
			return addForLang("Russian", key);
		}

		public LocalizeKey Romanian(string key)
		{
			return addForLang("Romanian", key);
		}

		public LocalizeKey Bulgarian(string key)
		{
			return addForLang("Bulgarian", key);
		}

		public LocalizeKey Macedonian(string key)
		{
			return addForLang("Macedonian", key);
		}

		public LocalizeKey Finnish(string key)
		{
			return addForLang("Finnish", key);
		}

		public LocalizeKey Danish(string key)
		{
			return addForLang("Danish", key);
		}

		public LocalizeKey Norwegian(string key)
		{
			return addForLang("Norwegian", key);
		}

		public LocalizeKey Icelandic(string key)
		{
			return addForLang("Icelandic", key);
		}

		public LocalizeKey Turkish(string key)
		{
			return addForLang("Turkish", key);
		}

		public LocalizeKey Lithuanian(string key)
		{
			return addForLang("Lithuanian", key);
		}

		public LocalizeKey Czech(string key)
		{
			return addForLang("Czech", key);
		}

		public LocalizeKey Hungarian(string key)
		{
			return addForLang("Hungarian", key);
		}

		public LocalizeKey Slovak(string key)
		{
			return addForLang("Slovak", key);
		}

		public LocalizeKey Polish(string key)
		{
			return addForLang("Polish", key);
		}

		public LocalizeKey Dutch(string key)
		{
			return addForLang("Dutch", key);
		}

		public LocalizeKey Portuguese_European(string key)
		{
			return addForLang("Portuguese_European", key);
		}

		public LocalizeKey Portuguese_Brazilian(string key)
		{
			return addForLang("Portuguese_Brazilian", key);
		}

		public LocalizeKey Chinese(string key)
		{
			return addForLang("Chinese", key);
		}

		public LocalizeKey Japanese(string key)
		{
			return addForLang("Japanese", key);
		}

		public LocalizeKey Korean(string key)
		{
			return addForLang("Korean", key);
		}

		public LocalizeKey Hindi(string key)
		{
			return addForLang("Hindi", key);
		}

		public LocalizeKey Thai(string key)
		{
			return addForLang("Thai", key);
		}

		public LocalizeKey Abenaki(string key)
		{
			return addForLang("Abenaki", key);
		}

		public LocalizeKey Croatian(string key)
		{
			return addForLang("Croatian", key);
		}

		public LocalizeKey Georgian(string key)
		{
			return addForLang("Georgian", key);
		}

		public LocalizeKey Greek(string key)
		{
			return addForLang("Greek", key);
		}

		public LocalizeKey Serbian(string key)
		{
			return addForLang("Serbian", key);
		}

		public LocalizeKey Ukrainian(string key)
		{
			return addForLang("Ukrainian", key);
		}

		private LocalizeKey addForLang(string lang, string value)
		{
			Localizations[lang] = value;
			if (Localization.instance.GetSelectedLanguage() == lang)
			{
				Localization.instance.AddWord(Key, value);
			}
			else if (lang == "English" && !Localization.instance.m_translations.ContainsKey(Key))
			{
				Localization.instance.AddWord(Key, value);
			}
			return this;
		}

		[HarmonyPriority(300)]
		internal static void AddLocalizedKeys(Localization __instance, string language)
		{
			foreach (LocalizeKey key in keys)
			{
				string value2;
				if (key.Localizations.TryGetValue(language, out string value) || key.Localizations.TryGetValue("English", out value))
				{
					__instance.AddWord(key.Key, value);
				}
				else if (key.Localizations.TryGetValue("alias", out value2))
				{
					__instance.AddWord(key.Key, Localization.instance.Localize(value2));
				}
			}
		}
	}
	public static class LocalizationCache
	{
		private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

		internal static void LocalizationPostfix(Localization __instance, string language)
		{
			Localization __instance2 = __instance;
			string key = localizations.FirstOrDefault<KeyValuePair<string, Localization>>((KeyValuePair<string, Localization> l) => l.Value == __instance2).Key;
			if (key != null)
			{
				localizations.Remove(key);
			}
			if (!localizations.ContainsKey(language))
			{
				localizations.Add(language, __instance2);
			}
		}

		public static Localization ForLanguage(string? language = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out Localization value))
			{
				return value;
			}
			value = new Localization();
			if (language != null)
			{
				value.SetupLanguage(language);
			}
			return value;
		}
	}
	[PublicAPI]
	public static class PrefabManager
	{
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> prefabs;

		private static readonly List<GameObject> ZnetOnlyPrefabs;

		internal static readonly Dictionary<GameObject, Tuple<Trader, TradeItem>> CustomTradeItems;

		static PrefabManager()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Expected O, but got Unknown
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Expected O, but got Unknown
			//IL_02e0: Expected O, but got Unknown
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Expected O, but got Unknown
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Expected O, but got Unknown
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Expected O, but got Unknown
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			ZnetOnlyPrefabs = new List<GameObject>();
			CustomTradeItems = new Dictionary<GameObject, Tuple<Trader, TradeItem>>();
			Harmony val = new Harmony("org.bepinex.helpers.ItemManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "UpdateRecipe", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_InventoryGui", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirementList", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_SetupRequirementList", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Requirement), "GetAmount", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_RequirementGetAmount", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "GetAvailableRecipes", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesPrefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesFinalizer", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Recipe), "GetRequiredStationLevel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_MaximumRequiredStationLevel", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddFuel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddOre", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Trader), "GetAvailableItems", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_TraderGetAvailableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			string assetBundleFileName2 = assetBundleFileName;
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName2;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out AssetBundle value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == assetBundleFileName2)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName2));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName, bool addToObjectDb = false)
		{
			return RegisterPrefab(assets.LoadAsset<GameObject>(prefabName), addToObjectDb);
		}

		public static GameObject RegisterPrefab(GameObject prefab, bool addToObjectDb = false)
		{
			if (addToObjectDb)
			{
				prefabs.Add(prefab);
			}
			else
			{
				ZnetOnlyPrefabs.Add(prefab);
			}
			return prefab;
		}

		public static void AddItemToTrader(GameObject prefab, Trader trader, uint price, uint stack = 1u, string? requiredGlobalKey = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			CustomTradeItems[prefab] = new Tuple<Trader, TradeItem>(trader, new TradeItem
			{
				m_prefab = prefab.GetComponent<ItemDrop>(),
				m_price = (int)price,
				m_stack = (int)stack,
				m_requiredGlobalKey = (requiredGlobalKey ?? "")
			});
		}

		public static void RemoveItemFromTrader(GameObject prefab)
		{
			CustomTradeItems.Remove(prefab);
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			ObjectDB __instance2 = __instance;
			foreach (GameObject prefab in prefabs)
			{
				if (!__instance2.m_items.Contains(prefab))
				{
					__instance2.m_items.Add(prefab);
				}
				SharedData shared = prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				RegisterStatusEffect(shared.m_attackStatusEffect);
				RegisterStatusEffect(shared.m_consumeStatusEffect);
				RegisterStatusEffect(shared.m_equipStatusEffect);
				RegisterStatusEffect(shared.m_setStatusEffect);
			}
			__instance2.UpdateRegisters();
			void RegisterStatusEffect(StatusEffect? statusEffect)
			{
				if (statusEffect != null && !Object.op_Implicit((Object)(object)__instance2.GetStatusEffect(StringExtensionMethods.GetStableHashCode(((Object)statusEffect).name))))
				{
					__instance2.m_StatusEffects.Add(statusEffect);
				}
			}
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject item in prefabs.Concat(ZnetOnlyPrefabs))
			{
				if (!__instance.m_prefabs.Contains(item))
				{
					__instance.m_prefabs.Add(item);
				}
				else
				{
					Debug.LogWarning((object)("ZNetScene already contains " + ((Object)item).name + " it cannot be added twice."));
				}
			}
		}
	}
	[PublicAPI]
	public class Conversion
	{
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			public string? activePiece;

			public ConfigEntry<ConversionPiece> piece;

			public ConfigEntry<string> customPiece;
		}

		public string Input;

		public ConversionPiece Piece;

		internal string? customPiece;

		internal ConversionConfig? config;

		public string? Custom
		{
			get
			{
				return customPiece;
			}
			set
			{
				customPiece = value;
				Piece = ConversionPiece.Custom;
			}
		}

		public Conversion(Item outputItem)
		{
			outputItem.Conversions.Add(this);
		}
	}
}
namespace ItemDataManager
{
	[PublicAPI]
	public abstract class ItemData
	{
		internal static WeakReference<ItemInfo> constructingInfo = null;

		internal WeakReference<ItemInfo>? info;

		private static readonly FieldInfo parameterInfoClassImpl = AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl");

		private static Dictionary<Type, Dictionary<string, FieldInfo>> serializedFields = new Dictionary<Type, Dictionary<string, FieldInfo>>();

		public string CustomDataKey { get; internal set; }

		protected virtual bool AllowStackingIdenticalValues { get; set; }

		public string Value
		{
			get
			{
				if (!Item.m_customData.TryGetValue(CustomDataKey, out var value))
				{
					return "";
				}
				return value;
			}
			set
			{
				Item.m_customData[CustomDataKey] = value;
			}
		}

		public string Key { get; internal set; }

		public bool IsCloned => Info.isCloned.Contains(CustomDataKey);

		public bool IsAlive
		{
			get
			{
				ItemInfo target;
				return (info ?? constructingInfo).TryGetTarget(out target);
			}
		}

		public ItemData Item => Info.ItemData;

		public ItemInfo Info
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				if (!(info ?? constructingInfo).TryGetTarget(out ItemInfo target))
				{
					return new ItemInfo(new ItemData());
				}
				return target;
			}
		}

		public virtual void FirstLoad()
		{
		}

		public virtual void Load()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			Dictionary<string, FieldInfo> dictionary = fetchSerializedFields();
			if (dictionary == null || dictionary.Count <= 0 || Value == "")
			{
				return;
			}
			List<object> list = new List<object>();
			string[] array = Value.Split(new char[1] { '|' });
			foreach (string text in array)
			{
				string[] array2 = text.Split(new char[1] { ':' });
				if (array2.Length == 2 && dictionary.TryGetValue(array2[0], out var value))
				{
					ZPackage val = new ZPackage(array2[1]);
					ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
					parameterInfoClassImpl.SetValue(parameterInfo, value.FieldType);
					list.Clear();
					ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, val, ref list);
					if (list.Count > 0)
					{
						value.SetValue(this, list[0]);
					}
				}
			}
		}

		public virtual void Save()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			Dictionary<string, FieldInfo> dictionary = fetchSerializedFields();
			if (dictionary == null || dictionary.Count <= 0)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (FieldInfo value in dictionary.Values)
			{
				ZPackage val = new ZPackage();
				ZRpc.Serialize(new object[1] { value.GetValue(this) }, ref val);
				stringBuilder.Append(value.Name);
				stringBuilder.Append(':');
				stringBuilder.Append(val.GetBase64());
				stringBuilder.Append('|');
			}
			int length = stringBuilder.Length - 1;
			stringBuilder.Length = length;
			Value = stringBuilder.ToString();
		}

		public virtual void Unload()
		{
		}

		public virtual void Upgraded()
		{
		}

		public virtual string? TryStack(ItemData? data)
		{
			if (!AllowStackingIdenticalValues || !(data?.Value == Value))
			{
				return null;
			}
			return Value;
		}

		private Dictionary<string, FieldInfo> fetchSerializedFields()
		{
			Type type = GetType();
			if (serializedFields.TryGetValue(type, out Dictionary<string, FieldInfo> value))
			{
				return value;
			}
			return serializedFields[type] = (from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where f.GetCustomAttributes(typeof(SerializeField), inherit: true).Length != 0
				select f).ToDictionary((FieldInfo f) => f.Name, (FieldInfo f) => f);
		}
	}
	public sealed class StringItemData : ItemData
	{
	}
	[PublicAPI]
	public class ItemInfo : IEnumerable<ItemData>, IEnumerable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass57_0
		{
			public Label target;

			public CodeInstruction targetedInstr;

			internal bool <CheckStackableInFindFreeStackMethods>b__1(CodeInstruction i)
			{
				return i.labels.Contains(target);
			}

			internal bool <CheckStackableInFindFreeStackMethods>b__2(CodeInstruction i)
			{
				Label? label = default(Label?);
				if (CodeInstructionExtensions.Branches(i, ref label))
				{
					return targetedInstr.labels.Contains(label.Value);
				}
				return false;
			}
		}

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

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructionsEnumerable;

			public IEnumerable<CodeInstruction> <>3__instructionsEnumerable;

			private <>c__DisplayClass57_0 <>8__1;

			private CodeInstruction[] <instructions>5__2;

			private CodeInstruction <lastBranch>5__3;

			private CodeInstruction <loadingInstruction>5__4;

			private int <i>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Expected O, but got Unknown
				//IL_0272: Unknown result type (might be due to invalid IL or missing references)
				//IL_027c: Expected O, but got Unknown
				//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ac: Expected O, but got Unknown
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass57_0();
					<instructions>5__2 = instructionsEnumerable.ToArray();
					<>8__1.target = (Label)<instructions>5__2.First((CodeInstruction i) => i.opcode == OpCodes.Br || i.opcode == OpCodes.Br_S).operand;
					<>8__1.targetedInstr = <instructions>5__2.First((CodeInstruction i) => i.labels.Contains(<>8__1.target));
					Label? label = default(Label?);
					<lastBranch>5__3 = <instructions>5__2.Reverse().First((CodeInstruction i) => CodeInstructionExtensions.Branches(i, ref label) && <>8__1.targetedInstr.labels.Contains(label.Value));
					<loadingInstruction>5__4 = null;
					<i>5__5 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					if (<loadingInstruction>5__4 == null && <instructions>5__2[<i>5__5].opcode == OpCodes.Call && ((MethodInfo)<instructions>5__2[<i>5__5].operand).Name == "get_Current")
					{
						<loadingInstruction>5__4 = <instructions>5__2[<i>5__5 + 1].Clone();
						<loadingInstruction>5__4.opcode = new Dictionary<OpCode, OpCode>
						{
							{
								OpCodes.Stloc_0,
								OpCodes.Ldloc_0
							},
							{
								OpCodes.Stloc_1,
								OpCodes.Ldloc_1
							},
							{
								OpCodes.Stloc_2,
								OpCodes.Ldloc_2
							},
							{
								OpCodes.Stloc_3,
								OpCodes.Ldloc_3
							},
							{
								OpCodes.Stloc_S,
								OpCodes.Ldloc_S
							}
						}[<loadingInstruction>5__4.opcode];
					}
					if (<instructions>5__2[<i>5__5] == <lastBranch>5__3)
					{
						<>2__current = <loadingInstruction>5__4;
						<>1__state = 2;
						return true;
					}
					goto IL_02bc;
				case 2:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "checkingForStackableItemData"));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataIsStackableFindFree", (Type[])null, (Type[])null));
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Brfalse, (object)<>8__1.target);
					<>1__state = 5;
					return true;
				case 5:
					{
						<>1__state = -1;
						goto IL_02bc;
					}
					IL_02bc:
					num = <i>5__5 + 1;
					<i>5__5 = num;
					break;
				}
				if (<i>5__5 < <instructions>5__2.Length)
				{
					<>2__current = <instructions>5__2[<i>5__5];
					<>1__state = 1;
					return true;
				}
				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]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<CheckStackableInFindFreeStackMethods>d__57 <CheckStackableInFindFreeStackMethods>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<CheckStackableInFindFreeStackMethods>d__ = this;
				}
				else
				{
					<CheckStackableInFindFreeStackMethods>d__ = new <CheckStackableInFindFreeStackMethods>d__57(0);
				}
				<CheckStackableInFindFreeStackMethods>d__.instructionsEnumerable = <>3__instructionsEnumerable;
				return <CheckStackableInFindFreeStackMethods>d__;
			}

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

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

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructionList;

			public IEnumerable<CodeInstruction> <>3__instructionList;

			private List<CodeInstruction>.Enumerator <>7__wrap1;

			private CodeInstruction <instruction>5__3;

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

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

			[DebuggerHidden]
			public <ImportCustomDataOnUpgrade>d__71(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 = default(List<CodeInstruction>.Enumerator);
				<instruction>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						List<CodeInstruction> list = instructionList.ToList();
						<>7__wrap1 = list.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						if (<instruction>5__3.opcode == OpCodes.Stfld && CodeInstructionExtensions.OperandIs(<instruction>5__3, (MemberInfo)AccessTools.DeclaredField(typeof(ItemData), "m_dropPrefab")))
						{
							<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
							<>1__state = 2;
							return true;
						}
						goto IL_0118;
					case 2:
						<>1__state = -3;
						<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CopyCustomDataFromUpgradedItem", (Type[])null, (Type[])null));
						<>1__state = 3;
						return true;
					case 3:
						{
							<>1__state = -3;
							goto IL_0118;
						}
						IL_0118:
						<instruction>5__3 = null;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						<instruction>5__3 = <>7__wrap1.Current;
						<>2__current = <instruction>5__3;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = default(List<CodeInstruction>.Enumerator);
					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;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

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

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

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

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructions;

			public IEnumerable<CodeInstruction> <>3__instructions;

			private MethodInfo <itemDeleter>5__2;

			private IEnumerator<CodeInstruction> <>7__wrap2;

			private CodeInstruction <instruction>5__4;

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

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

			[DebuggerHidden]
			public <TransferCustomItemDataOnUpgrade>d__68(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();
					}
				}
				<itemDeleter>5__2 = null;
				<>7__wrap2 = null;
				<instruction>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Expected O, but got Unknown
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<itemDeleter>5__2 = AccessTools.DeclaredMethod(typeof(Inventory), "RemoveItem", new Type[1] { typeof(ItemData) }, (Type[])null);
						<>7__wrap2 = instructions.GetEnumerator();
						<>1__state = -3;
						goto IL_0136;
					case 1:
						<>1__state = -3;
						<>2__current = new CodeInstruction(OpCodes.Stsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "currentlyUpgradingItem"));
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -3;
						goto IL_0110;
					case 3:
						{
							<>1__state = -3;
							<instruction>5__4 = null;
							goto IL_0136;
						}
						IL_0136:
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							if (<instruction>5__4.opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(<instruction>5__4, (MemberInfo)<itemDeleter>5__2))
							{
								<>2__current = new CodeInstruction(OpCodes.Dup, (object)null);
								<>1__state = 1;
								return true;
							}
							goto IL_0110;
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						return false;
						IL_0110:
						<>2__current = <instruction>5__4;
						<>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__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

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

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

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

		public static HashSet<Type> ForceLoadTypes;

		internal static string? _modGuid;

		private static Dictionary<Type, HashSet<Type>> typeInheritorsCache;

		private static HashSet<string> knownTypes;

		private Dictionary<string, ItemData> data = new Dictionary<string, ItemData>();

		private WeakReference<ItemInfo>? selfReference;

		internal HashSet<string> isCloned = new HashSet<string>();

		private static ItemData? awakeningItem;

		private static Assembly primaryAssembly;

		private static Dictionary<Assembly, string> assemblyNameCache;

		private static Dictionary<Type, string> classKeyCache;

		private HashSet<string> fetchedClassKeys = new HashSet<string>();

		private static MethodInfo removeMethod;

		private static ItemData? checkingForStackableItemData;

		private static Dictionary<string, string>? newValuesOnStackable;

		private static ItemData? currentlyUpgradingItem;

		internal static string modGuid => _modGuid ?? (_modGuid = ((Func<string>)delegate
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			IEnumerable<TypeInfo> source;
			try
			{
				source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			BaseUnityPlugin val = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			return val.Info.Metadata.GUID;
		})());

		public string Mod => modGuid;

		public ItemData ItemData { get; private set; }

		public string? this[string key]
		{
			get
			{
				return Get<StringItemData>(key)?.Value;
			}
			set
			{
				GetOrCreate<StringItemData>(key).Value = value ?? "";
			}
		}

		internal static void addTypeToInheritorsCache(Type type, string typeKey)
		{
			Type type2 = type;
			if (!knownTypes.Contains(typeKey))
			{
				knownTypes.Add(typeKey);
				Type type3 = type2;
				while ((object)type3 != null)
				{
					AddInterfaces(type3);
					type3 = type3.BaseType;
				}
			}
			void AddInterfaces(Type baseType)
			{
				if (!typeInheritorsCache.TryGetValue(baseType, out HashSet<Type> value))
				{
					HashSet<Type> hashSet2 = (typeInheritorsCache[baseType] = new HashSet<Type>());
					value = hashSet2;
				}
				value.Add(type2);
				Type[] interfaces = baseType.GetInterfaces();
				foreach (Type baseType2 in interfaces)
				{
					AddInterfaces(baseType2);
				}
			}
		}

		private static string cachedAssemblyName(Assembly assembly)
		{
			if (assemblyNameCache.TryGetValue(assembly, out string value))
			{
				return value;
			}
			return assemblyNameCache[assembly] = assembly.GetName().Name;
		}

		internal static string classKey(Type type, string key)
		{
			if (!classKeyCache.TryGetValue(type, out string value))
			{
				value = type.FullName + ((type.Assembly != primaryAssembly) ? ("," + cachedAssemblyName(type.Assembly)) : "");
				addTypeToInheritorsCache(type, value);
			}
			if (key == "")
			{
				return value;
			}
			return value + "#" + key;
		}

		internal static string dataKey(string key)
		{
			return modGuid + "#" + key;
		}

		internal ItemInfo(ItemData itemData)
		{
			ItemData = itemData;
			string text = dataKey("");
			List<string> list = ItemData.m_customData.Keys.ToList();
			foreach (string item in list)
			{
				if (!item.StartsWith(text))
				{
					continue;
				}
				string text2 = item.Substring(text.Length);
				string[] array = text2.Split(new char[1] { '#' }, 2);
				if (!knownTypes.Contains(array[0]))
				{
					Type type = Type.GetType(array[0]);
					if ((object)type != null && typeof(ItemData).IsAssignableFrom(type))
					{
						addTypeToInheritorsCache(type, array[0]);
					}
				}
			}
		}

		public T GetOrCreate<T>(string key = "") where T : ItemData, new()
		{
			return Add<T>(key) ?? Get<T>(key);
		}

		public T? Add<T>(string key = "") where T : ItemData, new()
		{
			string text = classKey(typeof(T), key);
			if (fetchedClassKeys.Contains(text) && data.ContainsKey(text))
			{
				return null;
			}
			string text2 = dataKey(text);
			if (ItemData.m_customData.ContainsKey(text2) || (awakeningItem != ItemData && data.ContainsKey(text)))
			{
				return null;
			}
			ItemData.m_customData[text2] = "";
			ItemDataManager.ItemData.constructingInfo = selfReference ?? (selfReference = new WeakReference<ItemInfo>(this));
			T val = new T
			{
				info = selfReference,
				Key = key,
				CustomDataKey = text2
			};
			data[text] = val;
			val.Value = "";
			val.FirstLoad();
			return val;
		}

		public T? Get<T>(string key = "") where T : class
		{
			if (!typeInheritorsCache.TryGetValue(typeof(T), out HashSet<Type> value))
			{
				if (!typeof(ItemData).IsAssignableFrom(typeof(T)) || typeof(T) == typeof(ItemData))
				{
					throw new Exception("Trying to get value from ItemDataManager for class not inheriting from ItemData");
				}
				return null;
			}
			foreach (Type item in value)
			{
				string text = classKey(item, key);
				if (data.TryGetValue(text, out ItemData value2))
				{
					return (T)(object)value2;
				}
				if (!fetchedClassKeys.Contains(text) && awakeningItem != ItemData)
				{
					string text2 = dataKey(text);
					fetchedClassKeys.Add(text);
					if (ItemData.m_customData.ContainsKey(text2))
					{
						return (T)(object)constructDataObj(text2, text);
					}
				}
			}
			return null;
		}

		public Dictionary<string, T> GetAll<T>() where T : ItemData
		{
			LoadAll();
			return data.Values.Where((ItemData o) => o is T).ToDictionary((ItemData o) => o.Key, (ItemData o) => (T)o);
		}

		public bool Remove(string key = "")
		{
			return Remove<StringItemData>(key);
		}

		public bool Remove<T>(string key = "") where T : ItemData
		{
			string key2 = classKey(typeof(T), key);
			string key3 = dataKey(key2);
			if (ItemData.m_customData.Remove(key3))
			{
				if (data.TryGetValue(key2, out ItemData value))
				{
					value.Unload();
					data.Remove(key2);
				}
				return true;
			}
			return false;
		}

		public bool Remove<T>(T itemData) where T : ItemData
		{
			if (typeof(T) == itemData.GetType())
			{
				return Remove<T>(itemData.Key);
			}
			return (bool)removeMethod.MakeGenericMethod(itemData.GetType()).Invoke(this, new object[1] { itemData.Key });
		}

		private ItemData? constructDataObj(string fullkey, string key)
		{
			string[] array = key.Split(new char[1] { '#' }, 2);
			Type type = Type.GetType(array[0]);
			if ((object)type == null || !typeof(ItemData).IsAssignableFrom(type))
			{
				return null;
			}
			ItemDataManager.ItemData.constructingInfo = selfReference ?? (selfReference = new WeakReference<ItemInfo>(this));
			ItemData itemData = (ItemData)Activator.CreateInstance(type);
			data[key] = itemData;
			itemData.info = selfReference;
			itemData.Key = ((array.Length > 1) ? array[1] : "");
			itemData.CustomDataKey = fullkey;
			itemData.Load();
			return itemData;
		}

		public void Save()
		{
			foreach (ItemData value in data.Values)
			{
				value.Save();
			}
		}

		public void LoadAll()
		{
			if (awakeningItem == ItemData)
			{
				return;
			}
			string text = dataKey("");
			List<string> list = ItemData.m_customData.Keys.ToList();
			foreach (string item in list)
			{
				if (item.StartsWith(text))
				{
					string key = item.Substring(text.Length);
					if (!data.ContainsKey(key))
					{
						constructDataObj(item, key);
					}
				}
			}
		}

		public IEnumerator<ItemData> GetEnumerator()
		{
			LoadAll();
			return data.Values.GetEnumerator();
		}

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

		private static void SavePrefix(ItemData __instance)
		{
			SaveItem(__instance);
		}

		private static void SaveInventoryPrefix(Inventory __instance)
		{
			foreach (ItemData item in __instance.m_inventory)
			{
				SaveItem(item);
			}
		}

		private static void SaveItem(ItemData item)
		{
			if (ItemExtensions.itemInfo.TryGetValue(item, out ItemInfo value))
			{
				value.Save();
			}
		}

		public Dictionary<string, string>? IsStackableWithOtherInfo(ItemInfo? info)
		{
			LoadAll();
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (info != null)
			{
				info.LoadAll();
				HashSet<string> hashSet = new HashSet<string>(info.data.Keys.Intersect(data.Keys));
				foreach (string item in hashSet)
				{
					string text = data[item].TryStack(info.data[item]);
					if (text == null)
					{
						return null;
					}
					dictionary[item] = text;
				}
				foreach (KeyValuePair<string, ItemData> datum in info.data)
				{
					if (!dictionary.ContainsKey(datum.Key))
					{
						string text2 = info.data[datum.Key].TryStack(null);
						if (text2 == null)
						{
							return null;
						}
						dictionary[datum.Key] = text2;
					}
				}
			}
			foreach (KeyValuePair<string, ItemData> datum2 in data)
			{
				if (!dictionary.ContainsKey(datum2.Key))
				{
					string text3 = data[datum2.Key].TryStack(null);
					if (text3 == null)
					{
						return null;
					}
					dictionary[datum2.Key] = text3;
				}
			}
			return dictionary.ToDictionary((KeyValuePair<string, string> kv) => dataKey(kv.Key), (KeyValuePair<string, string> kv) => kv.Value);
		}

		private static void RegisterForceLoadedTypesAddItem(ItemData? __result)
		{
			awakeningItem = null;
			if (__result != null)
			{
				RegisterForceLoadedTypes(__result);
			}
		}

		private static void RegisterForceLoadedTypes(ItemData itemData)
		{
			foreach (Type forceLoadType in ForceLoadTypes)
			{
				string key = classKey(forceLoadType, "");
				string text = dataKey(key);
				if (itemData.m_customData.ContainsKey(text))
				{
					ItemInfo itemInfo = itemData.Data();
					if (!itemInfo.data.ContainsKey(key))
					{
						itemInfo.constructDataObj(text, key);
					}
				}
			}
		}

		private static void ItemDropAwake(ItemDrop __instance)
		{
			GameObject dropPrefab = __instance.m_itemData.m_dropPrefab;
			if (dropPrefab == null || !ItemExtensions.itemInfo.TryGetValue(dropPrefab.GetComponent<ItemDrop>().m_itemData, out ItemInfo value))
			{
				return;
			}
			ItemInfo itemInfo = __instance.m_itemData.Data();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in value.data.Values.Select((ItemData i) => i.CustomDataKey))
			{
				hashSet.Add(item);
			}
			itemInfo.isCloned = hashSet;
		}

		private static void ItemDropAwakeDelayed(ItemDrop __instance)
		{
			if (!ZNetView.m_forceDisableInit)
			{
				RegisterForceLoadedTypes(__instance.m_itemData);
			}
		}

		private static void ItemDataClonePrefix(ItemData __instance, ItemData __result)
		{
			SaveItem(__instance);
		}

		private static void ItemDataClonePostfix(ItemData __instance, ItemData __result)
		{
			if (!ItemExtensions.itemInfo.TryGetValue(__instance, out ItemInfo value))
			{
				return;
			}
			ItemInfo itemInfo = __result.Data();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in value.data.Values.Select((ItemData i) => i.CustomDataKey))
			{
				hashSet.Add(item);
			}
			itemInfo.isCloned = hashSet;
		}

		private static void ItemDataClonePostfixDelayed(ItemData __result)
		{
			RegisterForceLoadedTypes(__result);
		}

		private static void RegisterForceLoadedTypesOnPlayerLoaded(Player __instance)
		{
			foreach (Food food in __instance.m_foods)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(food.m_name);
				if (itemPrefab.GetComponent<ItemDrop>().m_itemData == food.m_item)
				{
					food.m_item = food.m_item.Clone();
					food.m_item.m_dropPrefab = itemPrefab;
				}
				RegisterForceLoadedTypes(food.m_item);
			}
		}

		private static void SaveCheckingForStackableItemData(ItemData item)
		{
			if (item == awakeningItem)
			{
				awakeningItem = null;
			}
			checkingForStackableItemData = item;
		}

		private static void ResetCheckingForStackableItemData()
		{
			checkingForStackableItemData = null;
		}

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

		private static bool CheckItemDataIsStackableFindFree(ItemData item, ItemData? target)
		{
			if (target == null)
			{
				return true;
			}
			Dictionary<string, string> dictionary = IsStackable(item, target);
			if (dictionary != null)
			{
				newValuesOnStackable = dictionary;
				return true;
			}
			return false;
		}

		private static void ResetNewValuesOnStackable()
		{
			newValuesOnStackable = null;
		}

		private static void ApplyNewValuesOnStackable(ItemData? __result)
		{
			if (__result == null || newValuesOnStackable == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in newValuesOnStackable)
			{
				__result.m_customData[item.Key] = item.Value;
			}
		}

		private static Dictionary<string, string>? IsStackable(ItemData a, ItemData b)
		{
			ItemInfo itemInfo = a.Data();
			if (itemInfo != null)
			{
				return itemInfo.IsStackableWithOtherInfo(b.Data());
			}
			ItemInfo itemInfo2 = b.Data();
			if (itemInfo2 != null)
			{
				return itemInfo2.IsStackableWithOtherInfo(null);
			}
			return new Dictionary<string, string>();
		}

		private static bool CheckItemDataStackableAddItem(Inventory __instance, ItemData item, int x, int y, ref Dictionary<string, string>? __state, ref bool __result)
		{
			ItemData itemAt = __instance.GetItemAt(x, y);
			if (itemAt != null)
			{
				Dictionary<string, string> dictionary = IsStackable(item, itemAt);
				if (dictionary == null)
				{
					__result = false;
					return false;
				}
				__state = dictionary;
			}
			return true;
		}

		private static void ApplyCustomItemDataStackableAddItem(Inventory __instance, int x, int y, Dictionary<string, string>? __state, bool __result)
		{
			if (!__result || __state == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in __state)
			{
				__instance.GetItemAt(x, y).m_customData[item.Key] = item.Value;
			}
		}

		private static void ApplyCustomItemDataStackableAutoStack(ItemDrop item, Dictionary<string, string> customData)
		{
			item.m_itemData.m_customData = customData;
		}

		private static Dictionary<string, string>? IsStackableItemDrop(ItemDrop drop, ItemData item)
		{
			return IsStackable(drop.m_itemData, item);
		}

		private static IEnumerable<CodeInstruction> HandleAutostackableItems(IEnumerable<CodeInstruction> instructionList, ILGenerator ilg)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			List<CodeInstruction> list = instructionList.ToList();
			FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ItemData), "m_stack");
			FieldInfo fieldInfo2 = AccessTools.DeclaredField(typeof(ItemDrop), "m_itemData");
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (!CodeInstructionExtensions.StoresField(list[i], fieldInfo))
				{
					continue;
				}
				for (int num = i; num > 0; num--)
				{
					if (CodeInstructionExtensions.Branches(list[num], ref label))
					{
						for (int num2 = num; num2 > 0; num2--)
						{
							if (CodeInstructionExtensions.LoadsField(list[num2], fieldInfo2, false))
							{
								LocalBuilder localBuilder = ilg.DeclareLocal(typeof(Dictionary<string, string>));
								LocalBuilder localBuilder2 = ilg.DeclareLocal(typeof(ItemData));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyCustomItemDataStackableAutoStack", (Type[])null, (Type[])null)));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder.LocalIndex));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Brfalse, (object)label));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Stloc, (object)localBuilder.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Dup, (object)localBuilder.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "IsStackableItemDrop", (Type[])null, (Type[])null)));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder2.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
								list.Insert(num2 + 1, new CodeInstruction(OpCodes.Stloc, (object)localBuilder2.LocalIndex));
								list.Insert(num2 + 1, new CodeInstruction(OpCodes.Dup, (object)null));
								return list;
							}
						}
					}
				}
			}
			throw new Exception("Found no stack store in a branch");
		}

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

		private static void ResetCurrentlyUpgradingItem()
		{
			currentlyUpgradingItem = null;
		}

		private static void CopyCustomDataFromUpgradedItem(ItemDrop item)
		{
			if (currentlyUpgradingItem != null)
			{
				item.m_itemData.m_customData = currentlyUpgradingItem.m_customData;
				ItemInfo itemInfo = currentlyUpgradingItem.Data();
				ItemExtensions.itemInfo.Remove(currentlyUpgradingItem);
				ItemExtensions.itemInfo.Add(item.m_itemData, itemInfo);
				item.m_itemData.m_quality = currentlyUpgradingItem.m_quality + 1;
				item.m_itemData.m_variant = currentlyUpgradingItem.m_variant;
				itemInfo.ItemData = item.m_itemData;
				itemInfo.LoadAll();
				foreach (ItemData value in itemInfo.data.Values)
				{
					value.Upgraded();
				}
				currentlyUpgradingItem = null;
				awakeningItem = null;
				return;
			}
			GameObject dropPrefab = item.m_itemData.m_dropPrefab;
			if (dropPrefab == null || item.m_itemData.m_customData.Count != 0)
			{
				return;
			}
			ZNetView component = ((Component)item).GetComponent<ZNetView>();
			ZDO val = ((Object.op_Implicit((Object)(object)component) && component.IsValid()) ? component.GetZDO() : null);
			if (val != null && val.GetInt(ZDOVars.s_dataCount, -1) != -1)
			{
				return;
			}
			item.m_itemData.m_customData = new Dictionary<string, string>(dropPrefab.GetComponent<ItemDrop>().m_itemData.m_customData);
			if (val == null)
			{
				return;
			}
			int num = 0;
			val.Set(ZDOVars.s_dataCount, item.m_itemData.m_customData.Count, false);
			foreach (KeyValuePair<string, string> customDatum in item.m_itemData.m_customData)
			{
				val.Set($"data_{num}", customDatum.Key);
				val.Set($"data__{num++}", customDatum.Value);
			}
		}

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

		private static void TrackAwakeningItem(ItemDrop __instance)
		{
			if (ZNetView.m_forceDisableInit)
			{
				awakeningItem = __instance.m_itemData;
			}
		}

		static ItemInfo()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			//IL_01d0: Expected O, but got Unknown
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_023f: Expected O, but got Unknown
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Expected O, but got Unknown
			//IL_02a1: Expected O, but got Unknown
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_0310: Expected O, but got Unknown
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Expected O, but got Unknown
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Expected O, but got Unknown
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Expected O, but got Unknown
			//IL_03c0: Expected O, but got Unknown
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Expected O, but got Unknown
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Expected O, but got Unknown
			//IL_0452: Expected O, but got Unknown
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Expected O, but got Unknown
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Expected O, but got Unknown
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ce: Expected O, but got Unknown
			//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Expected O, but got Unknown
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_0662: Expected O, but got Unknown
			//IL_0662: Expected O, but got Unknown
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Expected O, but got Unknown
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0707: Unknown result type (might be due to invalid IL or missing references)
			//IL_0714: Expected O, but got Unknown
			//IL_0714: Expected O, but got Unknown
			//IL_0753: Unknown result type (might be due to invalid IL or missing references)
			//IL_0760: Expected O, but got Unknown
			ForceLoadTypes = new HashSet<Type>();
			typeInheritorsCache = new Dictionary<Type, HashSet<Type>>();
			knownTypes = new HashSet<string>();
			awakeningItem = null;
			primaryAssembly = Assembly.GetExecutingAssembly();
			assemblyNameCache = new Dictionary<Assembly, string>();
			classKeyCache = new Dictionary<Type, string>();
			removeMethod = typeof(ItemInfo).GetMethods().Single((MethodInfo m) => m.Name == "Remove" && m.IsGenericMethod && m.GetParameters()[0].ParameterType == typeof(string));
			Harmony val = new Harmony("org.bepinex.helpers.ItemDataManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "Save", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveInventoryPrefix", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			foreach (MethodInfo item in from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "SaveToZDO"
				select m)
			{
				val.Patch((MethodBase)item, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SavePrefix", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[4]
			{
				typeof(ItemData),
				typeof(int),
				typeof(int),
				typeof(int)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataStackableAddItem", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyCustomItemDataStackableAddItem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "CanAddItem", new Type[2]
			{
				typeof(ItemData),
				typeof(int)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[1] { typeof(ItemData) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[2]
			{
				typeof(ItemData),
				typeof(Vector2i)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "FindFreeStackSpace", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckStackableInFindFreeStackMethods", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Inventory), "FindFreeStackItem", (Type[])null, (Type[])null);
			HarmonyMethod val2 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckStackableInFindFreeStackMethods", (Type[])null, (Type[])null));
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ResetNewValuesOnStackable", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyNewValuesOnStackable", (Type[])null, (Type[])null)), val2, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemDrop), "AutoStackItems", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "HandleAutostackableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "DoCrafting", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "TransferCustomItemDataOnUpgrade", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ResetCurrentlyUpgradingItem", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			foreach (MethodInfo item2 in from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "LoadFromZDO"
				select m)
			{
				val.Patch((MethodBase)item2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypes", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "Load", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypesOnPlayerLoaded", (Type[])null, (Type[])null), 700, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[8]
			{
				typeof(string),
				typeof(int),
				typeof(int),
				typeof(int),
				typeof(long),
				typeof(string),
				typeof(Vector2i),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypesAddItem", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo2 = AccessTools.DeclaredMethod(typeof(ItemDrop), "Awake", (Type[])null, (Type[])null);
			HarmonyMethod val3 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "TrackAwakeningItem", (Type[])null, (Type[])null));
			val2 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ImportCustomDataOnUpgrade", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null);
			val.Patch((MethodBase)methodInfo2, val3, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDropAwake", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), val2, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemDrop), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDropAwakeDelayed", (Type[])null, (Type[])null), 799, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemData), "Clone", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePrefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePostfix", (Type[])null, (Type[])null), 500, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemData), "Clone", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePostfixDelayed", (Type[])null, (Type[])null), 499, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	[PublicAPI]
	public class ForeignItemInfo : IEnumerable<object>, IEnumerable
	{
		private readonly object foreignItemInfo;

		public string Mod => ((string)foreignItemInfo.GetType().GetProperty("Mod")?.GetValue(foreignItemInfo)) ?? "";

		public ItemData ItemData { get; private set; }

		public string? this[string key]
		{
			get
			{
				object obj = foreignItemInfo.GetType().InvokeMember("Item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty, null, foreignItemInfo, new object[1] { key });
				if (obj != null)
				{
					return (string)obj.GetType().GetProperty("Value")?.GetValue(obj);
				}
				return null;
			}
			set
			{
				foreignItemInfo.GetType().GetMethod("set_Item", BindingFlags.Instance | BindingFlags.Public)?.Invoke(foreignItemInfo, new object[2] { key, value });
			}
		}

		internal ForeignItemInfo(ItemData itemData, object foreignItemInfo)
		{
			ItemData = itemData;
			this.foreignItemInfo = foreignItemInfo;
		}

		public T GetOrCreate<T>(string key = "") where T : class, new()
		{
			return Add<T>(key) ?? Get<T>(key);
		}

		private object? call(string name, object?[] values, Type?[] args, Type? generic = null)
		{
			MethodInfo[] methods = foreignItemInfo.GetType().GetMethods();
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == name && (from p in methodInfo.GetParameters()
					select (!p.ParameterType.IsGenericParameter) ? p.ParameterType : null).SequenceEqual<Type>(args) && (object)generic != null == methodInfo.IsGenericMethod)
				{
					MethodInfo methodInfo2 = methodInfo;
					if ((object)generic != null)
					{
						methodInfo2 = methodInfo2.MakeGenericMethod(generic);
					}
					return methodInfo2.Invoke(foreignItemInfo, values);
				}
			}
			return null;
		}

		public T? Add<T>(string key = "") where T : class, new()
		{
			return call("Add", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as T;
		}

		public T? Get<T>(string key = "") where T : class
		{
			return call("Get", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as T;
		}

		public Dictionary<string, T> GetAll<T>() where T : class
		{
			return ((call("GetAll", Array.Empty<object>(), Array.Empty<Type>(), typeof(T)) as T) as Dictionary<string, T>) ?? new Dictionary<string, T>();
		}

		public bool Remove(string key = "")
		{
			return (call("Add", new object[1] { key }, new Type[1] { typeof(string) }) as bool?).GetValueOrDefault();
		}

		public bool Remove<T>(string key = "") where T : class
		{
			return (call("Remove", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as bool?).GetValueOrDefault();
		}

		public bool Remove<T>(T itemData) where T : class
		{
			return (call("Remove", new object[1] { itemData }, new Type[1], typeof(T)) as bool?).GetValueOrDefault();
		}

		public void Save()
		{
			call("Save", Array.Empty<object>(), Array.Empty<Type>());
		}

		public void LoadAll()
		{
			call("LoadAll", Array.Empty<object>(), Array.Empty<Type>());
		}

		public IEnumerator<object> GetEnumerator()
		{
			return (IEnumerator<object>)((call("GetEnumerator", Array.Empty<object>(), Array.Empty<Type>()) as IEnumerator<object>) ?? ((object)new List<object>().GetEnumerator()));
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[PublicAPI]
	public static class ItemExtensions
	{
		private const string className = "ItemDataManager.ItemExtensions";

		internal static readonly ConditionalWeakTable<ItemData, ItemInfo> itemInfo = new ConditionalWeakTable<ItemData, ItemInfo>();

		private static readonly ConditionalWeakTable<ItemData, Dictionary<string, ForeignItemInfo?>> foreignItemInfo = new ConditionalWeakTable<ItemData, Dictionary<string, ForeignItemInfo>>();

		public static ItemInfo Data(this ItemData item)
		{
			if (itemInfo.TryGetValue(item, out ItemInfo value))
			{
				return value;
			}
			itemInfo.Add(item, value = new ItemInfo(item));
			return value;
		}

		public static ForeignItemInfo? Data(this ItemData item, string mod)
		{
			Dictionary<string, ForeignItemInfo> orCreateValue = ItemExtensions.foreignItemInfo.GetOrCreateValue(item);
			if (orCreateValue.TryGetValue(mod, out var value))
			{
				return value;
			}
			if (!Chainloader.PluginInfos.TryGetValue(mod, out var value2))
			{
				return null;
			}
			object obj = ((object)value2.Instance).GetType().Assembly.GetType("ItemDataManager.ItemExtensions")?.GetMethod("Data", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, Array.Empty<ParameterModifier>())?.Invoke(null, new object[1] { item });
			if (obj != null)
			{
				return orCreateValue[mod] = new ForeignItemInfo(item, obj);
			}
			Debug.LogWarning((object)("Mod " + mod + " has an ItemDataManager.ItemExtensions class, but no Data(ItemDrop.ItemData) method could be called on it."));
			return orCreateValue[mod] = null;
		}
	}
}
namespace Marketplace
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class Market_Autoload : Attribute
	{
		public enum Priority
		{
			Init,
			First,
			Normal,
			Last
		}

		public enum Type
		{
			Server,
			Client,
			Both
		}

		public readonly Priority priority;

		public readonly Type type;

		public readonly string InitMethod;

		public readonly string[] OnWatcherNames;

		public readonly string[] OnWatcherMethods;

		public Market_Autoload(Type type, Priority priority = Priority.Last, string InitMethod = "OnInit", string[] OnWatcherNames = null, string[] OnWatcherMethods = null)
		{
			this.priority = priority;
			this.type = type;
			this.InitMethod = InitMethod;
			this.OnWatcherNames = OnWatcherNames;
			this.OnWatcherMethods = OnWatcherMethods;
			base..ctor();
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class ClientOnlyPatch : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class ServerOnlyPatch : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class ConditionalPatch : Attribute
	{
		[CompilerGenerated]
		private string <Condition>P;

		public ConditionalPatch(string Condition = "Condition")
		{
			<Condition>P = Condition;
			base..ctor();
		}

		public bool Check(Type t)
		{
			MethodInfo methodInfo = AccessTools.Method(t, <Condition>P, (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				return (bool)methodInfo.Invoke(null, null);
			}
			Utils.print("Error loading " + t.Name + " conditional patch, method " + <Condition>P + " not found", ConsoleColor.Red);
			return false;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public class MarketplaceRPC : Attribute
	{
		public readonly string RpcName;

		public readonly Market_Autoload.Type type;

		public MarketplaceRPC(string RpcName, Market_Autoload.Type type)
		{
			this.RpcName = RpcName;
			this.type = type;
			base..ctor();
		}
	}
	public static class ChatCommands
	{
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		[ClientOnlyPatch]
		private static class Chat_InputText_Patch_AdminCommands
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_0;

				public static ConsoleEvent <>9__0_1;

				public static Func<Market_NPC.NPCcomponent, bool> <>9__0_16;

				public static ConsoleEvent <>9__0_2;

				public static ConsoleEvent <>9__0_3;

				public static ConsoleEvent <>9__0_4;

				public static ConsoleEvent <>9__0_5;

				public static ConsoleEvent <>9__0_6;

				public static ConsoleEvent <>9__0_7;

				public static ConsoleEvent <>9__0_8;

				public static ConsoleEvent <>9__0_9;

				public static Func<KeyValuePair<string, string>, bool> <>9__0_17;

				public static ConsoleEvent <>9__0_10;

				public static ConsoleEvent <>9__0_11;

				public static ConsoleOptionsFetcher <>9__0_12;

				public static ConsoleEvent <>9__0_13;

				public static ConsoleOptionsFetcher <>9__0_14;

				public static ConsoleEvent <>9__0_15;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					AssetStorage.ReloadSounds();
					args.Context.AddString("Reloading sounds...");
				}

				internal void <Postfix>b__0_1(ConsoleEventArgs args)
				{
					AssetStorage.ReloadImages();
					args.Context.AddString("Reloading images...");
				}

				internal void <Postfix>b__0_2(ConsoleEventArgs args)
				{
					//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
					if (!Utils.IsDebug_Marketplace)
					{
						return;
					}
					IEnumerable<Market_NPC.NPCcomponent> enumerable = Market_NPC.NPCcomponent.ALL.Where((Market_NPC.NPCcomponent x) => Utils.DistanceXZ(((Component)Player.m_localPlayer).transform.position, ((Component)x).transform.position) <= 5f);
					int num = 0;
					string text = "";
					foreach (Market_NPC.NPCcomponent item in enumerable)
					{
						num++;
						string text2 = item.GetClearNPCName();
						if (string.IsNullOrWhiteSpace(text2))
						{
							text2 = Localization.instance.Localize("$mpasn_" + item._currentNpcType);
						}
						text += $"\n{num + 1}) {text2} {((Component)item).transform.position}";
						ZDOMan.instance.m_destroySendList.Add(item.znv.m_zdo.m_uid);
					}
					args.Context.AddString($"Removed total {num} NPCs in range:{text}");
				}

				internal bool <Postfix>b__0_16(Market_NPC.NPCcomponent x)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					return Utils.DistanceXZ(((Component)Player.m_localPlayer).transform.position, ((Component)x).transform.position) <= 5f;
				}

				internal void <Postfix>b__0_3(ConsoleEventArgs args)
				{
					if (Utils.IsDebug_Marketplace)
					{
						ItemData val = ((((Humanoid)Player.m_localPlayer).GetRightItem() != null) ? ((Humanoid)Player.m_localPlayer).GetRightItem() : ((Humanoid)Player.m_localPlayer).GetLeftItem());
						if (val == null)
						{
							args.Context.AddString("No weapon in hand");
							return;
						}
						string text = JSON.ToNiceJSON(val.m_customData);
						args.Context.AddString("IDM for " + ((Object)val.m_dropPrefab).name + ":\n" + text);
					}
				}

				internal void <Postfix>b__0_4(ConsoleEventArgs args)
				{
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					args.Context.AddString($"<color=green>Position: {((Component)Player.m_localPlayer).transform.position}</color>");
				}

				internal void <Postfix>b__0_5(ConsoleEventArgs args)
				{
					if (Utils.IsDebug_Marketplace && args.Args.Length >= 2)
					{
						int num = int.Parse(args.Args[1]);
						num = Mathf.Clamp(num, 50, 144);
						float fixedDeltaTime = 1f / (float)num;
						Time.fixedDeltaTime = fixedDeltaTime;
						args.Context.AddString($"<color=green>Fixed Update FPS set to {num}</color>");
					}
				}

				internal void <Postfix>b__0_6(ConsoleEventArgs _)
				{
					if (Utils.IsDebug_Marketplace)
					{
						if (ZoneVisualizer.Visualizers.Count == 0)
						{
							ZoneVisualizer.On();
						}
						else
						{
							ZoneVisualizer.Off();
						}
					}
				}

				internal void <Postfix>b__0_7(ConsoleEventArgs args)
				{
					if (args.Args.Length <= 1)
					{
						args.Context.AddString("Current Alpha: " + ZoneVisualizer.VisualizerAlpha);
						return;
					}
					if (!int.TryParse(args.Args[1], out var result))
					{
						args.Context.AddString("Invalid Alpha");
						return;
					}
					result = Mathf.Clamp(result, 25, 255);
					ZoneVisualizer.VisualizerAlpha = (float)Mathf.Clamp(result, 25, 255) / 255f;
					args.Context.AddString("Set Alpha to: " + result);
					if (ZoneVisualizer.Visualizers.Count > 0)
					{
						ZoneVisualizer.On();
					}
				}

				internal void <Postfix>b__0_8(ConsoleEventArgs args)
				{
					Quests_Main_Client.ShowQuestMark.Value = !Quests_Main_Client.ShowQuestMark.Value;
					string text = (Quests_Main_Client.ShowQuestMark.Value ? "<color=green>Enabled</color>" : "<color=red>Disabled</color>");
					args.Context.AddString("Quest Mark is now " + text);
					((ConfigEntryBase)Quests_Main_Client.ShowQuestMark).ConfigFile.Save();
				}

				internal void <Postfix>b__0_9(ConsoleEventArgs args)
				{
					if (Utils.IsDebug_Marketplace)
					{
						Player.m_localPlayer.m_customData.Clear();
					}
				}

				internal void <Postfix>b__0_10(ConsoleEventArgs args)
				{
					string text = "<color=yellow>Custom Values:</color>";
					foreach (KeyValuePair<string, string> item in Player.m_localPlayer.m_customData.Where((KeyValuePair<string, string> x) => x.Key.Contains("kgMarketplaceValue@")))
					{
						text = text + "\n<color=green>" + item.Key.Replace("kgMarketplaceValue@", "").Replace("_", " ") + "</color> = <color=yellow>" + item.Value + "</color>";
					}
					args.Context.AddString(text);
					CustomValuesShowup.Show = true;
				}

				internal bool <Postfix>b__0_17(KeyValuePair<string, string> x)
				{
					return x.Key.Contains("kgMarketplaceValue@");
				}

				internal void <Postfix>b__0_11(ConsoleEventArgs args)
				{
					//IL_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0076: Unknown result type (might be due to invalid IL or missing references)
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_007f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0080: 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)
					<>c__DisplayClass0_0 CS$<>8__locals0 = new <>c__DisplayClass0_0();
					if (Utils.IsDebug_Marketplace)
					{
						CS$<>8__locals0.playerName = "";
						for (int i = 1; i < args.Args.Length; i++)
						{
							CS$<>8__locals0.playerName = CS$<>8__locals0.playerName + args.Args[i] + " ";
						}
						CS$<>8__locals0.playerName = CS$<>8__locals0.playerName.Trim();
						PlayerInfo val = ZNet.instance.m_players.Find((PlayerInfo p) => p.m_name == CS$<>8__locals0.playerName);
						if (val.m_name == null || val.m_userInfo.m_id.m_userID == null)
						{
							args.Context.AddString("<color=red>Player " + CS$<>8__locals0.playerName + " not found</color>");
							return;
						}
						ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref val.m_characterID)).UserID, "Marketplace_ResetQuests", new object[1]);
						args.Context.AddString("<color=green>All Quests cleared for " + CS$<>8__locals0.playerName + "</color>");
					}
				}

				internal List<string> <Postfix>b__0_12()
				{
					//IL_001a: Unknown result type (might be due to invalid IL or missing references)
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					List<string> list = new List<string>();
					foreach (PlayerInfo player in ZNet.instance.m_players)
					{
						list.Add(player.m_name);
					}
					return list;
				}

				internal void <Postfix>b__0_13(ConsoleEventArgs args)
				{
					//IL_0073: Unknown result type (might be due to invalid IL or missing references)
					//IL_0078: Unknown result type (might be due to invalid IL or missing references)
					//IL_0079: Unknown result type (might be due to invalid IL or missing references)
					//IL_0081: Unknown result type (might be due to invalid IL or missing references)
					//IL_0082: 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)
					<>c__DisplayClass0_1 CS$<>8__locals0 = new <>c__DisplayClass0_1();
					if (Utils.IsDebug_Marketplace)
					{
						CS$<>8__locals0.playerName = "";
						for (int i = 1; i < args.Args.Length - 1; i++)
						{
							CS$<>8__locals0.playerName = CS$<>8__locals0.playerName + args.Args[i] + " ";
						}
						CS$<>8__locals0.playerName = CS$<>8__locals0.playerName.Trim();
						PlayerInfo val = ZNet.instance.m_players.Find((PlayerInfo p) => p.m_name == CS$<>8__locals0.playerName);
						if (val.m_name == null || val.m_userInfo.m_id.m_userID == null)
						{
							args.Context.AddString("<color=red>Player " + CS$<>8__locals0.playerName + " not found</color>");
							return;
						}
						string text = args.Args[args.Args.Length - 1];
						ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref val.m_characterID)).UserID, "Marketplace_ResetQuest", new object[1] { text });
						args.Context.AddString("<color=green>Quest " + text + " cleared for " + CS$<>8__locals0.playerName + "</color>");
					}
				}

				internal List<string> <Postfix>b__0_14()
				{
					//IL_001a: Unknown result type (might be due to invalid IL or missing references)
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					List<string> list = new List<string>();
					foreach (PlayerInfo player in ZNet.instance.m_players)
					{
						list.Add(player.m_name);
					}
					return list;
				}

				internal void <Postfix>b__0_15(ConsoleEventArgs args)
				{
					//IL_008c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0093: Expected O, but got Unknown
					if (Utils.IsDebug_Strict)
					{
						TerritorySystem_DataTypes.TerritoryShape territoryShape = (TerritorySystem_DataTypes.TerritoryShape)Enum.Parse(typeof(TerritorySystem_DataTypes.TerritoryShape), args.Args[1], ignoreCase: true);
						int num = int.Parse(args.Args[2]);
						int num2 = int.Parse(args.Args[3]);
						int num3 = int.Parse(args.Args[4]);
						byte b = byte.Parse(args.Args[5]);
						byte b2 = byte.Parse(args.Args[6]);
						byte b3 = byte.Parse(args.Args[7]);
						int num4 = int.Parse(args.Args[8]);
						ZPackage val = new ZPackage();
						val.Write((int)territoryShape);
						val.Write(num);
						val.Write(num2);
						val.Write(num3);
						val.Write(b);
						val.Write(b2);
						val.Write(b3);
						val.Write(num4);
						ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket TerritorySystem AddTerritory", new object[1] { val });
					}
				}
			}

			[CompilerGenerated]
			private sealed class <>c__DisplayClass0_0
			{
				public string playerName;

				internal bool <Postfix>b__18(PlayerInfo p)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					return p.m_name == playerName;
				}
			}

			[CompilerGenerated]
			private sealed class <>c__DisplayClass0_1
			{
				public string playerName;

				internal bool <Postfix>b__19(PlayerInfo p)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					return p.m_name == playerName;
				}
			}

			private static void Postfix()
			{
				//IL_0032: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Expected O, but got Unknown
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Expected O, but got Unknown
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Expected O, but got Unknown
				//IL_0182: 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_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Expected O, but got Unknown
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Expected O, but got Unknown
				//IL_01f2: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e9: Expected O, but got Unknown
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0216: Unknown result type (might be due to invalid IL or missing references)
				//IL_021b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0221: Expected O, but got Unknown
				//IL_0262: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_0259: Expected O, but got Unknown
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Expected O, but got Unknown
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b5: Expected O, but got Unknown
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e7: Expected O, but got Unknown
				//IL_030e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0300: Unknown result type (might be due to invalid IL or missing references)
				//IL_0305: Unknown result type (might be due to invalid IL or missing references)
				//IL_030b: Expected O, but got Unknown
				//IL_0346: Unknown result type (might be due to invalid IL or missing references)
				//IL_0332: Unknown result type (might be due to invalid IL or missing references)
				//IL_0337: Unknown result type (might be due to invalid IL or missing references)
				//IL_033d: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						AssetStorage.ReloadSounds();
						args.Context.AddString("Reloading sounds...");
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("mreloadsounds", "Reloads all sounds", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj2 = <>c.<>9__0_1;
				if (obj2 == null)
				{
					ConsoleEvent val2 = delegate(ConsoleEventArgs args)
					{
						AssetStorage.ReloadImages();
						args.Context.AddString("Reloading images...");
					};
					<>c.<>9__0_1 = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("mreloadimages", "Reloads all sounds", (ConsoleEvent)obj2, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj3 = <>c.<>9__0_2;
				if (obj3 == null)
				{
					ConsoleEvent val3 = delegate(ConsoleEventArgs args)
					{
						//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
						//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
						if (Utils.IsDebug_Marketplace)
						{
							IEnumerable<Market_NPC.NPCcomponent> enumerable = Market_NPC.NPCcomponent.ALL.Where((Market_NPC.NPCcomponent x) => Utils.DistanceXZ(((Component)Player.m_localPlayer).transform.position, ((Component)x).transform.position) <= 5f);
							int num6 = 0;
							string text5 = "";
							foreach (Market_NPC.NPCcomponent item in enumerable)
							{
								num6++;
								string text6 = item.GetClearNPCName();
								if (string.IsNullOrWhiteSpace(text6))
								{
									text6 = Localization.instance.Localize("$mpasn_" + item._currentNpcType);
								}
								text5 += $"\n{num6 + 1}) {text6} {((Component)item).transform.position}";
								ZDOMan.instance.m_destroySendList.Add(item.znv.m_zdo.m_uid);
							}
							args.Context.AddString($"Removed total {num6} NPCs in range:{text5}");
						}
					};
					<>c.<>9__0_2 = val3;
					obj3 = (object)val3;
				}
				new ConsoleCommand("mnpcremove", "Remove NPCs in range of 5 meters", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj4 = <>c.<>9__0_3;
				if (obj4 == null)
				{
					ConsoleEvent val4 = delegate(ConsoleEventArgs args)
					{
						if (Utils.IsDebug_Marketplace)
						{
							ItemData val20 = ((((Humanoid)Player.m_localPlayer).GetRightItem() != null) ? ((Humanoid)Player.m_localPlayer).GetRightItem() : ((Humanoid)Player.m_localPlayer).GetLeftItem());
							if (val20 == null)
							{
								args.Context.AddString("No weapon in hand");
							}
							else
							{
								string text4 = JSON.ToNiceJSON(val20.m_customData);
								args.Context.AddString("IDM for " + ((Object)val20.m_dropPrefab).name + ":\n" + text4);
							}
						}
					};
					<>c.<>9__0_3 = val4;
					obj4 = (object)val4;
				}
				new ConsoleCommand("idm", "Get Current Left/Right ItemDataManager values", (ConsoleEvent)obj4, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj5 = <>c.<>9__0_4;
				if (obj5 == null)
				{
					ConsoleEvent val5 = delegate(ConsoleEventArgs args)
					{
						//IL_0015: Unknown result type (might be due to invalid IL or missing references)
						args.Context.AddString($"<color=green>Position: {((Component)Player.m_localPlayer).transform.position}</color>");
					};
					<>c.<>9__0_4 = val5;
					obj5 = (object)val5;
				}
				new ConsoleCommand("mpos", "Get Current Position", (ConsoleEvent)obj5, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj6 = <>c.<>9__0_5;
				if (obj6 == null)
				{
					ConsoleEvent val6 = delegate(ConsoleEventArgs args)
					{
						if (Utils.IsDebug_Marketplace && args.Args.Length >= 2)
						{
							int num5 = int.Parse(args.Args[1]);
							num5 = Mathf.Clamp(num5, 50, 144);
							float fixedDeltaTime = 1f / (float)num5;
							Time.fixedDeltaTime = fixedDeltaTime;
							args.Context.AddString($"<color=green>Fixed Update FPS set to {num5}</color>");
						}
					};
					<>c.<>9__0_5 = val6;
					obj6 = (object)val6;
				}
				new ConsoleCommand("mfpslimit", "Set Fixed Update FPS", (ConsoleEvent)obj6, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj7 = <>c.<>9__0_6;
				if (obj7 == null)
				{
					ConsoleEvent val7 = delegate
					{
						if (Utils.IsDebug_Marketplace)
						{
							if (ZoneVisualizer.Visualizers.Count == 0)
							{
								ZoneVisualizer.On();
							}
							else
							{
								ZoneVisualizer.Off();
							}
						}
					};
					<>c.<>9__0_6 = val7;
					obj7 = (object)val7;
				}
				new ConsoleCommand("zonevisualizer", "Toggle zone visualizer", (ConsoleEvent)obj7, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj8 = <>c.<>9__0_7;
				if (obj8 == null)
				{
					ConsoleEvent val8 = delegate(ConsoleEventArgs args)
					{
						int result;
						if (args.Args.Length <= 1)
						{
							args.Context.AddString("Current Alpha: " + ZoneVisualizer.VisualizerAlpha);
						}
						else if (!int.TryParse(args.Args[1], out result))
						{
							args.Context.AddString("Invalid Alpha");
						}
						else
						{
							result = Mathf.Clamp(result, 25, 255);
							ZoneVisualizer.VisualizerAlpha = (float)Mathf.Clamp(result, 25, 255) / 255f;
							args.Context.AddString("Set Alpha to: " + result);
							if (ZoneVisualizer.Visualizers.Count > 0)
							{
								ZoneVisualizer.On();
							}
						}
					};
					<>c.<>9__0_7 = val8;
					obj8 = (object)val8;
				}
				new ConsoleCommand("zonevisualizeralpha", "Set Zone Visualizer Alpha", (ConsoleEvent)obj8, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj9 = <>c.<>9__0_8;
				if (obj9 == null)
				{
					ConsoleEvent val9 = delegate(ConsoleEventArgs args)
					{
						Quests_Main_Client.ShowQuestMark.Value = !Quests_Main_Client.ShowQuestMark.Value;
						string text3 = (Quests_Main_Client.ShowQuestMark.Value ? "<color=green>Enabled</color>" : "<color=red>Disabled</color>");
						args.Context.AddString("Quest Mark is now " + text3);
						((ConfigEntryBase)Quests_Main_Client.ShowQuestMark).ConfigFile.Save();
					};
					<>c.<>9__0_8 = val9;
					obj9 = (object)val9;
				}
				new ConsoleCommand("mquestmarker", "Enable / Disable quest mark", (ConsoleEvent)obj9, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj10 = <>c.<>9__0_9;
				if (obj10 == null)
				{
					ConsoleEvent val10 = delegate
					{
						if (Utils.IsDebug_Marketplace)
						{
							Player.m_localPlayer.m_customData.Clear();
						}
					};
					<>c.<>9__0_9 = val10;
					obj10 = (object)val10;
				}
				new ConsoleCommand("mresetcustomvalues", "Reset custom values", (ConsoleEvent)obj10, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj11 = <>c.<>9__0_10;
				if (obj11 == null)
				{
					ConsoleEvent val11 = delegate(ConsoleEventArgs args)
					{
						string text2 = "<color=yellow>Custom Values:</color>";
						foreach (KeyValuePair<string, string> item2 in Player.m_localPlayer.m_customData.Where((KeyValuePair<string, string> x) => x.Key.Contains("kgMarketplaceValue@")))
						{
							text2 = text2 + "\n<color=green>" + item2.Key.Replace("kgMarketplaceValue@", "").Replace("_", " ") + "</color> = <color=yellow>" + item2.Value + "</color>";
						}
						args.Context.AddString(text2);
						CustomValuesShowup.Show = true;
					};
					<>c.<>9__0_10 = val11;
					obj11 = (object)val11;
				}
				new ConsoleCommand("mcustomvalues", "Show Custom Values", (ConsoleEvent)obj11, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj12 = <>c.<>9__0_11;
				if (obj12 == null)
				{
					ConsoleEvent val12 = delegate(ConsoleEventArgs args)
					{
						//IL_0071: Unknown result type (might be due to invalid IL or missing references)
						//IL_0076: Unknown result type (might be due to invalid IL or missing references)
						//IL_0077: Unknown result type (might be due to invalid IL or missing references)
						//IL_007f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0080: 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)
						if (Utils.IsDebug_Marketplace)
						{
							string playerName2 = "";
							for (int j = 1; j < args.Args.Length; j++)
							{
								playerName2 = playerName2 + args.Args[j] + " ";
							}
							playerName2 = playerName2.Trim();
							PlayerInfo val19 = ZNet.instance.m_players.Find((PlayerInfo p) => p.m_name == playerName2);
							if (val19.m_name == null || val19.m_userInfo.m_id.m_userID == null)
							{
								args.Context.AddString("<color=red>Player " + playerName2 + " not found</color>");
							}
							else
							{
								ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref val19.m_characterID)).UserID, "Marketplace_ResetQuests", new object[1]);
								args.Context.AddString("<color=green>All Quests cleared for " + playerName2 + "</color>");
							}
						}
					};
					<>c.<>9__0_11 = val12;
					obj12 = (object)val12;
				}
				object obj13 = <>c.<>9__0_12;
				if (obj13 == null)
				{
					ConsoleOptionsFetcher val13 = delegate
					{
						//IL_001a: Unknown result type (might be due to invalid IL or missing references)
						//IL_001f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0021: Unknown result type (might be due to invalid IL or missing references)
						List<string> list2 = new List<string>();
						foreach (PlayerInfo player in ZNet.instance.m_players)
						{
							list2.Add(player.m_name);
						}
						return list2;
					};
					<>c.<>9__0_12 = val13;
					obj13 = (object)val13;
				}
				new ConsoleCommand("mclearallquests", "Clears all quests for player", (ConsoleEvent)obj12, false, false, false, false, false, (ConsoleOptionsFetcher)obj13, false, false, false);
				object obj14 = <>c.<>9__0_13;
				if (obj14 == null)
				{
					ConsoleEvent val14 = delegate(ConsoleEventArgs args)
					{
						//IL_0073: Unknown result type (might be due to invalid IL or missing references)
						//IL_0078: Unknown result type (might be due to invalid IL or missing references)
						//IL_0079: Unknown result type (might be due to invalid IL or missing references)
						//IL_0081: Unknown result type (might be due to invalid IL or missing references)
						//IL_0082: 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 (Utils.IsDebug_Marketplace)
						{
							string playerName = "";
							for (int i = 1; i < args.Args.Length - 1; i++)
							{
								playerName = playerName + args.Args[i] + " ";
							}
							playerName = playerName.Trim();
							PlayerInfo val18 = ZNet.instance.m_players.Find((PlayerInfo p) => p.m_name == playerName);
							if (val18.m_name == null || val18.m_userInfo.m_id.m_userID == null)
							{
								args.Context.AddString("<color=red>Player " + playerName + " not found</color>");
							}
							else
							{
								string text = args.Args[args.Args.Length - 1];
								ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref val18.m_characterID)).UserID, "Marketplace_ResetQuest", new object[1] { text });
								args.Context.AddString("<color=green>Quest " + text + " cleared for " + playerName + "</color>");
							}
						}
					};
					<>c.<>9__0_13 = val14;
					obj14 = (object)val14;
				}
				object obj15 = <>c.<>9__0_14;
				if (obj15 == null)
				{
					ConsoleOptionsFetcher val15 = delegate
					{
						//IL_001a: Unknown result type (might be due to invalid IL or missing references)
						//IL_001f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0021: Unknown result type (might be due to invalid IL or missing references)
						List<string> list = new List<string>();
						foreach (PlayerInfo player2 in ZNet.instance.m_players)
						{
							list.Add(player2.m_name);
						}
						return list;
					};
					<>c.<>9__0_14 = val15;
					obj15 = (object)val15;
				}
				new ConsoleCommand("mclearquest", "Clear quest for player", (ConsoleEvent)obj14, false, false, false, false, false, (ConsoleOptionsFetcher)obj15, false, false, false);
				object obj16 = <>c.<>9__0_15;
				if (obj16 == null)
				{
					ConsoleEvent val16 = delegate(ConsoleEventArgs args)
					{
						//IL_008c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0093: Expected O, but got Unknown
						if (Utils.IsDebug_Strict)
						{
							TerritorySystem_DataTypes.TerritoryShape territoryShape = (TerritorySystem_DataTypes.TerritoryShape)Enum.Parse(typeof(TerritorySystem_DataTypes.TerritoryShape), args.Args[1], ignoreCase: true);
							int num = int.Parse(args.Args[2]);
							int num2 = int.Parse(args.Args[3]);
							int num3 = int.Parse(args.Args[4]);
							byte b = byte.Parse(args.Args[5]);
							byte b2 = byte.Parse(args.Args[6]);
							byte b3 = byte.Parse(args.Args[7]);
							int num4 = int.Parse(args.Args[8]);
							ZPackage val17 = new ZPackage();
							val17.Write((int)territoryShape);
							val17.Write(num);
							val17.Write(num2);
							val17.Write(num3);
							val17.Write(b);
							val17.Write(b2);
							val17.Write(b3);
							val17.Write(num4);
							ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket TerritorySystem AddTerritory", new object[1] { val17 });
						}
					};
					<>c.<>9__0_15 = val16;
					obj16 = (object)val16;
				}
				new ConsoleCommand("maddterritory", "Add Territory", (ConsoleEvent)obj16, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			private static void Postfix()
			{
				ZRoutedRpc.instance.Register("Marketplace_ResetQuests", (Action<long>)delegate
				{
					foreach (string item in (from d in Player.m_localPlayer.m_customData
						where d.Key.Contains("[MPASN]quest=")
						select d.Key).ToList())
					{
						Player.m_localPlayer.m_customData.Remove(item);
						Utils.print("Cleared quest data: " + item.Replace("[MPASN]quest=", ""));
					}
					foreach (string item2 in (from d in Player.m_localPlayer.m_customData
						where d.Key.Contains("[MPASN]questCD=")
						select d.Key).ToList())
					{
						Player.m_localPlayer.m_customData.Remove(item2);
						Utils.print("Cleared quest CD data: " + item2.Replace("[MPASN]quest=", ""));
					}
					Quests_DataTypes.AcceptedQuests.Clear();
					Quests_UIs.AcceptedQuestsUI.CheckQuests();
				});
				ZRoutedRpc.instance.Register<string>("Marketplace_ResetQuest", (Action<long, string>)delegate(long _, string questUID)
				{
					Utils.print("Quest: " + questUID + " removed");
					int stableHashCode = StringExtensionMethods.GetStableHashCode(questUID.ToLower());
					Player.m_localPlayer.m_customData.Remove($"[MPASN]quest={stableHashCode}");
					Player.m_localPlayer.m_customData.Remove($"[MPASN]questCD={stableHashCode}");
					Quests_DataTypes.AcceptedQuests.Remove(stableHashCode);
					Quests_UIs.AcceptedQuestsUI.CheckQuests();
				});
			}
		}
	}
	[PublicAPI]
	public class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

		private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

		private static readonly List<WeakReference<Localization>> localizationObjects;

		private static BaseUnityPlugin? _plugin;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			localizationLanguage.TryGetValue(localization, out string value);
			string text = loadedTexts[value][key];
			if (PlaceholderProcessors.TryGetValue(key, out Dictionary<string, Func<string>> value2))
			{
				text = value2.Aggregate(text, (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, text);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, Func<T, string>? convertConfigValue = null) where T : notnull
		{
			string key2 = key;
			string placeholder2 = placeholder;
			Func<T, string> convertConfigValue2 = convertConfigValue;
			ConfigEntry<T> config2 = config;
			if (convertConfigValue2 == null)
			{
				convertConfigValue2 = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key2))
			{
				PlaceholderProcessors[key2] = new Dictionary<string, Func<string>>();
			}
			config2.SettingChanged += delegate
			{
				UpdatePlaceholder();
			};
			if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				PlaceholderProcessors[key2][placeholder2] = () => convertConfigValue2(config2.Value);
				UpdatePlaceholderText(Localization.instance, key2);
			}
		}

		public static void AddText(string key, string text)
		{
			List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
			foreach (WeakReference<Localization> localizationObject in localizationObjects)
			{
				if (localizationObject.TryGetTarget(out var target))
				{
					Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
					if (!target.m_translations.ContainsKey(key))
					{
						dictionary[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				localizationObjects.Remove(item);
			}
		}

		public static void Load()
		{
			LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
		}

		private static void LoadLocalization(Localization __instance, string language)
		{
			if (!localizationLanguage.Remove(__instance))
			{
				localizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			localizationLanguage.Add(__instance, language);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
				where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
				select f)
			{
				string text = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' })[1];
				if (dictionary.ContainsKey(text))
				{
					Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
				}
				else
				{
					dictionary[text] = item;
				}
			}
			byte[] array = LoadTranslationFromAssembly("English");
			if (array == null)
			{
				throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
			}
			Dictionary<string, string> dictionary2 = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary2 == null)
			{
				throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text2 = null;
			if (language != "English")
			{
				if (dictionary.ContainsKey(language))
				{
					text2 = File.ReadAllText(dictionary[language]);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text2 = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text2 == null && dictionary.ContainsKey("English"))
			{
				text2 = File.ReadAllText(dictionary["English"]);
			}
			if (text2 != null)
			{
				foreach (KeyValuePair<string, string> item2 in new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
				{
					dictionary2[item2.Key] = item2.Value;
				}
			}
			loadedTexts[language] = dictionary2;
			foreach (KeyValuePair<string, string> item3 in dictionary2)
			{
				UpdatePlaceholderText(__instance, item3.Key);
			}
		}

		static Localizer()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			loadedTexts = new Dictionary<string, Dictionary<string, string>>();
			localizationLanguage = new ConditionalWeakTable<Localization, string>();
			localizationObjects = new List<WeakReference<Localization>>();
			fileExtensions = new List<string>(2) { ".json", ".yml" };
			Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static byte[]? LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			string resourceFileName2 = resourceFileName;
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName2, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
	internal static class Market_Logger
	{
		public enum LogType
		{
			Banker,
			Marketplace,
			Territory,
			Trader,
			Transmog
		}

		internal static void Log(LogType type, string message)
		{
			if ((type != LogType.Trader || Global_Configs.EnableTraderLog) && (type != LogType.Transmog || Global_Configs.EnableTransmogLog))
			{
				string contents = type switch
				{
					LogType.Banker => $"[{DateTime.Now}] [Banker] " + message + "\n", 
					LogType.Marketplace => $"[{DateTime.Now}] [Marketplace] " + message + "\n", 
					LogType.Territory => $"[{DateTime.Now}] [Territory] " + message + "\n", 
					LogType.Trader => $"[{DateTime.Now}] [Trader] " + message + "\n", 
					LogType.Transmog => $"[{DateTime.Now}] [Transmog] " + message + "\n", 
					_ => "", 
				};
				File.AppendAllText(Market_Paths.LoggerPath, contents);
			}
		}

		[MarketplaceRPC("LogOnServer_mpasn", Market_Autoload.Type.Server)]
		private static void LogOnServer(long _, int type, string message)
		{
			Log((LogType)type, message);
		}
	}
	[BepInPlugin("MarketplaceAndServerNPCs", "MarketplaceAndServerNPCs", "9.8.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Marketplace : BaseUnityPlugin
	{
		public enum WorkingAs
		{
			Client,
			Server,
			Both
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class RPC_REGISTERS
		{
			private static Type GetActionRaw(int length)
			{
				return length switch
				{
					1 => typeof(Action<long>), 
					2 => typeof(Action<long, object>), 
					3 => typeof(Action<long, object, object>), 
					4 => typeof(Action<long, object, object, object>), 
					_ => null, 
				};
			}

			[UsedImplicitly]
			private static void Postfix()
			{
				foreach (KeyValuePair<MarketplaceRPC, MethodInfo> routedRPC in RoutedRPCs)
				{
					try
					{
						List<Type> list = (from p in routedRPC.Value.GetParameters()
							select p.ParameterType).ToList();
						object obj = Delegate.CreateDelegate(Expression.GetActionType(list.ToArray()), routedRPC.Value);
						list.RemoveAt(0);
						if (list.Count >= 4)
						{
							Utils.print($"Error registering RPC: {routedRPC.Key.RpcName}, method: {routedRPC.Value}, too many parameters", ConsoleColor.Red);
							continue;
						}
						MethodInfo methodInfo = ((list.Count == 0) ? AccessTools.Method(typeof(ZRoutedRpc), "Register", new Type[2]
						{
							typeof(string),
							GetActionRaw(list.Count + 1)
						}, (Type[])null) : AccessTools.Method(typeof(ZRoutedRpc), "Register", new Type[2]
						{
							typeof(string),
							GetActionRaw(list.Count + 1)
						}, (Type[])null).MakeGenericMethod(list.ToArray()));
						methodInfo.Invoke(ZRoutedRpc.instance, new object[2]
						{
							routedRPC.Key.RpcName,
							obj
						});
					}
					catch (Exception arg)
					{
						Utils.print($"Error registering RPC: {routedRPC.Key.RpcName}, method: {routedRPC.Value}, exception: {arg}", ConsoleColor.Red);
					}
				}
			}
		}

		private const string GUID = "MarketplaceAndServerNPCs";

		private const string PluginName = "MarketplaceAndServerNPCs";

		public const string PluginVersion = "9.8.1";

		internal static Marketplace _thistype = null;

		private static readonly Harmony _harmony = new Harmony("MarketplaceAndServerNPCs");

		public static Action<float> Global_Updator;

		public static Action<float> Global_FixedUpdator;

		public static Action Global_OnGUI_Updator;

		public static Action Global_Start;

		public static Type TempProfessionsType;

		public static ManualLogSource DebugLogger = Logger.CreateLogSource("MarketplaceDebug");

		public static readonly ConfigSync configSync = new ConfigSync("MarketplaceAndServerNPCs")
		{
			DisplayName = "MarketplaceAndServerNPCs",
			ModRequired = true,
			MinimumRequiredVersion = "9.8.1",
			CurrentVersion = "9.8.1",
			IsLocked = true
		};

		public static WorkingAs WorkingAsType;

		public static Dictionary<MarketplaceRPC, MethodInfo> RoutedRPCs = new Dictionary<MarketplaceRPC, MethodInfo>();

		private static readonly Dictionary<string, string> FoldersToFiles = new Dictionary<string, string>();

		private static readonly Dictionary<string, Action> FSW_Lookup = new Dictionary<string, Action>();

		private static readonly Dictionary<string, DateTime> LastConfigChangeTime = new Dictionary<string, DateTime>();

		public const string _InternalMarketplace_ = "_InternalMarketplace_";

		private void Awake()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			WorkingAsType = (((int)SystemInfo.graphicsDeviceType == 4) ? WorkingAs.Server : (((BaseUnityPlugin)this).Config.Bind<bool>("General", "Use Marketplace Locally", false, "Enable Market Local Usage").Value ? WorkingAs.Both : WorkingAs.Client));
			CollectionExtensions.Do<Type>(from t in AccessTools.GetTypesFromAssembly(Assembly.GetExecutingAssembly())
				where WorkingAsType switch
				{
					WorkingAs.Client => t.GetCustomAttribute<ServerOnlyPatch>() == null, 
					WorkingAs.Server => t.GetCustomAttribute<ClientOnlyPatch>() == null, 
					_ => true, 
				}
				where t.GetCustomAttribute<ConditionalPatch>()?.Check(t) ?? true
				select t, (Action<Type>)delegate(Type type)
			{
				_harmony.CreateClassProcessor(type).Patch();
			});
			Utils.print($"Marketplace Working As: {WorkingAsType}");
			_thistype = this;
			Logger.ChannelFilter = (LogChannel)16;
			Localizer.Load();
			TempProfessionsType = Type.GetType("Professions.Professions, Professions");
			JSON.Parameters = new JSONParameters
			{
				UseExtensions = false,
				SerializeNullValues = false,
				DateTimeMilliseconds = false,
				UseUTCDateTime = true,
				UseOptimizedDatasetSchema = true,
				UseValuesOfEnums = true,
				ShowReadOnlyProperties = true
			};
			IEnumerable<KeyValuePair<Market_Autoload, Type>> enumerable = from t in AccessTools.GetTypesFromAssembly(Assembly.GetExecutingAssembly())
				where t.GetCustomAttribute<Market_Autoload>() != null
				select t into x
				select new KeyValuePair<Market_Autoload, Type>(x.GetCustomAttribute<Market_Autoload>(), x) into x
				orderby x.Key.priority
				where WorkingAsType switch
				{
					WorkingAs.Client => x.Key.type != Market_Autoload.Type.Server, 
					WorkingAs.Server => x.Key.type != Market_Autoload.Type.Client, 
					_ => true, 
				}
				select x;
			foreach (KeyValuePair<Market_Autoload, Type> item in enumerable)
			{
				if (item.Key.OnWatcherNames != null && item.Key.OnWatcherMethods != null && item.Key.OnWatcherNames.Length == item.Key.OnWatcherMethods.Length)
				{
					for (int i = 0; i < item.Key.OnWatcherNames.Length; i++)
					{
						MethodInfo configWatcherMethod = item.Value.GetMethod(item.Key.OnWatcherMethods[i], BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						if (configWatcherMethod == null)
						{
							Utils.print("Error loading " + item.Value.Name + " class, method " + item.Key.OnWatcherMethods[i] + " not found", ConsoleColor.Red);
						}
						else
						{
							FSW_Lookup.Add(item.Key.OnWatcherNames[i], delegate
							{
								configWatcherMethod.Invoke(null, null);
							});
						}
					}
				}
				MethodInfo method = item.Value.GetMethod(item.Key.InitMethod ?? "OnInit", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					Utils.print("Error loading " + item.Value.Name + " class, method " + item.Key.InitMethod + " not found", ConsoleColor.Red);
				}
				else
				{
					try
					{
						method.Invoke(null, null);
					}
					catch (Exception arg)
					{
						Utils.print($"Autoload exception on method {method}. Class {item.Value}\n:{arg}", ConsoleColor.Red);
					}
				}
			}
			RoutedRPCs = (from m in Assembly.GetExecutingAssembly().GetTypes().SelectMany((Type t) => t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
				where m.GetCustomAttribute<MarketplaceRPC>() != null
				select m into x
				select new KeyValuePair<MarketplaceRPC, MethodInfo>(x.GetCustomAttribute<MarketplaceRPC>(), x) into x
				where WorkingAsType switch
				{
					WorkingAs.Client => x.Key.type != Market_Autoload.Type.Server, 
					WorkingAs.Server => x.Key.type != Market_Autoload.Type.Client, 
					_ => true, 
				}
				select x).ToDictionary((KeyValuePair<MarketplaceRPC, MethodInfo> x) => x.Key, (KeyValuePair<MarketplaceRPC, MethodInfo> x) => x.Value);
			InitFSW(Market_Paths.MainPath);
		}

		private void Update()
		{
			Global_Updator?.Invoke(Time.deltaTime);
		}

		private void OnGUI()
		{
			Global_OnGUI_Updator?.Invoke();
		}

		private void FixedUpdate()
		{
			Global_FixedUpdator?.Invoke(Time.fixedDeltaTime);
		}

		private void Start()
		{
			Global_Start?.Invoke();
		}

		private static void InitFSW(string folderPath)
		{
			if (WorkingAsType == WorkingAs.Client)
			{
				return;
			}
			FillFolderRoutes();
			try
			{
				FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folderPath)
				{
					Filter = "*.cfg",
					EnableRaisingEvents = true,
					IncludeSubdirectories = true,
					SynchronizingObject = ThreadingHelper.SynchronizingObject,
					NotifyFilter = NotifyFilters.LastWrite
				};
				fileSystemWatcher.Changed += MarketplaceConfigChanged;
				FileSystemWatcher fileSystemWatcher2 = new FileSystemWatcher(folderPath)
				{
					Filter = "*.yml",
					EnableRaisingEvents = true,
					IncludeSubdirectories = true,
					SynchronizingObject = ThreadingHelper.SynchronizingObject,
					NotifyFilter = NotifyFilters.LastWrite
				};
				fileSystemWatcher2.Changed += MarketplaceConfigChanged;
				FileSystemWatcher fileSystemWatcher3 = new FileSystemWatcher(folderPath)
				{
					Filter = "*.yaml",
					EnableRaisingEvents = true,
					IncludeSubdirectories = true,
					SynchronizingObject = ThreadingHelper.SynchronizingObject,
					NotifyFilter = NotifyFilters.LastWrite
				};
				fileSystemWatcher3.Changed += MarketplaceConfigChanged;
			}
			catch (Exception arg)
			{
				Utils.print($"Can't start FSW, error: {arg}", ConsoleColor.Red);
			}
		}

		private static void FillFolderRoutes()
		{
			FoldersToFiles.Add(Market_Paths.QuestsDatabaseFolder, "QD");
			FoldersToFiles.Add(Market_Paths.QuestsEventsFolder, "QE");
			FoldersToFiles.Add(Market_Paths.QuestsProfilesFolder, "QP");
			FoldersToFiles.Add(Market_Paths.DialoguesCustomSpawnDataFolder, "DSCD");
			FoldersToFiles.Add(Market_Paths.DialoguesFolder, "DI");
			FoldersToFiles.Add(Market_Paths.TerritoriesFolder, "TD");
			FoldersToFiles.Add(Market_Paths.BankerProfilesFolder, "BA");
			FoldersToFiles.Add(Market_Paths.TeleportHubProfilesFolder, "TE");
			FoldersToFiles.Add(Market_Paths.TraderProfilesFolder, "TR");
			FoldersToFiles.Add(Market_Paths.TransmogrificationFolder, "TM");
			FoldersToFiles.Add(Market_Paths.BufferDatabaseFolder, "BD");
			FoldersToFiles.Add(Market_Paths.BufferProfilesFolder, "BP");
			FoldersToFiles.Add(Market_Paths.ServerInfoProfilesFolder, "SI");
			FoldersToFiles.Add(Market_Paths.GamblerProfilesFolder, "GP");
			FoldersToFiles.Add(Market_Paths.LeaderboardAchievementsFolder, "LA");
			FoldersToFiles.Add(Market_Paths.LootboxesFolder, "LB");
		}

		private static void MarketplaceConfigChanged(object sender, FileSystemEventArgs e)
		{
			WatcherChangeTypes changeType = e.ChangeType;
			if ((changeType != WatcherChangeTypes.Deleted && changeType != WatcherChangeTypes.Changed) || 1 == 0)
			{
				return;
			}
			string directoryName = Path.GetDirectoryName(e.FullPath);
			string text = Path.GetFileName(e.Name);
			if (text.Contains("_InternalMarketplace_"))
			{
				return;
			}
			foreach (KeyValuePair<string, string> foldersToFile in FoldersToFiles)
			{
				if (directoryName.Contains(foldersToFile.Key))
				{
					text = foldersToFile.Value;
					break;
				}
			}
			if (!FSW_Lookup.TryGetValue(text, out Action value))
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
			{
				Utils.print("FSW: Not a server, ignoring (" + e.Name + ")", ConsoleColor.Red);
				return;
			}
			if (!LastConfigChangeTime.ContainsKey(text))
			{
				LastConfigChangeTime[text] = DateTime.MinValue;
			}
			if (!(LastConfigChangeTime[text] > DateTime.Now.AddSeconds(-3.0)))
			{
				LastConfigChangeTime[text] = DateTime.Now;
				Utils.DelayedAction(value);
			}
		}
	}
	public static class IsExternalInit
	{
	}
	public static class FixPossibleErrors
	{
		[HarmonyPatch(typeof(CharacterAnimEvent), "Awake")]
		[ClientOnlyPatch]
		private static class Fix1
		{
			private static bool Prefix(CharacterAnimEvent __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponentInParent<Character>() != (Object)null)
				{
					return true;
				}
				Object.Destroy((Object)(object)__instance);
				return false;
			}
		}

		[HarmonyPatch(typeof(LevelEffects), "Start")]
		[ClientOnlyPatch]
		private static class Fix2
		{
			private static bool Prefix(LevelEffects __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponentInParent<Character>() == (Object)null)
				{
					Object.Destroy((Object)(object)__instance);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Minimap), "Start")]
		[ClientOnlyPatch]
		private static class SetMaxPins
		{
			public static void Postfix(Minimap __instance)
			{
				if (__instance.m_visibleIconTypes.Length < 200)
				{
					__instance.m_visibleIconTypes = new bool[200];
					for (int i = 0; i < __instance.m_visibleIconTypes.Length; i++)
					{
						__instance.m_visibleIconTypes[i] = true;
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		[ClientOnlyPatch]
		private static class InventoryGui_Show_Patch
		{
			[UsedImplicitly]
			private static bool Prefix(InventoryGui __instance)
			{
				if (!Input.GetKey((KeyCode)308))
				{
					return !TextInput.IsVisible();
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
		[ClientOnlyPatch]
		private static class GameCamera_UpdateCamera_Patch
		{
			private static void Nullify(ref float f)
			{
				if (TextInput.IsVisible())
				{
					f = 0f;
				}
			}

			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> code)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Expected O, but got Unknown
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(code, (ILGenerator)null);
				MethodInfo methodInfo = AccessTools.Method(typeof(ZInput), "GetMouseScrollWheel", (Type[])null, (Type[])null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null)
				});
				if (val.IsInvalid)
				{
					Utils.print($"GameCamera_UpdateCamera_Patch: failed to match {methodInfo}", ConsoleColor.Red);
					return code;
				}
				val.Advance(2);
				val.Insert((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldloca_S, (object)2),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GameCamera_UpdateCamera_Patch), "Nullify", (Type[])null, (Type[])null))
				});
				return val.Instructions();
			}
		}
	}
	public static class GameEvents
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[ClientOnlyPatch]
		private static class Player_SetLocalPlayer_Patch
		{
			public static bool firstTime = true;

			[UsedImplicitly]
			private static void Postfix()
			{
				if (firstTime)
				{
					firstTime = false;
					OnPlayerFirstSpawn?.Invoke();
				}
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				Player_SetLocalPlayer_Patch.firstTime = true;
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		[ClientOnlyPatch]
		private static class Player_OnDeath_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Player __instance)
			{
				if (!((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
				{
					OnPlayerDeath?.Invoke();
				}
			}
		}

		[HarmonyPatch(typeof(Character), "ApplyDamage")]
		[ClientOnlyPatch]
		private static class Character_ApplyDamage_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Character __instance, ref HitData hit)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && ((Character)Player.m_localPlayer).GetHealth() <= 0f)
				{
					Character attacker = hit.GetAttacker();
					if (attacker != null)
					{
						string obj = (attacker.IsPlayer() ? ("PLAYER_" + ((Player)attacker).GetPlayerName()) : Utils.GetPrefabName(((Component)attacker).gameObject));
						KilledBy?.Invoke(obj);
					}
				}
			}
		}

		public static Action OnPlayerFirstSpawn;

		public static Action<string, int> OnCreatureKilled;

		public static Action<string> OnStructureBuilt;

		public static Action<string, int> OnItemCrafted;

		public static Action<string> KilledBy;

		public static Action<string> OnHarvest;

		public static Action OnPlayerDeath;
	}
	public static class PhotoManager
	{
		public class ScreenshotStuff
		{
			private class RenderObject
			{
				public readonly GameObject Spawn;

				public readonly Vector3 Size;

				public RenderRequest Request;

				public RenderObject(GameObject spawn, Vector3 size)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Spawn = spawn;
					Size = size;
				}
			}

			private class RenderRequest
			{
				public readonly GameObject Target;

				public int Level = 1;

				public int Width { get; set; } = 128;


				public int Height { get; set; } = 128;


				public Quaternion Rotation { get; set; } = Quaternion.Euler(23f, 51f, 25.8f);


				public float FieldOfView { get; set; } = 0.5f;


				public RenderRequest(GameObject target)
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					Target = target;
				}
			}

			private readonly GameObject INACTIVE;

			private readonly Camera rendererCamera;

			private readonly Light Light;

			private readonly Dictionary<long, Sprite> CachedSprites = new Dictionary<long, Sprite>();

			private static readonly Vector3 SpawnPoint = new Vector3(10000f, 10000f, 10000f);

			private const int MAINLAYER = 31;

			private static Dictionary<Type, List<Type>> componentDependencies = new Dictionary<Type, List<Type>>();

			private static readonly int Movement = Animator.StringToHash("Movement");

			public Sprite GetSprite(string prefab, Sprite defaultValue, int level)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(prefab);
				if (CachedSprites.TryGetValue(stableHashCode, out Sprite value))
				{
					return value;
				}
				level = Mathf.Clamp(level, 1, 3);
				int num = StringExtensionMethods.GetStableHashCode(prefab) + level;
				if (CachedSprites.TryGetValue(num, out Sprite value2))
				{
					return value2;
				}
				return defaultValue;
			}

			public ScreenshotStuff()
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("INACTIVEscreenshotHelper")
				{
					layer = 31
				};
				val.transform.localScale = Vector3.one;
				INACTIVE = val;
				INACTIVE.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)INACTIVE);
				rendererCamera = new GameObject("Render Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				rendererCamera.backgroundColor = new Color(0f, 0f, 0f, 0f);
				rendererCamera.clearFlags = (CameraClearFlags)2;
				((Component)rendererCamera).transform.position = SpawnPoint;
				((Component)rendererCamera).transform.rotation = Quaternion.Euler(0f, 180f, 0f);
				rendererCamera.fieldOfView = 0.5f;
				rendererCamera.farClipPlane = 100000f;
				rendererCamera.cullingMask = int.MinValue;
				Object.DontDestroyOnLoad((Object)(object)rendererCamera);
				Light = new GameObject("Render Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)Light).transform.position = SpawnPoint;
				((Component)Light).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
				Light.type = (LightType)1;
				Light.intensity = 0.5f;
				Light.cullingMask = int.MinValue;
				Object.DontDestroyOnLoad((Object)(object)Light);
				((Component)rendererCamera).gameObject.SetActive(false);
				((Component)Light).gameObject.SetActive(false);
			}

			private void ClearRendering()
			{
				((Component)rendererCamera).gameObject.SetActive(false);
				((Component)Light).gameObject.SetActive(false);
			}

			private static bool IsVisualComponent(Component component)
			{
				if (component is Renderer || component is MeshFilter || component is Transform || component is LevelEffects)
				{
					return true;
				}
				return false;
			}

			private static List<Type> GetComponentDependencies(Type node)
			{
				if (!componentDependencies.TryGetValue(node, out List<Type> value))
				{
					value = new List<Type>();
					foreach (RequireComponent customAttribute in ((MemberInfo)node).GetCustomAttributes<RequireComponent>(inherit: true))
					{
						value.Add(customAttribute.m_Type0);
						value.Add(customAttribute.m_Type1);
						value.Add(customAttribute.m_Type2);
					}
					value = value.Where((Type t) => t != null).Distinct().ToList();
					componentDependencies[node] = value;
				}
				return value;
			}

			private static bool TopologicalSortUtil(Type node, HashSet<Type> visited, HashSet<Type> recursionStack, List<Type> result)
			{
				if (visited.Contains(node))
				{
					return true;
				}
				List<Type> list = null;
				int num = result.FindIndex(node.IsSubclassOf);
				if (num != -1)
				{
					list = result.Skip(num).ToList();
					result.RemoveRange(num, result.Count - num);
				}
				if (recursionStack.Contains(node))
				{
					return false;
				}
				recursionStack.Add(node);
				List<Type> list2 = GetComponentDependencies(node);
				foreach (Type item in list2)
				{
					if (!TopologicalSortUtil(item, visited, recursionStack, result))
					{
						return false;
					}
				}
				if (list != null)
				{
					result.AddRange(list);
				}
				else
				{
					result.Add(node);
				}
				recursionStack.Remove(node);
				visited.Add(node);
				return true;
			}

			private static List<Type> GetTopolocialSort(Transform tranform)
			{
				List<Type> list = new List<Type>();
				HashSet<Type> visited = new HashSet<Type>();
				HashSet<Type> recursionStack = new HashSet<Type>();
				Component[] components = ((Component)tranform).gameObject.GetComponents<Component>();
				foreach (Component val in components)
				{
					if (!TopologicalSortUtil(((object)val).GetType(), visited, recursionStack, list))
					{
						return null;
					}
				}
				list.Reverse();
				return list;
			}

			private static bool RecursivelyRemoveComponents(Transform parentTransform)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)parentTransform).gameObject;
				for (int i = 0; i < parentTransform.childCount; i++)
				{
					RecursivelyRemoveComponents(parentTransform.GetChild(i));
				}
				List<Type> topolocialSort = GetTopolocialSort(parentTransform);
				foreach (Type item in topolocialSort)
				{
					Component[] components = gameObject.GetComponents(item);
					foreach (Component val in components)
					{
						if (val is Animator)
						{
							((Behaviour)(Animator)val).enabled = false;
						}
						else if (!IsVisualComponent(val))
						{
							try
							{
								Object.DestroyImmediate((Object)(object)val);
							}
							catch (Exception)
							{
								return false;
							}
						}
					}
				}
				return true;
			}

			private GameObject SpawnAndRemoveComponents(RenderRequest obj)
			{
				GameObject val = Object.Instantiate<GameObject>(obj.Target, INACTIVE.transform);
				if (!RecursivelyRemoveComponents(val.transform))
				{
					return null;
				}
				val.layer = 31;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				foreach (Transform val2 in componentsInChildren)
				{
					((Component)val2).gameObject.layer = 31;
				}
				LevelEffects componentInChildren = val.GetComponentInChildren<LevelEffects>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					obj.Level = Mathf.Clamp(obj.Level, 1, 3);
					if (obj.Level > 1)
					{
						SETLEVEL(componentInChildren, obj.Level, ((Object)obj.Target).name);
					}
				}
				else
				{
					obj.Level = 0;
				}
				val.transform.SetParent((Transform)null);
				val.SetActive(true);
				((Object)val).name = ((Object)obj.Target).name;
				return val;
			}

			private void SETLEVEL(LevelEffects effects, int level, string prefab)
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				if (effects.m_levelSetups.Count < level - 1)
				{
					return;
				}
				LevelSetup val = effects.m_levelSetups[level - 2];
				if (Object.op_Implicit((Object)(object)effects.m_mainRender))
				{
					string key = prefab + level;
					if (LevelEffects.m_materials.TryGetValue(key, out var value))
					{
						Material[] sharedMaterials = effects.m_mainRender.sharedMaterials;
						sharedMaterials[0] = value;
						effects.m_mainRender.sharedMaterials = sharedMaterials;
					}
					else
					{
						Material[] sharedMaterials2 = effects.m_mainRender.sharedMaterials;
						sharedMaterials2[0] = new Material(sharedMaterials2[0]);
						sharedMaterials2[0].SetFloat(Hue, val.m_hue);
						sharedMaterials2[0].SetFloat(Saturation, val.m_saturation);
						sharedMaterials2[0].SetFloat(Value, val.m_value);
						effects.m_mainRender.sharedMaterials = sharedMaterials2;
						LevelEffects.m_materials[key] = sharedMaterials2[0];
					}
				}
				if (Object.op_Implicit((Object)(object)effects.m_baseEnableObject))
				{
					effects.m_baseEnableObject.SetActive(false);
				}
				if (Object.op_Implicit((Object)(object)val.m_enableObject))
				{
					val.m_enableObject.SetActive(true);
				}
			}

			public void MakeSprite(GameObject prefabArg, int level = 1)
			{
				//IL_006e: 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)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = null;
				try
				{
					((Component)rendererCamera).gameObject.SetActive(true);
					((Component)Light).gameObject.SetActive(true);
					RenderRequest renderRequest = new RenderRequest(prefabArg);
					val = SpawnAndRemoveComponents(renderRequest);
					if ((Object)(object)val == (Object)null)
					{
						CachedSprites[StringExtensionMethods.GetStableHashCode(((Object)val).name) + level] = null;
						ClearRendering();
						return;
					}
					Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>();
					val.transform.position = Vector3.zero;
					val.transform.rotation = Quaternion.Euler(0f, -24f, 0f);
					Vector3 val2 = default(Vector3);
					((Vector3)(ref val2))..ctor(1000f, 1000f, 1000f);
					Vector3 val3 = default(Vector3);
					((Vector3)(ref val3))..ctor(-1000f, -1000f, -1000f);
					Renderer[] array = componentsInChildren;
					foreach (Renderer val4 in array)
					{
						if (!(val4 is ParticleSystemRenderer))
						{
							Vector3 val5 = val2;
							Bounds bounds = val4.bounds;
							val2 = Vector3.Min(val5, ((Bounds)(ref bounds)).min);
							Vector3 val6 = val3;
							bounds = val4.bounds;
							val3 = Vector3.Max(val6, ((Bounds)(ref bounds)).max);
						}
					}
					val.transform.position = SpawnPoint - (val2 + val3) / 2f;
					Vector3 size = default(Vector3);
					((Vector3)(ref size))..ctor(Mathf.Abs(val2.x) + Mathf.Abs(val3.x), Mathf.Abs(val2.y) + Mathf.Abs(val3.y), Mathf.Abs(val2.z) + Mathf.Abs(val3.z));
					RenderObject renderObject = new RenderObject(val, size)
					{
						Request = renderRequest
					};
					RenderSprite(renderObject);
					Object.DestroyImmediate((Object)(object)val);
					ClearRendering();
				}
				catch (Exception arg)
				{
					Utils.print($"Error while MakeSprite({((Object)prefabArg).name}): {arg}");
				}
				finally
				{
					if (Object.op_Implicit((Object)(object)val))
					{
						Object.DestroyImmediate((Object)(object)val);
					}
					ClearRendering();
				}
			}

			private void RenderSprite(RenderObject renderObject)
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Expected O, but got Unknown
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				int width = renderObject.Request.Width;
				int height = renderObject.Request.Height;
				RenderTexture active = RenderTexture.active;
				RenderTexture temporary = RenderTexture.GetTemporary(width, height, 32);
				rendererCamera.targetTexture = temporary;
				rendererCamera.fieldOfView = renderObject.Request.FieldOfView;
				RenderTexture.active = rendererCamera.targetTexture;
				float num = Mathf.Max(renderObject.Size.x, renderObject.Size.y);
				float num2 = num / Mathf.Tan(rendererCamera.fieldOfView * ((float)Math.PI / 180f));
				((Component)rendererCamera).transform.position = SpawnPoint + new Vector3(0f, 0f, num2);
				Animator[] componentsInChildren = renderObject.Spawn.GetComponentsInChildren<Animator>();
				Animator[] array = componentsInChildren;
				foreach (Animator val in array)
				{
					((Behaviour)val).enabled = true;
					if (val.HasState(0, Movement))
					{
						val.Play(Movement);
					}
					val.Update(0f);
				}
				rendererCamera.Render();
				Texture2D val2 = new Texture2D(width, height, (TextureFormat)4, false);
				val2.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
				val2.Apply();
				RenderTexture.active = active;
				rendererCamera.targetTexture = null;
				RenderTexture.ReleaseTemporary(temporary);
				Sprite value = Sprite.Create(val2, new Rect(0f, 0f, (float)width, (float)height), Vector2.one / 2f);
				CachedSprites[StringExtensionMethods.GetStableHashCode(((Object)renderObject.Spawn).name) + renderObject.Request.Level] = value;
			}
		}

		public static readonly ScreenshotStuff __instance = new ScreenshotStuff();

		private static readonly int Hue = Shader.PropertyToID("_Hue");

		private static readonly int Saturation = Shader.PropertyToID("_Saturation");

		private static readonly int Value = Shader.PropertyToID("_Value");
	}
	public static class Utils
	{
		public class SelfSocket : ISocket
		{
			public bool IsConnected()
			{
				return true;
			}

			public string GetHostName()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return ((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID.m_userID;
			}

			public void Send(ZPackage pkg)
			{
				throw new NotImplementedException();
			}

			public ZPackage Recv()
			{
				throw new NotImplementedException();
			}

			public int GetSendQueueSize()
			{
				throw new NotImplementedException();
			}

			public int GetCurrentSendRate()
			{
				throw new NotImplementedException();
			}

			public bool IsHost()
			{
				return true;
			}

			public void Dispose()
			{
				throw new NotImplementedException();
			}

			public bool GotNewData()
			{
				throw new NotImplementedException();
			}

			public void Close()
			{
				throw new NotImplementedException();
			}

			public string GetEndPointString()
			{
				throw new NotImplementedException();
			}

			public void GetAndResetStats(out int totalSent, out int totalRecv)
			{
				throw new NotImplementedException();
			}

			public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
			{
				throw new NotImplementedException();
			}

			public ISocket Accept()
			{
				throw new NotImplementedException();
			}

			public int GetHostPort()
			{
				throw new NotImplementedException();
			}

			public bool Flush()
			{
				throw new NotImplementedException();
			}

			public void VersionMatch()
			{
				throw new NotImplementedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayReloadConfigFile>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ConfigFile file;

			public Action action;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(1.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					file.Reload();
					<>2__current = (object)new WaitForSecondsRealtime(1.5f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					action?.Invoke();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedActionRoutine>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Action action;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(1.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					action?.Invoke();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <SkipOneFrameRoutine>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Action action;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					action?.Invoke();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <_Internal_LoadImage>d__43 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public Action<Sprite> callback;

			private UnityWebRequest <request>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Invalid comparison between Unknown and I4
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<request>5__2 = UnityWebRequestTexture.GetTexture(url);
						<>1__state = -3;
						<>2__current = <request>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					case 1:
						{
							<>1__state = -3;
							if ((int)<request>5__2.result == 1)
							{
								Texture2D content = DownloadHandlerTexture.GetContent(<request>5__2);
								if (((Texture)content).width == 0 || ((Texture)content).height == 0)
								{
									result = false;
									goto IL_011b;
								}
								Texture2D val = new Texture2D(((Texture)content).width, ((Texture)content).height, (TextureFormat)4, false);
								val.SetPixels(content.GetPixels());
								val.Apply();
								AssetStorage.GlobalCachedSprites[url] = Sprite.Create(content, new Rect(0f, 0f, (float)((Texture)content).width, (float)((Texture)content).height), new Vector2(0.5f, 0.5f));
								callback?.Invoke(AssetStorage.GlobalCachedSprites[url]);
							}
							result = false;
							goto IL_011b;
						}
						IL_011b:
						<>m__Finally1();
						break;
					}
				}
				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;
				if (<request>5__2 != null)
				{
					((IDisposable)<request>5__2).Dispose();
				}
			}

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

		private static readonly string[] SizeSuffixes = new string[9] { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };

		private const string CustomValue_Prefix = "kgMarketplaceValue@";

		public static bool IsDebug_Marketplace
		{
			get
			{
				if (!Player.m_debugMode && !ZNet.IsSinglePlayer)
				{
					return CustomDebug();
				}
				return true;
			}
		}

		public static bool IsDebug_Strict => Player.m_debugMode;

		public static string GetItemForTooltip(string prefab, int Count, int Quality, int Variant, long CrafterID, string CrafterName, string CustomData, byte DurabilityPercent, Action<ItemData> callback = null)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
			ItemData itemData = prefab2.GetComponent<ItemDrop>().m_itemData;
			SharedData shared = itemData.m_shared;
			Dictionary<string, string> customData = itemData.m_customData;
			itemData.m_shared = (SharedData)AccessTools.DeclaredMethod(typeof(object), "MemberwiseClone", (Type[])null, (Type[])null).Invoke(shared, Array.Empty<object>());
			itemData.m_customData = JSON.ToObject<Dictionary<string, string>>(CustomData);
			ItemData val = itemData.Clone();
			itemData.m_customData = customData;
			itemData.m_shared = shared;
			val.m_stack = Count;
			val.m_quality = Quality;
			val.m_variant = Variant;
			val.m_crafterID = CrafterID;
			val.m_crafterName = CrafterName;
			val.m_durability = val.GetMaxDurability() * (float)(int)DurabilityPercent / 100f;
			string result = val.GetTooltip(-1).Localize();
			callback?.Invoke(val);
			return result;
		}

		private static bool CustomDebug()
		{
			if (Global_Configs.SyncedGlobalOptions.Value._overrideDebug.Count != 0)
			{
				return Global_Configs.SyncedGlobalOptions.Value._overrideDebug.Contains(Global_Configs._localUserID);
			}
			return false;
		}

		public static void print(object obj, ConsoleColor color = ConsoleColor.DarkGreen)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)Application.platform == 2)
			{
				ConsoleManager.SetConsoleColor(color);
				ConsoleManager.StandardOutStream.WriteLine($"[{DateTime.Now}] [kg.Marketplace] {obj}");
				ConsoleManager.SetConsoleColor(ConsoleColor.White);
				{
					foreach (ILogListener listener in Logger.Listeners)
					{
						DiskLogListener val = (DiskLogListener)(object)((listener is DiskLogListener) ? listener : null);
						if (val != null && val.LogWriter != null)
						{
							val.LogWriter.WriteLine($"[{DateTime.Now}] [kg.Marketplace] {obj}");
						}
					}
					return;
				}
			}
			MonoBehaviour.print((object)($"[{DateTime.Now}] [kg.Marketplace] " + obj));
		}

		public static void arr_print(IEnumerable arr, ConsoleColor color = ConsoleColor.DarkGreen)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)Application.platform == 2)
			{
				ConsoleManager.SetConsoleColor(color);
				ConsoleManager.StandardOutStream.WriteLine($"[Marketplace] printing array: {arr}");
				int num = 0;
				foreach (object item in arr)
				{
					ConsoleManager.StandardOutStream.WriteLine($"[{num++}] {item}");
					foreach (ILogListener listener in Logger.Listeners)
					{
						DiskLogListener val = (DiskLogListener)(object)((listener is DiskLogListener) ? listener : null);
						if (val != null && val.LogWriter != null)
						{
							val.LogWriter.WriteLine($"[{num++}] {item}");
						}
					}
				}
				ConsoleManager.SetConsoleColor(ConsoleColor.White);
				return;
			}
			MonoBehaviour.print((object)("[Marketplace] " + arr));
			int num2 = 0;
			foreach (object item2 in arr)
			{
				MonoBehaviour.print((object)$"[{num2++}] {item2}");
			}
		}

		[IteratorStateMachine(typeof(<DelayReloadConfigFile>d__9))]
		private static IEnumerator DelayReloadConfigFile(ConfigFile file, Action action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayReloadConfigFile>d__9(0)
			{
				file = file,
				action = action
			};
		}

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

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

		public static void DelayedAction(Action action)
		{
			if (action != null)
			{
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(DelayedActionRoutine(action));
			}
		}

		public static void SkipOneFrame(Action action)
		{
			if (action != null)
			{
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(SkipOneFrameRoutine(action));
			}
		}

		public static void DelayReloadConfig(ConfigFile file, Action action = null)
		{
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(DelayReloadConfigFile(file, action));
		}

		public static void CopyComponent<T>(T original, GameObject destination) where T : Component
		{
			Type type = ((object)original).GetType();
			Component obj = destination.AddComponent(type);
			try
			{
				PropertyInfo[] properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				PropertyInfo[] array = properties;
				foreach (PropertyInfo propertyInfo in array)
				{
					if (propertyInfo.CanWrite)
					{
						propertyInfo.SetValue(obj, propertyInfo.GetValue(original, null), null);
					}
				}
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				FieldInfo[] array2 = fields;
				foreach (FieldInfo fieldInfo in array2)
				{
					fieldInfo.SetValue(obj, fieldInfo.GetValue(original));
				}
			}
			catch
			{
			}
		}

		public static void CustomFindFloor(Vector3 p, out float height, float offset = 1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			height = (Physics.SphereCast(p + Vector3.up * offset, 0.05f, Vector3.down, ref val, 100f, ZoneSystem.instance.m_solidRayMask) ? ((RaycastHit)(ref val)).point.y : 0f);
		}

		public static string NoRichText(this string source)
		{
			return Regex.Replace(source, "<[^>]*>", "");
		}

		public static string RemoveRichTextDynamicTag(string input, string tag)
		{
			while (true)
			{
				int num = input.IndexOf("<" + tag + "=", StringComparison.Ordinal);
				if (num == -1)
				{
					break;
				}
				int num2 = input.Substring(num, input.Length - num).IndexOf('>');
				if (num2 > 0)
				{
					input = input.Remove(num, num2 + 1);
				}
			}
			input = RemoveRichTextTag(input, tag, isStart: false);
			return input;
		}

		private static string RemoveRichTextTag(string input, string tag, bool isStart = true)
		{
			while (true)
			{
				int num = input.IndexOf(isStart ? ("<" + tag + ">") : ("</" + tag + ">"), StringComparison.Ordinal);
				if (num == -1)
				{
					break;
				}
				input = input.Remove(num, 2 + tag.Length + (!isStart).GetHashCode());
			}
			if (isStart)
			{
				input = RemoveRichTextTag(input, tag, isStart: false);
			}
			return input;
		}

		public static string RichTextFormatting(string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return "";
			}
			input = RemoveRichTextDynamicTag(input, "size");
			string[] array = input.Split(new string[1] { "<icon>" }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0)
			{
				return "";
			}
			return array[0];
		}

		public static bool IsHovering(this GameObject go)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			PointerEventData val = new PointerEventData(EventSystem.current)
			{
				position = Vector2.op_Implicit(Input.mousePosition)
			};
			List<RaycastResult> list = new List<RaycastResult>();
			EventSystem.current.RaycastAll(val, list);
			if (list.Count > 0)
			{
				RaycastResult val2 = list[0];
				return (Object)(object)((RaycastResult)(ref val2)).gameObject == (Object)(object)go;
			}
			return false;
		}

		public static int CustomCountItems(string prefab, int level)
		{
			int num = 0;
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory)
			{
				if (((Object)item.m_dropPrefab).name == prefab && level == item.m_quality)
				{
					num += item.m_stack;
				}
			}
			return num;
		}

		public static PinData GetCustomPin(PinType type, Vector3 pos, float radius)
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			PinData val = null;
			float num = 999999f;
			foreach (PinData pin in Minimap.instance.m_pins)
			{
				if (pin.m_type == type)
				{
					float num2 = Utils.DistanceXZ(pos, pin.m_pos);
					if (num2 < radius && (num2 < num || val == null))
					{
						val = pin;
						num = num2;
					}
				}
			}
			return val;
		}

		public static Texture2D CustomSize(this Texture2D texture2D, int targetX, int targetY)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			RenderTexture val2 = (RenderTexture.active = new RenderTexture(targetX, targetY, 24));
			Graphics.Blit((Texture)(object)texture2D, val2);
			Texture2D val3 = new Texture2D(targetX, targetY);
			val3.ReadPixels(new Rect(0f, 0f, (float)targetX, (float)targetY), 0, 0);
			val3.Apply();
			return val3;
		}

		public static string AsBase64(this string s)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
		}

		public static int CustomCountItemsNoLevel(string prefab)
		{
			int num = 0;
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory)
			{
				if (((Object)item.m_dropPrefab).name == prefab)
				{
					num += item.m_stack;
				}
			}
			return num;
		}

		public static void CustomRemoveItems(string prefab, int amount, int level)
		{
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory)
			{
				if (((Object)item.m_dropPrefab).name == prefab && item.m_quality == level)
				{
					int num = Mathf.Min(item.m_stack, amount);
					item.m_stack -= num;
					amount -= num;
					if (amount <= 0)
					{
						break;
					}
				}
			}
			((Humanoid)Player.m_localPlayer).m_inventory.m_inventory.RemoveAll((ItemData x) => x.m_stack <= 0);
			((Humanoid)Player.m_localPlayer).m_inventory.Changed();
		}

		public static string SizeSuffix(this int value, int decimalPlaces = 1)
		{
			if (value >= 0)
			{
				if (value == 0)
				{
					return string.Format("{0:n" + decimalPlaces + "} bytes", 0);
				}
				int num = (int)Math.Log(value, 1024.0);
				decimal num2 = (decimal)value / (decimal)(1L << num * 10);
				if (Math.Round(num2, decimalPlaces) < 1000m)
				{
					return string.Format("{0:n" + decimalPlaces + "} {1}", num2, SizeSuffixes[num]);
				}
				num++;
				num2 /= 1024m;
				return string.Format("{0:n" + decimalPlaces + "} {1}", num2, SizeSuffixes[num]);
			}
			return "-" + (-value).SizeSuffix(decimalPlaces);
		}

		public static void Decompress(this ZPackage pkg)
		{
			byte[] buffer = Utils.Decompress(pkg.GetArray());
			pkg.Clear();
			pkg.m_writer.Write(buffer);
			pkg.m_stream.Position = 0L;
		}

		public static void WriteFile(this string path, string data)
		{
			File.WriteAllText(path, data);
		}

		public static string ReadFile(this string path)
		{
			return File.ReadAllText(path);
		}

		public static void Compress(this ZPackage pkg)
		{
			byte[] array = pkg.GetArray();
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionLevel.Optimal))
			{
				gZipStream.Write(array, 0, array.Length);
			}
			byte[] buffer = memoryStream.ToArray();
			pkg.Clear();
			pkg.m_writer.Write(buffer);
		}

		public static void AddItemToPlayer(GameObject prefab, int count, int level, Dialogues_DataTypes.CustomSpawnZDO customData = null)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)prefab))
			{
				return;
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (component != null)
			{
				if (component.m_itemData.m_shared.m_maxStackSize > 1)
				{
					GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					if (customData != null)
					{
						ZNetView component2 = val.GetComponent<ZNetView>();
						if (component2 != null)
						{
							if (customData.Ints != null)
							{
								foreach (KeyValuePair<string, int> @int in customData.Ints)
								{
									component2.m_zdo.Set(@int.Key, @int.Value);
								}
							}
							if (customData.Floats != null)
							{
								foreach (KeyValuePair<string, float> @float in customData.Floats)
								{
									component2.m_zdo.Set(@float.Key, @float.Value);
								}
							}
							if (customData.Strings != null)
							{
								foreach (KeyValuePair<string, string> @string in customData.Strings)
								{
									component2.m_zdo.Set(@string.Key, @string.Value);
								}
							}
							if (customData.Bools != null)
							{
								foreach (KeyValuePair<string, bool> @bool in customData.Bools)
								{
									component2.m_zdo.Set(@bool.Key, @bool.Value);
								}
							}
						}
					}
					ItemDrop component3 = val.GetComponent<ItemDrop>();
					component3.m_itemData.m_quality = level;
					component3.m_itemData.m_stack = count;
					component3.m_itemData.m_durability = component3.m_itemData.GetMaxDurability();
					component3.Save();
					if (((Humanoid)localPlayer).m_inventory.CanAddItem(val, -1))
					{
						((Humanoid)localPlayer).m_inventory.AddItem(component3.m_itemData);
						ZNetScene.instance.Destroy(val);
					}
					return;
				}
				for (int i = 0; i < count; i++)
				{
					GameObject val2 = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					if (customData != null)
					{
						ZNetView component4 = val2.GetComponent<ZNetView>();
						if (component4 != null)
						{
							if (customData.Ints != null)
							{
								foreach (KeyValuePair<string, int> int2 in customData.Ints)
								{
									component4.m_zdo.Set(int2.Key, int2.Value);
								}
							}
							if (customData.Floats != null)
							{
								foreach (KeyValuePair<string, float> float2 in customData.Floats)
								{
									component4.m_zdo.Set(float2.Key, float2.Value);
								}
							}
							if (customData.Strings != null)
							{
								foreach (KeyValuePair<string, string> string2 in customData.Strings)
								{
									component4.m_zdo.Set(string2.Key, string2.Value);
								}
							}
							if (customData.Bools != null)
							{
								foreach (KeyValuePair<string, bool> bool2 in customData.Bools)
								{
									component4.m_zdo.Set(bool2.Key, bool2.Value);
								}
							}
						}
					}
					ItemDrop component5 = val2.GetComponent<ItemDrop>();
					component5.m_itemData.m_quality = level;
					component5.m_itemData.m_durability = component5.m_itemData.GetMaxDurability();
					component5.Save();
					if (((Humanoid)localPlayer).m_inventory.CanAddItem(val2, -1))
					{
						((Humanoid)localPlayer).m_inventory.AddItem(component5.m_itemData);
						ZNetScene.instance.Destroy(val2);
					}
				}
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)prefab.GetComponent<Character>()))
				{
					return;
				}
				for (int j = 0; j < count; j++)
				{
					GameObject val3 = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					val3.GetComponent<Character>().SetLevel(level);
					if (Object.op_Implicit((Object)(object)val3.GetComponent<Tameable>()))
					{
						val3.GetComponent<Tameable>().Tame();
					}
				}
			}
		}

		public static Market_NPC.NPCcomponent GetClosestNPC(Vector3 pos)
		{
			//IL_0020: 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)
			List<Market_NPC.NPCcomponent> aLL = Market_NPC.NPCcomponent.ALL;
			Market_NPC.NPCcomponent result = null;
			float num = 999999f;
			foreach (Market_NPC.NPCcomponent item in aLL)
			{
				float num2 = Vector3.Distance(pos, ((Component)item).transform.position);
				if (!(num2 >= num))
				{
					num = num2;
					result = item;
				}
			}
			return result;
		}

		public static Sprite TryFindIcon(string name, Sprite defaultSprite = null)
		{
			if (string.IsNullOrEmpty(name))
			{
				return defaultSprite;
			}
			if (AssetStorage.GlobalCachedSprites.TryGetValue(name, out Sprite value))
			{
				return value;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(name);
			if (prefab == null)
			{
				return defaultSprite;
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (component != null)
			{
				return component.m_itemData.GetIcon();
			}
			Piece component2 = prefab.GetComponent<Piece>();
			if (component2 != null)
			{
				return component2.m_icon;
			}
			return defaultSprite;
		}

		public static float GetPlayerSkillLevelCustom(string skillName)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!Enum.TryParse<SkillType>(skillName, out SkillType result))
			{
				SkillDef skillDef = Player.m_localPlayer.m_skills.GetSkillDef((SkillType)Mathf.Abs(StringExtensionMethods.GetStableHashCode(skillName)));
				if (skillDef == null)
				{
					return -1f;
				}
				result = skillDef.m_skill;
			}
			return Player.m_localPlayer.m_skills.GetSkillLevel(result);
		}

		public static void AddRange(this HashSet<int> hashSet, IEnumerable<int> collection)
		{
			foreach (int item in collection)
			{
				hashSet.Add(item);
			}
		}

		public static string ReplaceSpacesOutsideQuotes(this string input)
		{
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			foreach (char c in input)
			{
				if (c == '"')
				{
					flag = !flag;
				}
				else if (flag || c != ' ')
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		public static string LocalizeSkill(string name)
		{
			if (!Enum.TryParse<SkillType>(name, out SkillType _))
			{
				return Localization.instance.Localize("$skill_" + Mathf.Abs(StringExtensionMethods.GetStableHashCode(name)));
			}
			return Localization.instance.Localize("$skill_" + name.ToLower());
		}

		public static Sprite GetSkillIcon(string name)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!Enum.TryParse<SkillType>(name, out SkillType result))
			{
				SkillDef skillDef = Player.m_localPlayer.m_skills.GetSkillDef((SkillType)Mathf.Abs(StringExtensionMethods.GetStableHashCode(name)));
				if (skillDef != null)
				{
					return skillDef.m_icon;
				}
				return AssetStorage.NullSprite;
			}
			Skill skill = Player.m_localPlayer.m_skills.GetSkill(result);
			return skill.m_info.m_icon;
		}

		public static void LoadImageFromWEB(string url, Action<Sprite> callback, [CallerMemberName] string name = "Caller")
		{
			if (!string.IsNullOrWhiteSpace(url) && Uri.TryCreate(url, UriKind.Absolute, out Uri _))
			{
				if (!AssetStorage.GlobalCachedSprites.TryGetValue(url, out Sprite value))
				{
					((MonoBehaviour)Marketplace._thistype).StartCoroutine(_Internal_LoadImage(url, callback));
				}
				else
				{
					callback?.Invoke(value);
				}
			}
		}

		[IteratorStateMachine(typeof(<_Internal_LoadImage>d__43))]
		private static IEnumerator _Internal_LoadImage(string url, Action<Sprite> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <_Internal_LoadImage>d__43(0)
			{
				url = url,
				callback = callback
			};
		}

		public static string BigLettersToSpaces(this string str)
		{
			string text = "";
			for (int i = 0; i < str.Length; i++)
			{
				char c = str[i];
				if (char.IsUpper(c))
				{
					text += " ";
				}
				text += c;
			}
			return text;
		}

		public static void IncreaseSkillEXP(string name, float expToAdd)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			SkillType result;
			Skill val = (Enum.TryParse<SkillType>(name, out result) ? Player.m_localPlayer.m_skills.GetSkill(result) : Player.m_localPlayer.m_skills.GetSkill((SkillType)Mathf.Abs(StringExtensionMethods.GetStableHashCode(name))));
			if (val == null || val.m_info == null)
			{
				return;
			}
			while (expToAdd > 0f)
			{
				float nextLevelRequirement = val.GetNextLevelRequirement();
				if (val.m_accumulator + expToAdd >= nextLevelRequirement)
				{
					expToAdd -= nextLevelRequirement - val.m_accumulator;
					val.m_accumulator = 0f;
					val.m_level += 1f;
					val.m_level = Mathf.Clamp(val.m_level, 0f, 100f);
				}
				else
				{
					val.m_accumulator += expToAdd;
					expToAdd = 0f;
				}
			}
		}

		public static void SetGOColors(GameObject go, Color color)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			foreach (Renderer item in ((IEnumerable<Renderer>)(object)go.GetComponentsInChildren<MeshRenderer>()).Concat(go.GetComponentsInChildren<SkinnedMeshRenderer>().Cast<Renderer>()))
			{
				Material[] materials = item.materials;
				foreach (Material val in materials)
				{
					val.color = color;
				}
			}
		}

		public static void SetCustomValue(this Player p, string key, int value)
		{
			key = key.Replace("CUSTOMVALUE@", "");
			string key2 = "kgMarketplaceValue@" + key;
			p.m_customData[key2] = value.ToString();
		}

		public static void AddCustomValue(this Player p, string key, int value)
		{
			key = key.Replace("CUSTOMVALUE@", "");
			string key2 = "kgMarketplaceValue@" + key;
			if (p.m_customData.TryGetValue(key2, out var value2))
			{
				if (int.TryParse(value2, out var result))
				{
					p.m_customData[key2] = (result + value).ToString();
				}
				else
				{
					p.m_customData[key2] = value.ToString();
				}
			}
			else
			{
				p.m_customData[key2] = value.ToString();
			}
		}

		public static int GetCustomValue(this Player p, string key)
		{
			key = key.Replace("CUSTOMVALUE@", "");
			string key2 = "kgMarketplaceValue@" + key;
			if (p.m_customData.TryGetValue(key2, out var value) && int.TryParse(value, out var result))
			{
				return result;
			}
			return 0;
		}

		public static List<KeyValuePair<string, int>> GetAllCustomValues(this Player p)
		{
			List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>();
			foreach (KeyValuePair<string, string> customDatum in p.m_customData)
			{
				if (customDatum.Key.Contains("kgMarketplaceValue@"))
				{
					list.Add(new KeyValuePair<string, int>(customDatum.Key.Replace("kgMarketplaceValue@", ""), int.Parse(customDatum.Value)));
				}
			}
			return list;
		}

		public static void RemoveCustomValue(this Player p, string key)
		{
			key = key.Replace("CUSTOMVALUE@", "");
			string key2 = "kgMarketplaceValue@" + key;
			p.m_customData.Remove(key2);
		}

		public static bool HasFlagFast(this Quests_DataTypes.SpecialQuestTag value, Quests_DataTypes.SpecialQuestTag flag)
		{
			return (value & flag) != 0;
		}

		public static List<Trader_DataTypes.TraderItem> ToList(this Trader_DataTypes.TraderItem item)
		{
			return new List<Trader_DataTypes.TraderItem>(1) { item };
		}

		public static long MinutesToTicks(this int minutes)
		{
			return (long)(minutes * 60) * 10000000L;
		}

		public static bool HasFlagFast(this Buffer_DataTypes.WhatToModify flag, Buffer_DataTypes.WhatToModify other)
		{
			return (flag & other) != 0;
		}

		public static bool HasFlagFast(this TerritorySystem_DataTypes.AdditionalTerritoryFlags flag, TerritorySystem_DataTypes.AdditionalTerritoryFlags other)
		{
			return (flag & other) != 0;
		}

		public static bool HasFlagFast(this TerritorySystem_DataTypes.TerritoryFlags flag, TerritorySystem_DataTypes.TerritoryFlags other)
		{
			return (flag & other) != 0;
		}

		public static string RandomSplitSpace(this string s)
		{
			if (string.IsNullOrWhiteSpace(s))
			{
				return "";
			}
			string[] array = s.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0)
			{
				return "";
			}
			return array[Random.Range(0, array.Length)];
		}

		public static string ToTime(this int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			string text = "";
			if (timeSpan.Days > 0)
			{
				text += $"{timeSpan.Days:D2}d ";
			}
			if (timeSpan.Hours > 0)
			{
				text += $"{timeSpan.Hours:D2}h ";
			}
			if (timeSpan.Minutes > 0)
			{
				text += $"{timeSpan.Minutes:D2}m ";
			}
			return text + $"{timeSpan.Seconds:D2}s";
		}

		public static string ToTime(this long seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			string text = "";
			if (timeSpan.Days > 0)
			{
				text += $"{timeSpan.Days:D2}d ";
			}
			if (timeSpan.Hours > 0)
			{
				text += $"{timeSpan.Hours:D2}h ";
			}
			if (timeSpan.Minutes > 0)
			{
				text += $"{timeSpan.Minutes:D2}m ";
			}
			return text + $"{timeSpan.Seconds:D2}s";
		}

		public static string ToTimeNoS(this long seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			string text = "";
			if (timeSpan.Days > 0)
			{
				text += $"{timeSpan.Days:D2}d ";
			}
			if (timeSpan.Hours > 0)
			{
				text += $"{timeSpan.Hours:D2}h ";
			}
			if (timeSpan.Minutes > 0)
			{
				text += $"{timeSpan.Minutes:D2}m ";
			}
			return text;
		}

		public static string Localize(this string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				return Localization.instance.Localize(text);
			}
			return string.Empty;
		}

		public static bool StlocIndex(this object obj, int index)
		{
			if (obj is LocalBuilder localBuilder)
			{
				return localBuilder.LocalIndex == index;
			}
			return false;
		}
	}
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class VideoPlayerUI
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class fix1
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= IsVisible;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "IsVisible")]
		[ClientOnlyPatch]
		private static class fix2
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= IsVisible;
			}
		}

		private static GameObject UI;

		private static VideoPlayer Player;

		public static bool IsVisible
		{
			get
			{
				if (Object.op_Implicit((Object)(object)UI))
				{
					return UI.activeSelf;
				}
				return false;
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MVideoPlayerUI"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			Player = ((Component)UI.transform.Find("Canvas/MainTab/Video")).GetComponent<VideoPlayer>();
			UI.SetActive(false);
			Player.isLooping = false;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void Update(float dt)
		{
			if (IsVisible && Input.GetKeyDown((KeyCode)27))
			{
				Hide();
			}
		}

		public static void StartVideo(string name, float multiplier = 0.5f)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)Screen.width * multiplier;
			float num2 = (float)Screen.height * multiplier;
			Transform obj = UI.transform.Find("Canvas/MainTab");
			((RectTransform)((obj is RectTransform) ? obj : null)).sizeDelta = new Vector2(num, num2);
			Hide();
			if (AssetStorage.NPC_VideoClips.ContainsKey(name))
			{
				((Component)Player).gameObject.SetActive(true);
				UI.SetActive(true);
				Player.url = AssetStorage.NPC_VideoClips[name];
				Player.Play();
			}
		}

		private static void Hide()
		{
			Player.Stop();
			Player.frame = 0L;
			Player.url = null;
			((Component)Player).gameObject.SetActive(false);
			UI.SetActive(false);
		}
	}
}
namespace Marketplace.UI_OptimizationHandler
{
	public static class UI_Optimizations
	{
		public enum OptimizationType
		{
			Horizontal,
			Vertical
		}

		[CompilerGenerated]
		private sealed class <UI_OptimizationCoroutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OptimizationType type;

			public IEnumerable<GameObject> Objects;

			public int size;

			public Func<bool> isVisible;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (isVisible())
				{
					switch (type)
					{
					case OptimizationType.Horizontal:
					{
						int width = Screen.width;
						foreach (GameObject @object in Objects)
						{
							float x = @object.transform.position.x;
							if (x - (float)size > (float)width || x - (float)size < 0f)
							{
								@object.SetActive(false);
							}
							else
							{
								@object.SetActive(true);
							}
						}
						break;
					}
					case OptimizationType.Vertical:
					{
						int height = Screen.height;
						foreach (GameObject object2 in Objects)
						{
							float y = object2.transform.position.y;
							if (y - (float)size > (float)height || y - (float)size < 0f)
							{
								object2.SetActive(false);
							}
							else
							{
								object2.SetActive(true);
							}
						}
						break;
					}
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				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();
			}
		}

		[IteratorStateMachine(typeof(<UI_OptimizationCoroutine>d__1))]
		public static IEnumerator UI_OptimizationCoroutine(int size, Func<bool> isVisible, IEnumerable<GameObject> Objects, OptimizationType type)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UI_OptimizationCoroutine>d__1(0)
			{
				size = size,
				isVisible = isVisible,
				Objects = Objects,
				type = type
			};
		}
	}
	public static class ScrollView_Optimization
	{
		private static readonly Dictionary<GameObject, Coroutine> Callers = new Dictionary<GameObject, Coroutine>();

		public static void StartOptimization(GameObject caller, Func<bool> isVisible, IEnumerable<GameObject> Objects, UI_Optimizations.OptimizationType type)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (Callers.TryGetValue(caller, out Coroutine value))
			{
				((MonoBehaviour)Marketplace._thistype).StopCoroutine(value);
			}
			if (Objects.Any())
			{
				int size;
				if (type == UI_Optimizations.OptimizationType.Horizontal)
				{
					GameObject val = Objects.First();
					size = (int)(val.GetComponent<RectTransform>().sizeDelta.x * val.transform.lossyScale.x) / 2;
				}
				else
				{
					GameObject val2 = Objects.First();
					size = (int)(val2.GetComponent<RectTransform>().sizeDelta.y * val2.transform.lossyScale.y) / 2;
				}
				Callers[caller] = ((MonoBehaviour)Marketplace._thistype).StartCoroutine(UI_Optimizations.UI_OptimizationCoroutine(size, isVisible, Objects, type));
			}
		}
	}
}
namespace Marketplace.Stats
{
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public class CustomValuesShowup
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class TextInput_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(TextInput __instance, ref bool __result)
			{
				__result |= Show;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__OnGUI;

			public static Action<float> <1>__Updator;

			public static WindowFunction <2>__Window;

			public static WindowFunction <3>__Test;
		}

		public static bool Show;

		private static Rect _ui;

		private static GUIStyle style;

		private static Vector2 _scroll;

		public static void OnInit()
		{
			Marketplace.Global_OnGUI_Updator = (Action)Delegate.Combine(Marketplace.Global_OnGUI_Updator, new Action(OnGUI));
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Updator));
		}

		private static void Updator(float obj)
		{
			if (Show && Input.GetKeyDown((KeyCode)27))
			{
				Show = false;
				Menu instance = Menu.instance;
				if (instance != null)
				{
					instance.OnClose();
				}
			}
		}

		private static void OnGUI()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			if (Show)
			{
				if (style == null)
				{
					style = new GUIStyle(GUI.skin.label)
					{
						alignment = (TextAnchor)3
					};
				}
				float num = 4f;
				float num2 = (float)Screen.width / num / 2f;
				float num3 = (float)Screen.height / num / 2f;
				_ui = new Rect((float)Screen.width / 2f - num2, (float)Screen.height / 2f - num3, (float)Screen.width / num, (float)Screen.height / num);
				GUI.backgroundColor = Color.black;
				Rect ui = _ui;
				object obj = <>O.<2>__Window;
				if (obj == null)
				{
					WindowFunction val = Window;
					<>O.<2>__Window = val;
					obj = (object)val;
				}
				_ui = GUI.Window(1920577722, ui, (WindowFunction)obj, "Custom Values");
				Rect ui2 = _ui;
				object obj2 = <>O.<3>__Test;
				if (obj2 == null)
				{
					WindowFunction val2 = Test;
					<>O.<3>__Test = val2;
					obj2 = (object)val2;
				}
				GUI.Window(43501325, ui2, (WindowFunction)obj2, "");
				Rect ui3 = _ui;
				object obj3 = <>O.<3>__Test;
				if (obj3 == null)
				{
					WindowFunction val3 = Test;
					<>O.<3>__Test = val3;
					obj3 = (object)val3;
				}
				GUI.Window(43102238, ui3, (WindowFunction)obj3, "");
			}
		}

		private static void Test(int id)
		{
		}

		private static void Window(int id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			foreach (KeyValuePair<string, int> allCustomValue in Player.m_localPlayer.GetAllCustomValues())
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				Sprite val = Utils.TryFindIcon(allCustomValue.Key, AssetStorage.CustomValue_Icon);
				GUILayout.Label((Texture)(object)val.texture, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(60f),
					GUILayout.Height(60f)
				});
				GUILayout.Label(string.Format("{0}: {1}", allCustomValue.Key.Replace("_", " "), allCustomValue.Value), style, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(60f) });
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}
	}
}
namespace Marketplace.Paths
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Both, Market_Autoload.Priority.Init, "OnInit", null, null)]
	public static class Market_Paths
	{
		public static string MainPath => Path.Combine(Paths.ConfigPath, "Marketplace");

		public static string NPC_SoundsPath => Path.Combine(Paths.ConfigPath, "Marketplace_Sounds");

		public static string NPC_Saved => Path.Combine(Paths.ConfigPath, "Marketplace_SavedNPCs");

		public static string CachedImagesFolder => Path.Combine(Paths.ConfigPath, "Marketplace_CachedImages");

		public static string VideoClipsFolder => Path.Combine(Paths.ConfigPath, "Marketplace_VideoClips");

		public static string DiscordStuffFolder => Path.Combine(MainPath, "DiscordWebhooks");

		private static string DataFolder => Path.Combine(MainPath, "SavedData");

		public static string DBFile => Path.Combine(MainPath, "SavedData", "DB.db");

		public static string LoggerPath => Path.Combine(MainPath, "Logger.log");

		private static string DistancedUIFolder => Path.Combine(MainPath, "DistancedUI");

		public static string DistancedUIConfig => Path.Combine(DistancedUIFolder, "DistancedUI.cfg");

		public static string MainConfig => Path.Combine(MainPath, "MarketPlace.cfg");

		private static string ConfigsFolder => Path.Combine(MainPath, "Configs");

		public static string QuestsDatabaseFolder => Path.Combine(ConfigsFolder, "Quests");

		public static string DialoguesFolder => Path.Combine(ConfigsFolder, "Dialogues");

		public static string TerritoriesFolder => Path.Combine(ConfigsFolder, "Territories");

		public static string QuestsProfilesFolder => Path.Combine(ConfigsFolder, "QuestProfiles");

		public static string QuestsEventsFolder => Path.Combine(ConfigsFolder, "QuestEvents");

		public static string BankerProfilesFolder => Path.Combine(ConfigsFolder, "Bankers");

		public static string TeleportHubProfilesFolder => Path.Combine(ConfigsFolder, "Teleporters");

		public static string TraderProfilesFolder => Path.Combine(ConfigsFolder, "Traders");

		public static string ServerInfoProfilesFolder => Path.Combine(ConfigsFolder, "ServerInfos");

		public static string GamblerProfilesFolder => Path.Combine(ConfigsFolder, "Gamblers");

		public static string BufferDatabaseFolder => Path.Combine(ConfigsFolder, "Buffers");

		public static string BufferProfilesFolder => Path.Combine(ConfigsFolder, "BufferProfiles");

		public static string TransmogrificationFolder => Path.Combine(ConfigsFolder, "Transmogrifications");

		public static string LootboxesFolder => Path.Combine(ConfigsFolder, "Lootboxes");

		public static string LeaderboardAchievementsFolder => Path.Combine(ConfigsFolder, "LeaderboardAchievements");

		public static string AdditionalTerritoriesFolder => Path.Combine(ConfigsFolder, "AdditionalTerritories");

		public static string DialoguesCustomSpawnDataFolder => Path.Combine(ConfigsFolder, "CustomSpawnData");

		public static string FactionsFile => Path.Combine(ConfigsFolder, "Factions.yml");

		private static string PlayerTagsFolder => Path.Combine(MainPath, "PlayerTags");

		public static string PlayerTagsConfig => Path.Combine(PlayerTagsFolder, "PlayerTags.cfg");

		[UsedImplicitly]
		private static void OnInit()
		{
			Marketplace.WorkingAs workingAsType = Marketplace.WorkingAsType;
			if ((uint)(workingAsType - 1) <= 1u)
			{
				if (!Directory.Exists(MainPath))
				{
					Directory.CreateDirectory(MainPath);
				}
				if (!Directory.Exists(DataFolder))
				{
					Directory.CreateDirectory(DataFolder);
				}
				if (!Directory.Exists(DiscordStuffFolder))
				{
					Directory.CreateDirectory(DiscordStuffFolder);
				}
				if (!Directory.Exists(DistancedUIFolder))
				{
					Directory.CreateDirectory(DistancedUIFolder);
				}
				if (!Directory.Exists(PlayerTagsFolder))
				{
					Directory.CreateDirectory(PlayerTagsFolder);
				}
				if (!Directory.Exists(ConfigsFolder))
				{
					Directory.CreateDirectory(ConfigsFolder);
				}
				if (!Directory.Exists(QuestsDatabaseFolder))
				{
					Directory.CreateDirectory(QuestsDatabaseFolder);
				}
				if (!Directory.Exists(DialoguesFolder))
				{
					Directory.CreateDirectory(DialoguesFolder);
				}
				if (!Directory.Exists(TerritoriesFolder))
				{
					Directory.CreateDirectory(TerritoriesFolder);
				}
				if (!Directory.Exists(QuestsProfilesFolder))
				{
					Directory.CreateDirectory(QuestsProfilesFolder);
				}
				if (!Directory.Exists(QuestsEventsFolder))
				{
					Directory.CreateDirectory(QuestsEventsFolder);
				}
				if (!Directory.Exists(BankerProfilesFolder))
				{
					Directory.CreateDirectory(BankerProfilesFolder);
				}
				if (!Directory.Exists(TeleportHubProfilesFolder))
				{
					Directory.CreateDirectory(TeleportHubProfilesFolder);
				}
				if (!Directory.Exists(TraderProfilesFolder))
				{
					Directory.CreateDirectory(TraderProfilesFolder);
				}
				if (!Directory.Exists(ServerInfoProfilesFolder))
				{
					Directory.CreateDirectory(ServerInfoProfilesFolder);
				}
				if (!Directory.Exists(DialoguesCustomSpawnDataFolder))
				{
					Directory.CreateDirectory(DialoguesCustomSpawnDataFolder);
				}
				if (!Directory.Exists(GamblerProfilesFolder))
				{
					Directory.CreateDirectory(GamblerProfilesFolder);
				}
				if (!Directory.Exists(BufferDatabaseFolder))
				{
					Directory.CreateDirectory(BufferDatabaseFolder);
				}
				if (!Directory.Exists(BufferProfilesFolder))
				{
					Directory.CreateDirectory(BufferProfilesFolder);
				}
				if (!Directory.Exists(TransmogrificationFolder))
				{
					Directory.CreateDirectory(TransmogrificationFolder);
				}
				if (!Directory.Exists(LeaderboardAchievementsFolder))
				{
					Directory.CreateDirectory(LeaderboardAchievementsFolder);
				}
				if (!Directory.Exists(LootboxesFolder))
				{
					Directory.CreateDirectory(LootboxesFolder);
				}
				if (!Directory.Exists(AdditionalTerritoriesFolder))
				{
					Directory.CreateDirectory(AdditionalTerritoriesFolder);
				}
				if (!File.Exists(PlayerTagsConfig))
				{
					File.Create(PlayerTagsConfig).Dispose();
				}
				if (!File.Exists(FactionsFile))
				{
					File.Create(FactionsFile).Dispose();
				}
			}
			workingAsType = Marketplace.WorkingAsType;
			if ((workingAsType == Marketplace.WorkingAs.Client || workingAsType == Marketplace.WorkingAs.Both) ? true : false)
			{
				if (!Directory.Exists(NPC_SoundsPath))
				{
					Directory.CreateDirectory(NPC_SoundsPath);
				}
				if (!Directory.Exists(CachedImagesFolder))
				{
					Directory.CreateDirectory(CachedImagesFolder);
				}
				if (!Directory.Exists(NPC_Saved))
				{
					Directory.CreateDirectory(NPC_Saved);
				}
				if (!Directory.Exists(VideoClipsFolder))
				{
					Directory.CreateDirectory(VideoClipsFolder);
				}
			}
		}
	}
}
namespace Marketplace.OtherModsAPIs
{
	internal static class Cozyheim_LevelingSystem
	{
		private static readonly bool _isInstalled;

		private static readonly FieldInfo FI_UIManagerInstance;

		private static readonly FieldInfo FI_Level;

		private static readonly MethodInfo MI_AddEXP;

		public static int GetLevel()
		{
			if (_isInstalled)
			{
				object value = FI_UIManagerInstance.GetValue(null);
				if (value != null)
				{
					return (int)FI_Level.GetValue(value);
				}
			}
			return 0;
		}

		public static void AddExp(int amount)
		{
			if (_isInstalled)
			{
				object value = FI_UIManagerInstance.GetValue(null);
				if (value != null)
				{
					MI_AddEXP.Invoke(value, new object[2] { amount, 0 });
				}
			}
		}

		static Cozyheim_LevelingSystem()
		{
			Type type = Type.GetType("Cozyheim.LevelingSystem.UIManager, Cozyheim_LevelingSystem");
			if ((object)type == null)
			{
				_isInstalled = false;
				return;
			}
			_isInstalled = true;
			FI_UIManagerInstance = AccessTools.Field(type, "Instance");
			FI_Level = AccessTools.Field(type, "playerLevel");
			MI_AddEXP = AccessTools.Method(type, "AddExperience", (Type[])null, (Type[])null);
		}
	}
	internal static class EpicMMOSystem_API
	{
		private enum MO_API_State
		{
			NotReady,
			NotInstalled,
			Ready
		}

		private static MO_API_State state;

		private static MethodInfo eGetLevel;

		private static MethodInfo eAddExp;

		public static int GetLevel()
		{
			int result = 0;
			Init();
			if (eGetLevel != null)
			{
				result = (int)eGetLevel.Invoke(null, null);
			}
			return result;
		}

		public static void AddExp(int value)
		{
			Init();
			eAddExp?.Invoke(null, new object[1] { value });
		}

		private static void Init()
		{
			MO_API_State mO_API_State = state;
			if ((uint)(mO_API_State - 1) > 1u)
			{
				if (Type.GetType("EpicMMOSystem.EpicMMOSystem, EpicMMOSystem") == null)
				{
					state = MO_API_State.NotInstalled;
					return;
				}
				state = MO_API_State.Ready;
				Type type = Type.GetType("API.EMMOS_API, EpicMMOSystem");
				eGetLevel = type.GetMethod("GetLevel", BindingFlags.Static | BindingFlags.Public);
				eAddExp = type.GetMethod("AddExp", BindingFlags.Static | BindingFlags.Public);
			}
		}
	}
	public static class RustyClassesAPI
	{
		private static readonly MethodInfo? API_AddExperience;

		private static readonly MethodInfo? API_GetLevel;

		private static readonly MethodInfo? API_GetCharacteristic;

		public static void AddEXP(int amount)
		{
			API_AddExperience?.Invoke(null, new object[1] { amount });
		}

		public static int GetLevel()
		{
			return (int)(API_GetLevel?.Invoke(null, null) ?? ((object)0));
		}

		public static int GetCharacteristic(string type)
		{
			return (int)(API_GetCharacteristic?.Invoke(null, new object[1] { type }) ?? ((object)0));
		}

		public static int GetConstitution()
		{
			return GetCharacteristic("Constitution");
		}

		public static int GetDexterity()
		{
			return GetCharacteristic("Dexterity");
		}

		public static int GetStrength()
		{
			return GetCharacteristic("Strength");
		}

		public static int GetIntelligence()
		{
			return GetCharacteristic("Intelligence");
		}

		public static int GetWisdom()
		{
			return GetCharacteristic("Wisdom");
		}

		static RustyClassesAPI()
		{
			Type type = Type.GetType("AlmanacClasses.API.API, AlmanacClasses");
			if ((object)type != null)
			{
				API_AddExperience = type.GetMethod("AddExperience", BindingFlags.Static | BindingFlags.Public);
				API_GetLevel = type.GetMethod("GetLevel", BindingFlags.Static | BindingFlags.Public);
				API_GetCharacteristic = type.GetMethod("GetCharacteristic", BindingFlags.Static | BindingFlags.Public);
			}
		}
	}
}
namespace Marketplace.Modules.Trader
{
	public static class Trader_DataTypes
	{
		public class TraderData : ISerializableParameter
		{
			public bool NeedToKnow;

			public List<TraderItem> NeededItems;

			public List<TraderItem> ResultItems;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(NeedToKnow);
				pkg.Write(NeededItems.Count);
				foreach (TraderItem neededItem in NeededItems)
				{
					pkg.Write(neededItem.ItemPrefab ?? "");
					pkg.Write(neededItem.Count);
					pkg.Write(neededItem.Level);
				}
				pkg.Write(ResultItems.Count);
				foreach (TraderItem resultItem in ResultItems)
				{
					pkg.Write(resultItem.ItemPrefab ?? "");
					pkg.Write(resultItem.Count);
					pkg.Write(resultItem.Level);
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				NeedToKnow = pkg.ReadBool();
				int num = pkg.ReadInt();
				NeededItems = new List<TraderItem>();
				for (int i = 0; i < num; i++)
				{
					TraderItem item = new TraderItem
					{
						ItemPrefab = pkg.ReadString(),
						Count = pkg.ReadInt(),
						Level = pkg.ReadInt()
					};
					NeededItems.Add(item);
				}
				num = pkg.ReadInt();
				ResultItems = new List<TraderItem>();
				for (int j = 0; j < num; j++)
				{
					TraderItem item2 = new TraderItem
					{
						ItemPrefab = pkg.ReadString(),
						Count = pkg.ReadInt(),
						Level = pkg.ReadInt()
					};
					ResultItems.Add(item2);
				}
			}
		}

		public class TraderItem
		{
			public enum TraderItemType
			{
				Item,
				Skill,
				Monster
			}

			public int Count;

			public string ItemName;

			public string OriginalItemName;

			public string ItemPrefab;

			public int Level = 1;

			public bool DisplayStars;

			public TraderItemType Type;

			private Sprite Icon;

			public Sprite GetIcon()
			{
				return Icon;
			}

			public void SetIcon(Sprite icon)
			{
				Icon = icon;
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, List<TraderData>>> SyncedTraderItemList = new CustomSyncedValue<Dictionary<string, List<TraderData>>>(Marketplace.configSync, "traderItemList", new Dictionary<string, List<TraderData>>());

		internal static readonly Dictionary<string, List<TraderData>> ClientSideItemList = new Dictionary<string, List<TraderData>>();
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Trader_Main_Client
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		[HarmonyPriority(-10000)]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				InitTraderItems();
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			Trader_UI.Init();
			Trader_DataTypes.SyncedTraderItemList.ValueChanged += OnTraderUpdate;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Trader_UI.IsPanelVisible())
			{
				Trader_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		private static void OnTraderUpdate()
		{
			InitTraderItems();
			Trader_UI.Reload();
		}

		public static void InitTraderItems()
		{
			Trader_DataTypes.ClientSideItemList.Clear();
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			foreach (KeyValuePair<string, List<Trader_DataTypes.TraderData>> item in Trader_DataTypes.SyncedTraderItemList.Value)
			{
				List<Trader_DataTypes.TraderData> list = new List<Trader_DataTypes.TraderData>();
				foreach (Trader_DataTypes.TraderData item2 in item.Value)
				{
					List<Trader_DataTypes.TraderItem> list2 = new List<Trader_DataTypes.TraderItem>();
					List<Trader_DataTypes.TraderItem> list3 = new List<Trader_DataTypes.TraderItem>();
					foreach (Trader_DataTypes.TraderItem neededItem in item2.NeededItems)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab(neededItem.ItemPrefab);
						if (Object.op_Implicit((Object)(object)prefab))
						{
							ItemData itemData = prefab.GetComponent<ItemDrop>().m_itemData;
							neededItem.Type = Trader_DataTypes.TraderItem.TraderItemType.Item;
							neededItem.DisplayStars = itemData.m_shared.m_maxQuality > 1;
							neededItem.SetIcon(itemData.GetIcon());
							neededItem.OriginalItemName = itemData.m_shared.m_name;
							neededItem.ItemName = Localization.instance.Localize(neededItem.OriginalItemName);
							list2.Add(neededItem);
						}
					}
					foreach (Trader_DataTypes.TraderItem resultItem in item2.ResultItems)
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab(resultItem.ItemPrefab);
						if (!Object.op_Implicit((Object)(object)prefab2))
						{
							resultItem.SetIcon(AssetStorage.NullSprite);
							resultItem.ItemName = Utils.LocalizeSkill(resultItem.ItemPrefab) + " EXP";
							resultItem.Type = Trader_DataTypes.TraderItem.TraderItemType.Skill;
							resultItem.DisplayStars = false;
							list3.Add(resultItem);
							continue;
						}
						if (Object.op_Implicit((Object)(object)prefab2.GetComponent<ItemDrop>()))
						{
							ItemData itemData2 = prefab2.GetComponent<ItemDrop>().m_itemData;
							resultItem.DisplayStars = itemData2.m_shared.m_maxQuality > 1;
							resultItem.SetIcon(itemData2.GetIcon());
							resultItem.OriginalItemName = itemData2.m_shared.m_name;
							resultItem.ItemName = Localization.instance.Localize(resultItem.OriginalItemName);
							resultItem.Type = Trader_DataTypes.TraderItem.TraderItemType.Item;
						}
						else if (Object.op_Implicit((Object)(object)prefab2.GetComponent<Character>()))
						{
							Character component = prefab2.GetComponent<Character>();
							PhotoManager.__instance.MakeSprite(prefab2, resultItem.Level);
							resultItem.SetIcon(PhotoManager.__instance.GetSprite(((Object)prefab2).name, AssetStorage.PlaceholderMonsterIcon, resultItem.Level));
							resultItem.ItemName = Localization.instance.Localize(component.m_name ?? "Default");
							resultItem.Type = Trader_DataTypes.TraderItem.TraderItemType.Monster;
							resultItem.DisplayStars = true;
						}
						list3.Add(resultItem);
					}
					if (list2.Count > 0 && list3.Count > 0)
					{
						list.Add(new Trader_DataTypes.TraderData
						{
							NeedToKnow = item2.NeedToKnow,
							NeededItems = list2,
							ResultItems = list3
						});
					}
				}
				Trader_DataTypes.ClientSideItemList[item.Key] = list;
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "TR" }, new string[] { "OnTraderProfilesFileChange" })]
	public static class Trader_Main_Server
	{
		private static void OnInit()
		{
			ReadServerTraderProfiles();
		}

		private static void OnTraderProfilesFileChange()
		{
			ReadServerTraderProfiles();
			Utils.print("Trader Changed. Sending new info to all clients");
		}

		private static void ProcessTraderProfiles(string fPath, IReadOnlyList<string> profiles)
		{
			string text = "default";
			bool needToKnow = false;
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					text = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					string[] array = text.Split(new char[1] { '=' });
					if (array.Length == 2)
					{
						text = array[0];
						needToKnow = Convert.ToBoolean(array[1]);
					}
					else
					{
						needToKnow = false;
					}
					continue;
				}
				try
				{
					if (!Enumerable.Contains(profiles[i], '='))
					{
						string[] array2 = profiles[i].Replace(" ", "").Split(new char[1] { ',' });
						if (array2.Length == 5)
						{
							Trader_DataTypes.TraderData item = new Trader_DataTypes.TraderData
							{
								NeedToKnow = needToKnow,
								NeededItems = new Trader_DataTypes.TraderItem
								{
									ItemPrefab = array2[0],
									Count = int.Parse(array2[1])
								}.ToList(),
								ResultItems = new Trader_DataTypes.TraderItem
								{
									ItemPrefab = array2[2],
									Count = int.Parse(array2[3]),
									Level = int.Parse(array2[4])
								}.ToList()
							};
							if (Trader_DataTypes.SyncedTraderItemList.Value.TryGetValue(text, out List<Trader_DataTypes.TraderData> value))
							{
								value.Add(item);
							}
							else
							{
								Trader_DataTypes.SyncedTraderItemList.Value[text] = new List<Trader_DataTypes.TraderData>(1) { item };
							}
						}
						if (array2.Length == 4)
						{
							Trader_DataTypes.TraderData item2 = new Trader_DataTypes.TraderData
							{
								NeedToKnow = needToKnow,
								NeededItems = new List<Trader_DataTypes.TraderItem>(1)
								{
									new Trader_DataTypes.TraderItem
									{
										ItemPrefab = array2[0],
										Count = int.Parse(array2[1])
									}
								},
								ResultItems = new List<Trader_DataTypes.TraderItem>(1)
								{
									new Trader_DataTypes.TraderItem
									{
										ItemPrefab = array2[2],
										Count = int.Parse(array2[3])
									}
								}
							};
							if (Trader_DataTypes.SyncedTraderItemList.Value.TryGetValue(text, out List<Trader_DataTypes.TraderData> value2))
							{
								value2.Add(item2);
								continue;
							}
							Trader_DataTypes.SyncedTraderItemList.Value[text] = new List<Trader_DataTypes.TraderData>(1) { item2 };
						}
						continue;
					}
					string[] array3 = profiles[i].Replace(" ", "").Split(new char[1] { '=' });
					if (array3.Length == 2)
					{
						Trader_DataTypes.TraderData traderData = new Trader_DataTypes.TraderData
						{
							NeedToKnow = needToKnow,
							NeededItems = new List<Trader_DataTypes.TraderItem>(),
							ResultItems = new List<Trader_DataTypes.TraderItem>()
						};
						string[] data2 = array3[0].Split(new char[1] { ',' });
						string[] data3 = array3[1].Split(new char[1] { ',' });
						FillTrader(traderData.NeededItems, data2);
						FillTrader(traderData.ResultItems, data3);
						if (Trader_DataTypes.SyncedTraderItemList.Value.TryGetValue(text, out List<Trader_DataTypes.TraderData> value3))
						{
							value3.Add(traderData);
							continue;
						}
						Trader_DataTypes.SyncedTraderItemList.Value[text] = new List<Trader_DataTypes.TraderData>(1) { traderData };
					}
				}
				catch (Exception arg)
				{
					Utils.print($"{arg}\nERROR: Can't add items in {fPath}, line: {i + 1}", ConsoleColor.Red);
					break;
				}
			}
			static void FillTrader(ICollection<Trader_DataTypes.TraderItem> list, IReadOnlyList<string> data)
			{
				int num = 0;
				while (num < data.Count)
				{
					Trader_DataTypes.TraderItem traderItem = new Trader_DataTypes.TraderItem
					{
						ItemPrefab = data[num],
						Count = int.Parse(data[num + 1])
					};
					if (num + 2 < data.Count && int.TryParse(data[num + 2], out var result))
					{
						traderItem.Level = result;
						num += 3;
					}
					else
					{
						num += 2;
					}
					if (list.Count < 5)
					{
						list.Add(traderItem);
					}
				}
			}
		}

		private static void ReadServerTraderProfiles()
		{
			Trader_DataTypes.SyncedTraderItemList.Value.Clear();
			string traderProfilesFolder = Market_Paths.TraderProfilesFolder;
			string[] files = Directory.GetFiles(traderProfilesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ProcessTraderProfiles(text, profiles);
			}
			Trader_DataTypes.SyncedTraderItemList.Update();
		}
	}
	public static class Trader_UI
	{
		private enum Modifier
		{
			x1,
			x5,
			x10,
			x100
		}

		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		[ClientOnlyPatch]
		private static class InventoryGui_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGui __instance)
			{
				UITooltip[] componentsInChildren = BuyElement.GetComponentsInChildren<UITooltip>(true);
				foreach (UITooltip val in componentsInChildren)
				{
					val.m_tooltipPrefab = __instance.m_playerGrid.m_elementPrefab.GetComponent<UITooltip>().m_tooltipPrefab;
				}
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class TraderUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsPanelVisible())
				{
					__result = true;
				}
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__20_0;

			public static UnityAction <>9__20_1;

			public static Func<Trader_DataTypes.TraderItem, bool> <>9__28_5;

			public static Func<Trader_DataTypes.TraderItem, bool> <>9__28_6;

			public static Func<Trader_DataTypes.TraderItem, bool> <>9__28_2;

			public static Func<Trader_DataTypes.TraderItem, bool> <>9__28_3;

			public static Action<ContentSizeFitter> <>9__28_0;

			public static Action<ContentSizeFitter> <>9__28_1;

			internal void <Init>b__20_0()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				AssetStorage.AUsrc.Play();
				ToBank = !ToBank;
				((Graphic)((Component)UI.transform.Find("Canvas/Background/ToBank/Image/img")).GetComponent<Image>()).color = (ToBank ? Enabled : Disabled);
				ResetBankText();
				Reload();
			}

			internal void <Init>b__20_1()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				AssetStorage.AUsrc.Play();
				FromBank = !FromBank;
				((Graphic)((Component)UI.transform.Find("Canvas/Background/FromBank/Image/img")).GetComponent<Image>()).color = (FromBank ? Enabled : Disabled);
				ResetBankText();
				Reload();
			}

			internal bool <CreateElementsNew>b__28_5(Trader_DataTypes.TraderItem item)
			{
				if (item.Type == Trader_DataTypes.TraderItem.TraderItemType.Item)
				{
					return !Player.m_localPlayer.m_knownMaterial.Contains(item.OriginalItemName);
				}
				return false;
			}

			internal bool <CreateElementsNew>b__28_6(Trader_DataTypes.TraderItem item)
			{
				if (item.Type == Trader_DataTypes.TraderItem.TraderItemType.Item)
				{
					return !Player.m_localPlayer.m_knownMaterial.Contains(item.OriginalItemName);
				}
				return false;
			}

			internal bool <CreateElementsNew>b__28_2(Trader_DataTypes.TraderItem x)
			{
				return !CanAddToBanker(x);
			}

			internal bool <CreateElementsNew>b__28_3(Trader_DataTypes.TraderItem x)
			{
				return !CanAddToBanker(x);
			}

			internal void <CreateElementsNew>b__28_0(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			}

			internal void <CreateElementsNew>b__28_1(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			}
		}

		private static GameObject UI;

		private static GameObject BuyElement;

		private static Transform ContentTransform;

		private static readonly Color Enabled = new Color(0.5361788f, 1f, 0.1176471f, 35f / 51f);

		private static readonly Color Disabled = new Color(1f, 0.1766787f, 0.1176471f, 35f / 51f);

		private static readonly List<GameObject> CurrentObjects = new List<GameObject>();

		private static string CurrentProfile = "";

		private static readonly List<ContentSizeFitter> AllFilters = new List<ContentSizeFitter>();

		private static Scrollbar ScrollbarMain;

		private static Text NPCname;

		private static List<Trader_DataTypes.TraderData> SortedList;

		private static InputField SearchInput;

		private static Modifier CurrentModifier;

		private static readonly Transform[] ModifierButtons = (Transform[])(object)new Transform[Enum.GetValues(typeof(Modifier)).Length];

		private static bool ToBank;

		private static bool FromBank;

		private static Text FromBankText;

		private static readonly Dictionary<Modifier, int> ModifierValues = new Dictionary<Modifier, int>
		{
			{
				Modifier.x1,
				1
			},
			{
				Modifier.x5,
				5
			},
			{
				Modifier.x10,
				10
			},
			{
				Modifier.x100,
				100
			}
		};

		private static int LastPaidBankHashcode = 0;

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_01d7: 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_01e2: Expected O, but got Unknown
			//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_0224: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceTraderNewUI"));
			BuyElement = AssetStorage.asset.LoadAsset<GameObject>("TraderInstantiateV3");
			ContentTransform = UI.transform.Find("Canvas/Scroll View/Viewport/Content");
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.SetActive(false);
			AllFilters.AddRange(UI.GetComponentsInChildren<ContentSizeFitter>().ToList());
			ScrollbarMain = UI.GetComponentInChildren<Scrollbar>();
			NPCname = ((Component)UI.transform.Find("Canvas/Header/Text")).GetComponent<Text>();
			SearchInput = UI.GetComponentInChildren<InputField>();
			((UnityEvent<string>)(object)SearchInput.onValueChanged).AddListener((UnityAction<string>)OnSearchInput);
			FromBankText = ((Component)UI.transform.Find("Canvas/Background/ToFromText")).GetComponent<Text>();
			ModifierButtons[0] = UI.transform.Find("Canvas/Background/x1");
			ModifierButtons[1] = UI.transform.Find("Canvas/Background/x5");
			ModifierButtons[2] = UI.transform.Find("Canvas/Background/x10");
			ModifierButtons[3] = UI.transform.Find("Canvas/Background/x100");
			for (int j = 0; j < ModifierButtons.Length; j++)
			{
				int i1 = j;
				((UnityEvent)((Component)ModifierButtons[j]).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					AssetStorage.AUsrc.Play();
					SetModifier((Modifier)i1);
					CreateElementsNew();
				});
			}
			ButtonClickedEvent onClick = ((Component)UI.transform.Find("Canvas/Background/ToBank")).GetComponent<Button>().onClick;
			object obj = <>c.<>9__20_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					AssetStorage.AUsrc.Play();
					ToBank = !ToBank;
					((Graphic)((Component)UI.transform.Find("Canvas/Background/ToBank/Image/img")).GetComponent<Image>()).color = (ToBank ? Enabled : Disabled);
					ResetBankText();
					Reload();
				};
				<>c.<>9__20_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("Canvas/Background/FromBank")).GetComponent<Button>().onClick;
			object obj2 = <>c.<>9__20_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					AssetStorage.AUsrc.Play();
					FromBank = !FromBank;
					((Graphic)((Component)UI.transform.Find("Canvas/Background/FromBank/Image/img")).GetComponent<Image>()).color = (FromBank ? Enabled : Disabled);
					ResetBankText();
					Reload();
				};
				<>c.<>9__20_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			Localization.instance.Localize(UI.transform);
		}

		private static void SetModifier(Modifier modifier)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			CurrentModifier = modifier;
			for (int i = 0; i < ModifierButtons.Length; i++)
			{
				((Graphic)((Component)((Component)ModifierButtons[i]).transform.Find("Image")).GetComponent<Image>()).color = ((i == (int)modifier) ? Color.green : Color.white);
				((Graphic)((Component)((Component)ModifierButtons[i]).transform.Find("Text")).GetComponent<Text>()).color = ((i == (int)modifier) ? Color.green : Color.white);
			}
		}

		private static void OnSearchInput(string arg0)
		{
			AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
			SortList();
			CreateElementsNew();
		}

		private static void SortList()
		{
			if (!Trader_DataTypes.ClientSideItemList.ContainsKey(CurrentProfile))
			{
				return;
			}
			string search = SearchInput.text.ToLower();
			if (string.IsNullOrWhiteSpace(search))
			{
				SortedList = Trader_DataTypes.ClientSideItemList[CurrentProfile];
				return;
			}
			SortedList = Trader_DataTypes.ClientSideItemList[CurrentProfile].Where((Trader_DataTypes.TraderData data) => data.NeededItems.Any((Trader_DataTypes.TraderItem i) => i.ItemName.ToLower().Contains(search)) || data.ResultItems.Any((Trader_DataTypes.TraderItem i) => i.ItemName.ToLower().Contains(search))).ToList();
		}

		private static float CalculateOffset(int amount)
		{
			return Mathf.Max(0f, (float)(amount - 1) * 34.5f);
		}

		private static void FillUITooltip(Transform transform, Trader_DataTypes.TraderItem data)
		{
			((Component)transform).GetComponent<UITooltip>().m_topic = data.ItemName;
			if (data.Type == Trader_DataTypes.TraderItem.TraderItemType.Monster)
			{
				((Component)transform).GetComponent<UITooltip>().m_text = Localization.instance.Localize("$mpasn_tooltip_pet");
			}
			else if (data.Type == Trader_DataTypes.TraderItem.TraderItemType.Skill)
			{
				((Component)transform).GetComponent<UITooltip>().m_text = Localization.instance.Localize("$mpasn_Skill_EXP");
			}
			else
			{
				((Component)transform).GetComponent<UITooltip>().m_text = ItemData.GetTooltip(ZNetScene.instance.GetPrefab(data.ItemPrefab).GetComponent<ItemDrop>().m_itemData, data.Level, false, (float)Game.m_worldLevel, -1);
			}
		}

		private static void CreateElementsNew()
		{
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: 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_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_0640: Expected O, but got Unknown
			//IL_0647: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_068e: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			CurrentObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentObjects.Clear();
			float num = 0f;
			foreach (Trader_DataTypes.TraderData data in SortedList)
			{
				if ((!data.NeedToKnow || (!data.NeededItems.Any((Trader_DataTypes.TraderItem item) => item.Type == Trader_DataTypes.TraderItem.TraderItemType.Item && !Player.m_localPlayer.m_knownMaterial.Contains(item.OriginalItemName)) && !data.ResultItems.Any((Trader_DataTypes.TraderItem item) => item.Type == Trader_DataTypes.TraderItem.TraderItemType.Item && !Player.m_localPlayer.m_knownMaterial.Contains(item.OriginalItemName)))) && (!FromBank || !data.NeededItems.Any((Trader_DataTypes.TraderItem x) => !CanAddToBanker(x))) && (!ToBank || !data.ResultItems.Any((Trader_DataTypes.TraderItem x) => !CanAddToBanker(x))))
				{
					GameObject val = Object.Instantiate<GameObject>(BuyElement, ContentTransform);
					int num2 = ((data.NeededItems.Count > data.ResultItems.Count) ? data.NeededItems.Count : data.ResultItems.Count);
					int num3 = 0;
					for (int i = 0; i < data.NeededItems.Count; i++)
					{
						Transform val2 = ((i == 0) ? val.transform.Find("Background/NeededItems/NeededItem") : Object.Instantiate<Transform>(val.transform.Find("Background/NeededItems/NeededItem"), val.transform.Find("Background/NeededItems")));
						RectTransform component = ((Component)val2).GetComponent<RectTransform>();
						component.anchoredPosition -= new Vector2(0f, (float)num3);
						num3 += 69;
						int level = data.NeededItems[i].Level;
						string arg = (data.NeededItems[i].DisplayStars ? $" <color=#00ff00>({level}★)</color>" : "");
						((Component)((Component)val2).transform.Find("Text")).GetComponent<Text>().text = (FromBank ? "<color=cyan>[BANK]</color> " : "") + $"{data.NeededItems[i].ItemName}{arg}\n<color=yellow>x{data.NeededItems[i].Count * ModifierValues[CurrentModifier]}</color>";
						((Component)((Component)val2).transform.Find("Icon")).GetComponent<Image>().sprite = data.NeededItems[i].GetIcon();
						FillUITooltip(val2, data.NeededItems[i]);
						((Shadow)((Component)val2).GetComponent<Outline>()).effectColor = (HasEnough(data.NeededItems[i]) ? Color.green : Color.red);
					}
					RectTransform component2 = ((Component)val.transform.Find("Background/NeededItems")).GetComponent<RectTransform>();
					component2.anchoredPosition += new Vector2(0f, CalculateOffset(data.NeededItems.Count));
					num3 = 0;
					for (int j = 0; j < data.ResultItems.Count; j++)
					{
						Transform val3 = ((j == 0) ? val.transform.Find("Background/ResultItems/ResultItem") : Object.Instantiate<Transform>(val.transform.Find("Background/ResultItems/ResultItem"), val.transform.Find("Background/ResultItems")));
						RectTransform component3 = ((Component)val3).GetComponent<RectTransform>();
						component3.anchoredPosition -= new Vector2(0f, (float)num3);
						num3 += 69;
						int num4 = ((data.ResultItems[j].Type == Trader_DataTypes.TraderItem.TraderItemType.Monster) ? (data.ResultItems[j].Level - 1) : data.ResultItems[j].Level);
						string arg2 = (data.ResultItems[j].DisplayStars ? $" <color=#00ff00>({num4}★)</color>" : "");
						((Component)((Component)val3).transform.Find("Text")).GetComponent<Text>().text = (ToBank ? "<color=cyan>[BANK]</color> " : "") + $"{data.ResultItems[j].ItemName}{arg2}\n<color=yellow>x{data.ResultItems[j].Count * ModifierValues[CurrentModifier]}</color>";
						((Component)((Component)val3).transform.Find("Icon")).GetComponent<Image>().sprite = ((data.ResultItems[j].Type == Trader_DataTypes.TraderItem.TraderItemType.Skill) ? Utils.GetSkillIcon(data.ResultItems[j].ItemPrefab) : data.ResultItems[j].GetIcon());
						FillUITooltip(val3, data.ResultItems[j]);
					}
					RectTransform component4 = ((Component)val.transform.Find("Background/ResultItems")).GetComponent<RectTransform>();
					component4.anchoredPosition += new Vector2(0f, CalculateOffset(data.ResultItems.Count));
					((UnityEvent)((Component)val.transform.Find("Background/Conversion")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						TradeItemByGo(data);
					});
					RectTransform component5 = val.GetComponent<RectTransform>();
					component5.anchoredPosition -= new Vector2(0f, num);
					CurrentObjects.Add(val);
					((Graphic)((Component)val.transform.Find("Background/Conversion/Conversion")).GetComponent<Image>()).color = (CanBuy(data) ? Color.green : Color.red);
					RectTransform component6 = val.GetComponent<RectTransform>();
					component6.sizeDelta += new Vector2(0f, 72.5f * (float)(num2 - 1));
					num += 72.5f * (float)(num2 - 1) + 79f;
				}
			}
			((Component)ContentTransform).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, num + 20f);
			Canvas.ForceUpdateCanvases();
			AllFilters.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			AllFilters.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
		}

		private static bool CanBuy(Trader_DataTypes.TraderData data)
		{
			foreach (Trader_DataTypes.TraderItem neededItem in data.NeededItems)
			{
				if (!HasEnough(neededItem))
				{
					return false;
				}
			}
			return true;
		}

		private static bool HasEnough(Trader_DataTypes.TraderItem r)
		{
			if (r.Type == Trader_DataTypes.TraderItem.TraderItemType.Item)
			{
				if (!FromBank)
				{
					return Utils.CustomCountItems(r.ItemPrefab, r.Level) >= r.Count * ModifierValues[CurrentModifier];
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(r.ItemPrefab);
				int value;
				int num = (Banker_DataTypes.BankerClientData.TryGetValue(stableHashCode, out value) ? value : 0);
				return num >= r.Count * ModifierValues[CurrentModifier];
			}
			return false;
		}

		private static bool CanAddToBanker(Trader_DataTypes.TraderItem item)
		{
			if (item.Type != 0)
			{
				return false;
			}
			if (item.Level > 1)
			{
				return false;
			}
			int hash = StringExtensionMethods.GetStableHashCode(item.ItemPrefab);
			return Banker_DataTypes.SyncedBankerProfiles.Value.Values.Any((List<int> x) => x.Contains(hash));
		}

		private static void TradeItemByGo(Trader_DataTypes.TraderData data)
		{
			Player localPlayer = Player.m_localPlayer;
			string text = Player.m_localPlayer.GetPlayerName() + " (" + Global_Configs._localUserID + ") TraderNPC: ";
			AssetStorage.AUsrc.Play();
			if (!CanBuy(data))
			{
				return;
			}
			if (FromBank)
			{
				int hashCode = Banker_DataTypes.BankerClientData.GetHashCode();
				if (LastPaidBankHashcode == hashCode)
				{
					return;
				}
				LastPaidBankHashcode = hashCode;
			}
			foreach (Trader_DataTypes.TraderItem neededItem in data.NeededItems)
			{
				if (neededItem.Type != 0)
				{
					continue;
				}
				int num = neededItem.Count * ModifierValues[CurrentModifier];
				if (!FromBank)
				{
					Utils.CustomRemoveItems(neededItem.ItemPrefab, num, neededItem.Level);
				}
				else
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(neededItem.ItemPrefab);
					if (Banker_DataTypes.BankerClientData.ContainsKey(stableHashCode))
					{
						Banker_DataTypes.BankerClientData[StringExtensionMethods.GetStableHashCode(neededItem.ItemPrefab)] -= num;
					}
					ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket BankerRemove", new object[2] { neededItem.ItemPrefab, num });
				}
				text += $"x{num} {neededItem.ItemName}, ";
			}
			text += "for => ";
			foreach (Trader_DataTypes.TraderItem resultItem in data.ResultItems)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(resultItem.ItemPrefab);
				switch (resultItem.Type)
				{
				case Trader_DataTypes.TraderItem.TraderItemType.Skill:
					Utils.IncreaseSkillEXP(resultItem.ItemPrefab, resultItem.Count * ModifierValues[CurrentModifier]);
					text += $"x{resultItem.Count * ModifierValues[CurrentModifier]} {resultItem.ItemName}, ";
					break;
				case Trader_DataTypes.TraderItem.TraderItemType.Item:
					if (ToBank && CanAddToBanker(resultItem))
					{
						ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket BankerDeposit", new object[2]
						{
							resultItem.ItemPrefab,
							resultItem.Count * ModifierValues[CurrentModifier]
						});
						MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize("$mpasn_addedtobank", new string[2]
						{
							(resultItem.Count * ModifierValues[CurrentModifier]).ToString(),
							Localization.instance.Localize(resultItem.ItemName)
						}), 0, (Sprite)null, false);
					}
					else
					{
						MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize("$mpasn_added", new string[2]
						{
							(resultItem.Count * ModifierValues[CurrentModifier]).ToString(),
							Localization.instance.Localize(resultItem.ItemName)
						}), 0, (Sprite)null, false);
						Utils.AddItemToPlayer(prefab, resultItem.Count * ModifierValues[CurrentModifier], resultItem.Level);
					}
					text += $"x{resultItem.Count * ModifierValues[CurrentModifier]} {resultItem.ItemName}, ";
					break;
				case Trader_DataTypes.TraderItem.TraderItemType.Monster:
					MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize("$mpasn_spawned", new string[2]
					{
						(resultItem.Count * ModifierValues[CurrentModifier]).ToString(),
						Localization.instance.Localize(resultItem.ItemName)
					}), 0, (Sprite)null, false);
					Utils.AddItemToPlayer(prefab, resultItem.Count * ModifierValues[CurrentModifier], resultItem.Level);
					text += $"x{resultItem.Count * ModifierValues[CurrentModifier]} {resultItem.ItemName}, ";
					break;
				}
			}
			text = text.Substring(0, text.Length - 2);
			ZRoutedRpc.instance.InvokeRoutedRPC("LogOnServer_mpasn", new object[2] { 3, text });
			CreateElementsNew();
		}

		public static void Hide()
		{
			ScrollbarMain.value = 1f;
			UI.SetActive(false);
			CurrentObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentObjects.Clear();
		}

		public static void Reload()
		{
			if (IsPanelVisible())
			{
				SortList();
				CreateElementsNew();
			}
		}

		private static void ResetBankText()
		{
			FromBankText.text = "Pay from Bank: " + (FromBank ? "<color=green>ON</color>" : "<color=red>OFF</color>") + "\nSend to Bank: " + (ToBank ? "<color=green>ON</color>" : "<color=red>OFF</color>");
		}

		public static void Show(string profile, string _npcName)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (Trader_DataTypes.ClientSideItemList.ContainsKey(profile))
			{
				CurrentProfile = profile;
				ToBank = false;
				FromBank = false;
				ResetBankText();
				SearchInput.text = "";
				SortList();
				SetModifier(Modifier.x1);
				CreateElementsNew();
				((Graphic)((Component)UI.transform.Find("Canvas/Background/ToBank/Image/img")).GetComponent<Image>()).color = Disabled;
				((Graphic)((Component)UI.transform.Find("Canvas/Background/FromBank/Image/img")).GetComponent<Image>()).color = Disabled;
				((Component)UI.transform.Find("Canvas/Background/ToBank")).gameObject.SetActive(true);
				((Component)UI.transform.Find("Canvas/Background/FromBank")).gameObject.SetActive(true);
				((Component)FromBankText).gameObject.SetActive(true);
				InventoryGui.instance.Show((Container)null, 1);
				UI.SetActive(true);
				_npcName = Utils.RichTextFormatting(_npcName);
				NPCname.text = (string.IsNullOrEmpty(_npcName) ? Localization.instance.Localize("$mpasn_Trader") : _npcName);
				ScrollView_Optimization.StartOptimization(UI, IsPanelVisible, CurrentObjects, UI_Optimizations.OptimizationType.Vertical);
			}
		}
	}
}
namespace Marketplace.Modules.Teleporter
{
	public static class Teleporter_DataTypes
	{
		public class TeleporterData : ISerializableParameter
		{
			public string name;

			public string sprite;

			public int x;

			public int y;

			public int z;

			public int speed;

			public string fromProfile;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(name ?? "");
				pkg.Write(sprite ?? "");
				pkg.Write(x);
				pkg.Write(y);
				pkg.Write(z);
				pkg.Write(speed);
				pkg.Write(fromProfile ?? "");
			}

			public void Deserialize(ref ZPackage pkg)
			{
				name = pkg.ReadString();
				sprite = pkg.ReadString();
				x = pkg.ReadInt();
				y = pkg.ReadInt();
				z = pkg.ReadInt();
				speed = pkg.ReadInt();
				fromProfile = pkg.ReadString();
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, List<TeleporterData>>> SyncedTeleporterData = new CustomSyncedValue<Dictionary<string, List<TeleporterData>>>(Marketplace.configSync, "teleporterData", new Dictionary<string, List<TeleporterData>>());
	}
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class Teleporter_Main_Client
	{
		[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
		[ClientOnlyPatch]
		private static class PatchClickIconMinimap
		{
			private static bool Prefix(Minimap __instance)
			{
				//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_000b: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
				Vector3 pos = __instance.ScreenToWorldPoint(Input.mousePosition);
				PinData customPin = Utils.GetCustomPin((PinType)177, pos, __instance.m_removeRadius * (__instance.m_largeZoom * 2f));
				if (customPin != null)
				{
					if (!Global_Configs.SyncedGlobalOptions.Value._canTeleportWithOre && !((Humanoid)Player.m_localPlayer).IsTeleportable())
					{
						MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_teleportwithore") + "</color>", 0, (Sprite)null, false);
						__instance.SetMapMode((MapMode)1);
						return false;
					}
					__instance.SetMapMode((MapMode)1);
					if (SpeedValues.TryGetValue(customPin, out var value) && value > 0)
					{
						((MonoBehaviour)Player.m_localPlayer).StartCoroutine(MarketplaceTeleporterMovement(value, ((Component)Player.m_localPlayer).transform.position, customPin.m_pos));
					}
					else
					{
						DEBUG_TELEPORTTO_TERRITORY = true;
						((Character)Player.m_localPlayer).TeleportTo(customPin.m_pos, ((Component)Player.m_localPlayer).transform.rotation, true);
						DEBUG_TELEPORTTO_TERRITORY = false;
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		[ClientOnlyPatch]
		private static class PatchRemovePinsMinimap
		{
			private static void Prefix(MapMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode == 2)
				{
					return;
				}
				foreach (PinData currentTeleporterObject in CurrentTeleporterObjects)
				{
					Minimap.instance.RemovePin(currentTeleporterObject);
				}
				CurrentTeleporterObjects.Clear();
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		[ClientOnlyPatch]
		private static class PLAYERHIDE
		{
			private static void Postfix(Player __instance)
			{
				Player __instance2 = __instance;
				((Character)__instance2).m_nview.Register<bool>("HideMarketplaceTeleporter", (Action<long, bool>)delegate(long _, bool tf)
				{
					((Character)__instance2).m_visual.SetActive(tf);
					((Character)__instance2).m_animator.SetBool(Wakeup, false);
				});
				ZNetView nview = ((Character)__instance2).m_nview;
				if (nview != null)
				{
					ZDO zdo = nview.m_zdo;
					if (((zdo != null) ? new bool?(zdo.GetBool("MarketplaceTeleporterHide", false)) : null).GetValueOrDefault())
					{
						((MonoBehaviour)__instance2).StartCoroutine(DelayInvokeSMR(__instance2));
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "CustomFixedUpdate")]
		[ClientOnlyPatch]
		private static class PriestCancelTP
		{
			private static void Postfix(Character __instance)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				if (TeleporterJump && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					__instance.m_body.useGravity = false;
					__instance.m_body.velocity = Vector3.zero;
					__instance.m_currentVel = Vector3.zero;
					__instance.m_body.angularVelocity = Vector3.zero;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		[ClientOnlyPatch]
		private static class Character_Damage_Patch
		{
			private static bool Prefix(Character __instance)
			{
				if (TeleporterJump)
				{
					return (Object)(object)__instance != (Object)(object)Player.m_localPlayer;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <DelayInvokeSMR>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player p;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)p))
					{
						return false;
					}
					((Character)p).m_visual.SetActive(false);
					((Character)p).m_animator.SetBool(Wakeup, false);
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <MarketplaceTeleporterMovement>d__15 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Vector3 startPos;

			public Vector3 targetPos;

			public int speed;

			private GameObject <mainEffect>5__2;

			private Player <p>5__3;

			private float <time>5__4;

			private float <count>5__5;

			private float <messageTimer>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<mainEffect>5__2 = null;
				<p>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: 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_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//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_0367: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0437: Unknown result type (might be due to invalid IL or missing references)
				//IL_043c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0441: Unknown result type (might be due to invalid IL or missing references)
				//IL_0451: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_0210: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: 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)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0230: Unknown result type (might be due to invalid IL or missing references)
				//IL_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_0255: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Unknown result type (might be due to invalid IL or missing references)
				//IL_0264: Unknown result type (might be due to invalid IL or missing references)
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<mainEffect>5__2 = Object.Instantiate<GameObject>(AssetStorage.Teleporter_VFX1, startPos, ((Component)Player.m_localPlayer).transform.rotation);
					TeleporterJump = true;
					<p>5__3 = Player.m_localPlayer;
					Object.Instantiate<GameObject>(AssetStorage.Teleporter_VFX2, ((Component)<p>5__3).transform.position + Vector3.up, ((Component)<p>5__3).transform.rotation);
					((Character)<p>5__3).m_nview.InvokeRPC(ZNetView.Everybody, "HideMarketplaceTeleporter", new object[1] { false });
					((Character)<p>5__3).m_nview.m_zdo.Set("MarketplaceTeleporterHide", true);
					((Character)<p>5__3).m_zanim.SetTrigger("emote_stop");
					((Collider)((Character)<p>5__3).m_collider).isTrigger = true;
					float num = Utils.DistanceXZ(startPos, targetPos);
					<time>5__4 = Mathf.Max(1f, num / (float)speed);
					<count>5__5 = 0f;
					Transform transform = ((Component)Player.m_localPlayer).transform;
					Vector3 val = targetPos - startPos;
					transform.rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized);
					goto IL_02ad;
				}
				case 1:
					<>1__state = -1;
					goto IL_02ad;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_02ad:
					if (<count>5__5 < 1f)
					{
						if (!Object.op_Implicit((Object)(object)<p>5__3) || ((Character)<p>5__3).IsDead())
						{
							ZNetScene.instance.Destroy(<mainEffect>5__2);
							TeleporterJump = false;
							return false;
						}
						((Character)<p>5__3).m_body.velocity = Vector3.zero;
						((Character)<p>5__3).m_body.angularVelocity = Vector3.zero;
						((Character)<p>5__3).m_lastGroundTouch = 0f;
						((Character)<p>5__3).m_maxAirAltitude = 0f;
						<count>5__5 += Time.deltaTime / <time>5__4;
						Vector3 val2 = startPos + (targetPos - startPos) / 2f + Vector3.up * 500f;
						Vector3 val3 = Vector3.Lerp(startPos, val2, <count>5__5);
						Vector3 val4 = Vector3.Lerp(val2, targetPos, <count>5__5);
						((Component)<p>5__3).transform.position = Vector3.Lerp(val3, val4, <count>5__5);
						<mainEffect>5__2.transform.position = ((Component)<p>5__3).transform.position;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<messageTimer>5__6 = 1f;
					break;
				}
				if (!ZNetScene.instance.IsAreaReady(((Component)Player.m_localPlayer).transform.position))
				{
					<messageTimer>5__6 -= Time.deltaTime;
					if (!Object.op_Implicit((Object)(object)<p>5__3) || ((Character)<p>5__3).IsDead())
					{
						ZNetScene.instance.Destroy(<mainEffect>5__2);
						TeleporterJump = false;
						return false;
					}
					if (<messageTimer>5__6 <= 0f)
					{
						<messageTimer>5__6 = 1f;
						MessageHud.instance.ShowMessage((MessageType)2, "$mpasn_zoneloading".Localize(), 0, (Sprite)null, false);
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				ZNetScene.instance.Destroy(<mainEffect>5__2);
				TeleporterJump = false;
				((Collider)((Character)<p>5__3).m_collider).isTrigger = false;
				((Character)<p>5__3).m_nview.m_zdo.Set("MarketplaceTeleporterHide", false);
				((Character)<p>5__3).m_body.velocity = Vector3.zero;
				((Character)<p>5__3).m_body.useGravity = true;
				((Character)<p>5__3).m_lastGroundTouch = 0f;
				((Character)<p>5__3).m_maxAirAltitude = 0f;
				((Character)<p>5__3).m_nview.InvokeRPC(ZNetView.Everybody, "HideMarketplaceTeleporter", new object[1] { true });
				Object.Instantiate<GameObject>(AssetStorage.Teleporter_VFX2, ((Component)<p>5__3).transform.position + Vector3.up, ((Component)<p>5__3).transform.rotation);
				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();
			}
		}

		private static readonly List<PinData> CurrentTeleporterObjects = new List<PinData>();

		private static readonly Dictionary<PinData, int> SpeedValues = new Dictionary<PinData, int>();

		private const PinType PINTYPE = 177;

		private static bool TeleporterJump;

		public static bool DEBUG_TELEPORTTO_TERRITORY;

		private static readonly int Wakeup = Animator.StringToHash("wakeup");

		[UsedImplicitly]
		private static void OnInit()
		{
			Teleporter_DataTypes.SyncedTeleporterData.Value.Count();
		}

		private static void CreatePinFromData(Teleporter_DataTypes.TeleporterData data)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			PinData val = new PinData
			{
				m_type = (PinType)177,
				m_name = data.name,
				m_pos = new Vector3((float)data.x, (float)data.y, (float)data.z)
			};
			if (!string.IsNullOrEmpty(val.m_name))
			{
				val.m_NamePinData = new PinNameData(val);
			}
			Sprite icon = Utils.TryFindIcon(data.sprite, AssetStorage.PortalIconDefault);
			val.m_icon = icon;
			val.m_save = false;
			val.m_checked = false;
			val.m_ownerID = 0L;
			Minimap.instance.m_pins.Add(val);
			CurrentTeleporterObjects.Add(val);
			SpeedValues.Add(val, data.speed);
		}

		internal static void ShowTeleporterUI(string profile)
		{
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui.instance.Hide();
			foreach (PinData currentTeleporterObject in CurrentTeleporterObjects)
			{
				Minimap.instance.RemovePin(currentTeleporterObject);
			}
			CurrentTeleporterObjects.Clear();
			SpeedValues.Clear();
			if (!Teleporter_DataTypes.SyncedTeleporterData.Value.ContainsKey(profile))
			{
				return;
			}
			List<Teleporter_DataTypes.TeleporterData> list = Teleporter_DataTypes.SyncedTeleporterData.Value[profile];
			Minimap.instance.SetMapMode((MapMode)2);
			foreach (Teleporter_DataTypes.TeleporterData item in list)
			{
				CreatePinFromData(item);
			}
			foreach (Teleporter_DataTypes.TeleporterData item2 in list.Where((Teleporter_DataTypes.TeleporterData x) => !string.IsNullOrEmpty(x.fromProfile) && Teleporter_DataTypes.SyncedTeleporterData.Value.ContainsKey(x.fromProfile)).SelectMany((Teleporter_DataTypes.TeleporterData x) => Teleporter_DataTypes.SyncedTeleporterData.Value[x.fromProfile]))
			{
				CreatePinFromData(item2);
			}
			Minimap.instance.m_largeZoom = 1f;
			Minimap.instance.CenterMap(Vector3.zero);
		}

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

		[IteratorStateMachine(typeof(<MarketplaceTeleporterMovement>d__15))]
		private static IEnumerator MarketplaceTeleporterMovement(int speed, Vector3 startPos, Vector3 targetPos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MarketplaceTeleporterMovement>d__15(0)
			{
				speed = speed,
				startPos = startPos,
				targetPos = targetPos
			};
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "TE" }, new string[] { "OnTeleporterProfilesChange" })]
	public static class Teleporter_Main_Server
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			ReadServerTeleporterProfiles();
		}

		private static void ProcessTeleporterProfiles(string fPath, IReadOnlyList<string> profiles)
		{
			string key = "default";
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					key = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					continue;
				}
				Teleporter_DataTypes.TeleporterData teleporterData = new Teleporter_DataTypes.TeleporterData();
				if (profiles[i].StartsWith("@from:"))
				{
					string fromProfile = profiles[i].Replace("@from:", "").Replace(" ", "").ToLower();
					teleporterData.fromProfile = fromProfile;
				}
				else
				{
					string[] array = profiles[i].Split(new char[1] { ',' });
					try
					{
						int speed = 0;
						string text = array[0];
						int num = text.IndexOf("<speed=", StringComparison.Ordinal);
						if (num != -1)
						{
							string text2 = text.Substring(num + "<speed=".Length);
							int num2 = text2.IndexOf('>');
							if (num2 > 0)
							{
								string value = text2.Replace(">", "");
								if (!string.IsNullOrWhiteSpace(value))
								{
									speed = Convert.ToInt32(value);
								}
								text = Utils.RemoveRichTextDynamicTag(text, "speed");
							}
						}
						teleporterData.name = text;
						teleporterData.speed = speed;
						teleporterData.x = int.Parse(array[1].Replace(" ", ""));
						teleporterData.y = int.Parse(array[2].Replace(" ", ""));
						teleporterData.z = int.Parse(array[3].Replace(" ", ""));
						teleporterData.sprite = ((array.Length == 5) ? array[4].Replace(" ", "") : "none");
					}
					catch (Exception arg)
					{
						Utils.print($"{arg}\nERROR: Can't add pins in {fPath}, line: {i}", ConsoleColor.Red);
						break;
					}
				}
				if (Teleporter_DataTypes.SyncedTeleporterData.Value.TryGetValue(key, out List<Teleporter_DataTypes.TeleporterData> value2))
				{
					value2.Add(teleporterData);
					continue;
				}
				Teleporter_DataTypes.SyncedTeleporterData.Value[key] = new List<Teleporter_DataTypes.TeleporterData>(1) { teleporterData };
			}
		}

		private static void ReadServerTeleporterProfiles()
		{
			Teleporter_DataTypes.SyncedTeleporterData.Value.Clear();
			string teleportHubProfilesFolder = Market_Paths.TeleportHubProfilesFolder;
			string[] files = Directory.GetFiles(teleportHubProfilesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ProcessTeleporterProfiles(text, profiles);
			}
			Teleporter_DataTypes.SyncedTeleporterData.Update();
		}

		private static void OnTeleporterProfilesChange()
		{
			ReadServerTeleporterProfiles();
			Utils.print("TeleportHub changed, sending options to peers");
		}
	}
}
namespace Marketplace.Modules.ServerInfo
{
	public static class ServerInfo_DataTypes
	{
		public class ServerInfoQueue : ISerializableParameter
		{
			public class Info
			{
				public enum InfoType
				{
					Text,
					Image
				}

				public string Text;

				public InfoType Type;

				private Sprite tex;

				public void SetSprite(Sprite _sprite)
				{
					tex = _sprite;
				}

				public Sprite GetSprite()
				{
					return tex;
				}
			}

			public List<Info> infoQueue = new List<Info>();

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(infoQueue.Count);
				foreach (Info item in infoQueue)
				{
					pkg.Write((int)item.Type);
					pkg.Write(item.Text ?? "");
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				int num = pkg.ReadInt();
				for (int i = 0; i < num; i++)
				{
					Info item = new Info
					{
						Type = (Info.InfoType)pkg.ReadInt(),
						Text = pkg.ReadString()
					};
					infoQueue.Add(item);
				}
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, ServerInfoQueue>> SyncedServerInfoData = new CustomSyncedValue<Dictionary<string, ServerInfoQueue>>(Marketplace.configSync, "infoData", new Dictionary<string, ServerInfoQueue>());
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class ServerInfo_Main_Client
	{
		private static void OnInit()
		{
			ServerInfo_UI.Init();
			ServerInfo_DataTypes.SyncedServerInfoData.ValueChanged += OnInfoUpdate;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
			GameEvents.OnPlayerFirstSpawn = (Action)Delegate.Combine(GameEvents.OnPlayerFirstSpawn, new Action(OnPlayerFirstSpawn));
		}

		private static void OnPlayerFirstSpawn()
		{
			if (ServerInfo_DataTypes.SyncedServerInfoData.Value.ContainsKey("onplayerfirstspawn"))
			{
				ServerInfo_UI.Show("onplayerfirstspawn", "");
			}
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && ServerInfo_UI.IsPanelVisible())
			{
				ServerInfo_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		private static void OnInfoUpdate()
		{
			foreach (ServerInfo_DataTypes.ServerInfoQueue.Info url in from x in ServerInfo_DataTypes.SyncedServerInfoData.Value.Values.SelectMany((ServerInfo_DataTypes.ServerInfoQueue x) => x.infoQueue)
				where x.Type == ServerInfo_DataTypes.ServerInfoQueue.Info.InfoType.Image
				select x)
			{
				Utils.LoadImageFromWEB(url.Text, delegate(Sprite sprite)
				{
					url.SetSprite(sprite);
				}, "OnInfoUpdate");
			}
			if (ServerInfo_UI.IsPanelVisible())
			{
				ServerInfo_UI.Reload();
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "SI" }, new string[] { "OnServerInfoProfileChange" })]
	public static class ServerInfo_Main_Server
	{
		private static void OnInit()
		{
			ReadServerInfoProfiles();
		}

		private static void OnServerInfoProfileChange()
		{
			ReadServerInfoProfiles();
			Utils.print("Info Profiles Changed. Sending new info to all clients");
		}

		private static void ProcessServerInfoProfiles(IReadOnlyList<string> profiles)
		{
			string key = "default";
			List<ServerInfo_DataTypes.ServerInfoQueue.Info> list = new List<ServerInfo_DataTypes.ServerInfoQueue.Info>();
			string text = "";
			for (int i = 0; i < profiles.Count; i++)
			{
				if (profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					if (!string.IsNullOrEmpty(text))
					{
						list.Add(new ServerInfo_DataTypes.ServerInfoQueue.Info
						{
							Type = ServerInfo_DataTypes.ServerInfoQueue.Info.InfoType.Text,
							Text = text.TrimEnd(new char[1] { '\n' })
						});
						ServerInfo_DataTypes.SyncedServerInfoData.Value[key] = new ServerInfo_DataTypes.ServerInfoQueue
						{
							infoQueue = new List<ServerInfo_DataTypes.ServerInfoQueue.Info>(list)
						};
					}
					key = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					list = new List<ServerInfo_DataTypes.ServerInfoQueue.Info>();
					text = "";
				}
				else if (profiles[i].Contains("<image="))
				{
					string[] array = profiles[i].Split(new string[1] { "<image=" }, StringSplitOptions.None);
					string[] array2 = array[1].Split(new string[1] { ">" }, StringSplitOptions.None);
					string text2 = array2[0];
					string text3 = array[0];
					string text4 = array2[1];
					text += text3;
					list.Add(new ServerInfo_DataTypes.ServerInfoQueue.Info
					{
						Type = ServerInfo_DataTypes.ServerInfoQueue.Info.InfoType.Text,
						Text = text
					});
					list.Add(new ServerInfo_DataTypes.ServerInfoQueue.Info
					{
						Type = ServerInfo_DataTypes.ServerInfoQueue.Info.InfoType.Image,
						Text = text2
					});
					text = text4 + "\n";
				}
				else
				{
					text = text + profiles[i] + "\n";
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				list.Add(new ServerInfo_DataTypes.ServerInfoQueue.Info
				{
					Type = ServerInfo_DataTypes.ServerInfoQueue.Info.InfoType.Text,
					Text = text.TrimEnd(new char[1] { '\n' })
				});
				ServerInfo_DataTypes.SyncedServerInfoData.Value[key] = new ServerInfo_DataTypes.ServerInfoQueue
				{
					infoQueue = new List<ServerInfo_DataTypes.ServerInfoQueue.Info>(list)
				};
				list.Clear();
			}
		}

		private static void ReadServerInfoProfiles()
		{
			ServerInfo_DataTypes.SyncedServerInfoData.Value.Clear();
			string serverInfoProfilesFolder = Market_Paths.ServerInfoProfilesFolder;
			string[] files = Directory.GetFiles(serverInfoProfilesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string path in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(path).ToList();
				ProcessServerInfoProfiles(profiles);
			}
			ServerInfo_DataTypes.SyncedServerInfoData.Update();
		}
	}
	public static class ServerInfo_UI
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class InfoUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsPanelVisible())
				{
					__result = true;
				}
			}
		}

		private static GameObject UI;

		private static Text NPCname;

		private static Scrollbar Scrollbar;

		private static string CurrentProfile;

		private static Transform Content;

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceInfoNewUI"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			NPCname = ((Component)UI.transform.Find("Canvas/Header/Text")).GetComponent<Text>();
			Content = UI.transform.Find("Canvas/Scroll View/Viewport/Content/");
			Scrollbar = UI.GetComponentInChildren<Scrollbar>();
			UI.SetActive(false);
		}

		public static void Reload()
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPanelVisible())
			{
				return;
			}
			if (!ServerInfo_DataTypes.SyncedServerInfoData.Value.ContainsKey(CurrentProfile))
			{
				Hide();
				return;
			}
			Transform val = Content.Find("Text");
			Transform val2 = Content.Find("Image");
			for (int i = 2; i < Content.childCount; i++)
			{
				Object.Destroy((Object)(object)((Component)Content.GetChild(i)).gameObject);
			}
			foreach (ServerInfo_DataTypes.ServerInfoQueue.Info item in ServerInfo_DataTypes.SyncedServerInfoData.Value[CurrentProfile].infoQueue)
			{
				if (item.Type == ServerInfo_DataTypes.ServerInfoQueue.Info.InfoType.Text)
				{
					Transform val3 = Object.Instantiate<Transform>(val, Content);
					((Component)val3).gameObject.SetActive(true);
					((Component)val3).GetComponent<Text>().text = item.Text;
					continue;
				}
				Transform val4 = Object.Instantiate<Transform>(val2, Content);
				((Component)val4).gameObject.SetActive(true);
				Sprite sprite = item.GetSprite();
				((Component)val4).GetComponent<Image>().sprite = sprite;
				if ((Object)(object)sprite != (Object)null && (Object)(object)sprite.texture != (Object)null)
				{
					((Component)val4).GetComponent<RectTransform>().sizeDelta = new Vector2((float)Mathf.Min(700, ((Texture)sprite.texture).width), (float)((Texture)sprite.texture).height);
				}
			}
			Canvas.ForceUpdateCanvases();
			List<ContentSizeFitter> list = UI.GetComponentsInChildren<ContentSizeFitter>().ToList();
			list.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			list.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
		}

		public static void Hide()
		{
			for (int i = 2; i < Content.childCount; i++)
			{
				Object.Destroy((Object)(object)((Component)Content.GetChild(i)).gameObject);
			}
			UI.SetActive(false);
		}

		public static void Show(string profile, string _npcName)
		{
			if (ServerInfo_DataTypes.SyncedServerInfoData.Value.ContainsKey(profile))
			{
				CurrentProfile = profile;
				UI.SetActive(true);
				_npcName = Utils.RichTextFormatting(_npcName);
				NPCname.text = (string.IsNullOrEmpty(_npcName) ? Localization.instance.Localize("$mpasn_Info") : _npcName);
				Scrollbar.value = 1f;
				Reload();
			}
		}
	}
}
namespace Marketplace.Modules.Quests
{
	public static class Quests_DataTypes
	{
		public enum QuestEventCondition
		{
			OnAcceptQuest,
			OnCancelQuest,
			OnCompleteQuest,
			OnQuestTimeout,
			OnDeath
		}

		[Flags]
		public enum SpecialQuestTag
		{
			None = 0,
			Autocomplete = 1
		}

		public enum QuestType
		{
			Kill,
			Collect,
			Harvest,
			Craft,
			Talk,
			Build,
			Move
		}

		public enum QuestRewardType
		{
			Item,
			RandomItem,
			Skill,
			Skill_EXP,
			Pet,
			EpicMMO_EXP,
			Cozyheim_EXP,
			GuildAddLevel,
			Battlepass_EXP,
			SetCustomValue,
			AddCustomValue,
			RustyClasses_EXP
		}

		public record RandomItemEntry(ItemDrop Item, int Amount, int Level);

		public class QuestEvent : ISerializableParameter
		{
			[CompilerGenerated]
			private List<string> <args_OnAcceptQuest>P;

			[CompilerGenerated]
			private List<string> <args_OnCancelQuest>P;

			[CompilerGenerated]
			private List<string> <args_OnCompleteQuest>P;

			[CompilerGenerated]
			private List<string> <args_OnQuestTimeout>P;

			[CompilerGenerated]
			private List<string> <args_OnDeath>P;

			public Action<Market_NPC.NPCcomponent> OnAcceptQuest;

			public Action<Market_NPC.NPCcomponent> OnCancelQuest;

			public Action<Market_NPC.NPCcomponent> OnCompleteQuest;

			public Action<Market_NPC.NPCcomponent> OnQuestTimeout;

			public Action<Market_NPC.NPCcomponent> OnDeath;

			public QuestEvent(List<string> args_OnAcceptQuest, List<string> args_OnCancelQuest, List<string> args_OnCompleteQuest, List<string> args_OnQuestTimeout, List<string> args_OnDeath)
			{
				<args_OnAcceptQuest>P = args_OnAcceptQuest;
				<args_OnCancelQuest>P = args_OnCancelQuest;
				<args_OnCompleteQuest>P = args_OnCompleteQuest;
				<args_OnQuestTimeout>P = args_OnQuestTimeout;
				<args_OnDeath>P = args_OnDeath;
				base..ctor();
			}

			public QuestEvent()
				: this(new List<string>(), new List<string>(), new List<string>(), new List<string>(), new List<string>())
			{
			}

			public void AddOnAcceptQuest(string command)
			{
				<args_OnAcceptQuest>P.Add(command);
			}

			public void AddOnCancelQuest(string command)
			{
				<args_OnCancelQuest>P.Add(command);
			}

			public void AddOnCompleteQuest(string command)
			{
				<args_OnCompleteQuest>P.Add(command);
			}

			public void AddOnQuestTimeout(string command)
			{
				<args_OnQuestTimeout>P.Add(command);
			}

			public void AddOnDeath(string command)
			{
				<args_OnDeath>P.Add(command);
			}

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(<args_OnAcceptQuest>P.Count);
				for (int i = 0; i < <args_OnAcceptQuest>P.Count; i++)
				{
					pkg.Write(<args_OnAcceptQuest>P[i] ?? "");
				}
				pkg.Write(<args_OnCancelQuest>P.Count);
				for (int j = 0; j < <args_OnCancelQuest>P.Count; j++)
				{
					pkg.Write(<args_OnCancelQuest>P[j] ?? "");
				}
				pkg.Write(<args_OnCompleteQuest>P.Count);
				for (int k = 0; k < <args_OnCompleteQuest>P.Count; k++)
				{
					pkg.Write(<args_OnCompleteQuest>P[k] ?? "");
				}
				pkg.Write(<args_OnQuestTimeout>P.Count);
				for (int l = 0; l < <args_OnQuestTimeout>P.Count; l++)
				{
					pkg.Write(<args_OnQuestTimeout>P[l] ?? "");
				}
				pkg.Write(<args_OnDeath>P.Count);
				for (int m = 0; m < <args_OnDeath>P.Count; m++)
				{
					pkg.Write(<args_OnDeath>P[m] ?? "");
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				int num = pkg.ReadInt();
				for (int i = 0; i < num; i++)
				{
					<args_OnAcceptQuest>P.Add(pkg.ReadString());
				}
				int num2 = pkg.ReadInt();
				for (int j = 0; j < num2; j++)
				{
					<args_OnCancelQuest>P.Add(pkg.ReadString());
				}
				int num3 = pkg.ReadInt();
				for (int k = 0; k < num3; k++)
				{
					<args_OnCompleteQuest>P.Add(pkg.ReadString());
				}
				int num4 = pkg.ReadInt();
				for (int l = 0; l < num4; l++)
				{
					<args_OnQuestTimeout>P.Add(pkg.ReadString());
				}
				int num5 = pkg.ReadInt();
				for (int m = 0; m < num5; m++)
				{
					<args_OnDeath>P.Add(pkg.ReadString());
				}
				OnAcceptQuest = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnAcceptQuest>P);
				OnCancelQuest = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnCancelQuest>P);
				OnCompleteQuest = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnCompleteQuest>P);
				OnQuestTimeout = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnQuestTimeout>P);
				OnDeath = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnDeath>P);
			}

			public void ParseAll()
			{
				if (Marketplace.WorkingAsType == Marketplace.WorkingAs.Both)
				{
					OnAcceptQuest = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnAcceptQuest>P);
					OnCancelQuest = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnCancelQuest>P);
					OnCompleteQuest = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnCompleteQuest>P);
					OnQuestTimeout = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnQuestTimeout>P);
					OnDeath = Dialogues_DataTypes.Dialogue.ParseCommands(<args_OnDeath>P);
				}
			}
		}

		public class Quest : ISerializableParameter
		{
			public QuestType Type;

			public SpecialQuestTag SpecialTag;

			public string Name;

			public string Description;

			public int TargetAmount;

			public string[] TargetPrefab;

			public int[] TargetCount;

			public int[] TargetLevel;

			public int RewardsAmount;

			public QuestRewardType[] RewardType;

			public string[] RewardPrefab;

			public int[] RewardCount;

			public int[] RewardLevel;

			public List<string[]> Conditions;

			public int TransferComplition;

			public string TransferComplitionText;

			public Dialogues_DataTypes.Dialogue_Condition Condition;

			public string PreviewImage;

			public int Cooldown;

			public int TimeLimit;

			private string[] LocalizedReward;

			private string[] LocalizedTarget;

			public int[] ScoreArray { get; private set; }

			public long AcceptedTime { get; private set; }

			public Sprite GetPreviewSprite { get; private set; }

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write((int)Type);
				pkg.Write((int)SpecialTag);
				pkg.Write(Name ?? "");
				pkg.Write(Description ?? "");
				pkg.Write(TargetAmount);
				for (int i = 0; i < TargetAmount; i++)
				{
					pkg.Write(TargetPrefab[i] ?? "");
					pkg.Write(TargetCount[i]);
					pkg.Write(TargetLevel[i]);
				}
				pkg.Write(RewardsAmount);
				for (int j = 0; j < RewardsAmount; j++)
				{
					pkg.Write((int)RewardType[j]);
					pkg.Write(RewardPrefab[j] ?? "");
					pkg.Write(RewardCount[j]);
					pkg.Write(RewardLevel[j]);
				}
				pkg.Write(Conditions.Count);
				for (int k = 0; k < Conditions.Count; k++)
				{
					pkg.Write(Conditions[k].Length);
					for (int l = 0; l < Conditions[k].Length; l++)
					{
						pkg.Write(Conditions[k][l]);
					}
				}
				pkg.Write(PreviewImage ?? "");
				pkg.Write(Cooldown);
				pkg.Write(TimeLimit);
				pkg.Write(TransferComplition);
				pkg.Write(TransferComplitionText ?? "");
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Type = (QuestType)pkg.ReadInt();
				SpecialTag = (SpecialQuestTag)pkg.ReadInt();
				Name = pkg.ReadString();
				Description = pkg.ReadString();
				TargetAmount = pkg.ReadInt();
				TargetPrefab = new string[TargetAmount];
				TargetCount = new int[TargetAmount];
				TargetLevel = new int[TargetAmount];
				for (int i = 0; i < TargetAmount; i++)
				{
					TargetPrefab[i] = pkg.ReadString();
					TargetCount[i] = pkg.ReadInt();
					TargetLevel[i] = pkg.ReadInt();
				}
				RewardsAmount = pkg.ReadInt();
				RewardType = new QuestRewardType[RewardsAmount];
				RewardPrefab = new string[RewardsAmount];
				RewardCount = new int[RewardsAmount];
				RewardLevel = new int[RewardsAmount];
				for (int j = 0; j < RewardsAmount; j++)
				{
					RewardType[j] = (QuestRewardType)pkg.ReadInt();
					RewardPrefab[j] = pkg.ReadString();
					RewardCount[j] = pkg.ReadInt();
					RewardLevel[j] = pkg.ReadInt();
				}
				int num = pkg.ReadInt();
				Conditions = new List<string[]>(num);
				for (int k = 0; k < num; k++)
				{
					int num2 = pkg.ReadInt();
					string[] array = new string[num2];
					for (int l = 0; l < num2; l++)
					{
						array[l] = pkg.ReadString();
					}
					Conditions.Add(array);
				}
				PreviewImage = pkg.ReadString();
				Cooldown = pkg.ReadInt();
				TimeLimit = pkg.ReadInt();
				TransferComplition = pkg.ReadInt();
				TransferComplitionText = pkg.ReadString();
			}

			public void SetPreviewSprite(Sprite sprite)
			{
				GetPreviewSprite = sprite;
			}

			public override string ToString()
			{
				return "";
			}

			public int GetScore(int index)
			{
				return ScoreArray[index];
			}

			public bool IsComplete()
			{
				for (int i = 0; i < TargetAmount; i++)
				{
					if (ScoreArray[i] < TargetCount[i])
					{
						return false;
					}
				}
				return true;
			}

			public bool IsComplete(int index)
			{
				return ScoreArray[index] >= TargetCount[index];
			}

			public bool Init()
			{
				for (int i = 0; i < RewardsAmount; i++)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(RewardPrefab[i]);
					bool flag = !Object.op_Implicit((Object)(object)prefab);
					bool flag2 = flag;
					if (flag2)
					{
						QuestRewardType questRewardType = RewardType[i];
						bool flag3 = ((questRewardType == QuestRewardType.Item || questRewardType == QuestRewardType.Pet) ? true : false);
						flag2 = flag3;
					}
					if (flag2)
					{
						return false;
					}
					if (RewardType[i] != QuestRewardType.RandomItem)
					{
						continue;
					}
					string[] array = RewardPrefab[i].Split(new char[1] { ',' });
					if (array.Length % 3 != 0)
					{
						return false;
					}
					for (int j = 0; j < array.Length; j += 3)
					{
						string text = array[j];
						if (!Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(text)))
						{
							return false;
						}
						if (!int.TryParse(array[j + 1], out var result))
						{
							return false;
						}
						if (!int.TryParse(array[j + 2], out result))
						{
							return false;
						}
					}
				}
				if (Type != QuestType.Talk && Type != QuestType.Move)
				{
					for (int k = 0; k < TargetAmount; k++)
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab(TargetPrefab[k]);
						if (!Object.op_Implicit((Object)(object)prefab2))
						{
							return false;
						}
					}
				}
				Condition = Dialogues_DataTypes.Dialogue.CombineOrConditions(Conditions, isQuest: true);
				LocalizedReward = new string[RewardsAmount];
				LocalizedTarget = new string[TargetAmount];
				for (int l = 0; l < RewardsAmount; l++)
				{
					LocalizedReward[l] = "";
					GameObject prefab3 = ZNetScene.instance.GetPrefab(RewardPrefab[l]);
					switch (RewardType[l])
					{
					case QuestRewardType.Pet:
						if (!Object.op_Implicit((Object)(object)prefab3.GetComponent<Character>()))
						{
							return false;
						}
						PhotoManager.__instance.MakeSprite(prefab3, RewardLevel[l]);
						LocalizedReward[l] = Localization.instance.Localize(prefab3.GetComponent<Character>().m_name);
						break;
					case QuestRewardType.Item:
						if (!Object.op_Implicit((Object)(object)prefab3.GetComponent<ItemDrop>()))
						{
							return false;
						}
						LocalizedReward[l] = Localization.instance.Localize(prefab3.GetComponent<ItemDrop>().m_itemData.m_shared.m_name);
						break;
					case QuestRewardType.RandomItem:
						LocalizedReward[l] = "$mpasn_RandomItem".Localize();
						break;
					case QuestRewardType.Skill:
					case QuestRewardType.Skill_EXP:
						LocalizedReward[l] = Utils.LocalizeSkill(RewardPrefab[l]);
						break;
					case QuestRewardType.SetCustomValue:
					case QuestRewardType.AddCustomValue:
						LocalizedReward[l] = RewardPrefab[l].Replace("_", " ");
						break;
					}
				}
				if (Type == QuestType.Talk)
				{
					for (int m = 0; m < TargetAmount; m++)
					{
						LocalizedTarget[m] = "<color=yellow>" + Utils.RichTextFormatting(TargetPrefab[m]) + "</color>";
					}
					return true;
				}
				QuestType type = Type;
				if ((type == QuestType.Collect || type == QuestType.Craft) ? true : false)
				{
					for (int n = 0; n < TargetAmount; n++)
					{
						GameObject prefab4 = ZNetScene.instance.GetPrefab(TargetPrefab[n]);
						if (!Object.op_Implicit((Object)(object)prefab4.GetComponent<ItemDrop>()))
						{
							return false;
						}
						LocalizedTarget[n] = Localization.instance.Localize(prefab4.GetComponent<ItemDrop>().m_itemData.m_shared.m_name);
					}
					return true;
				}
				if (Type == QuestType.Kill)
				{
					for (int num = 0; num < TargetAmount; num++)
					{
						GameObject prefab5 = ZNetScene.instance.GetPrefab(TargetPrefab[num]);
						if (!Object.op_Implicit((Object)(object)prefab5.GetComponent<Character>()))
						{
							return false;
						}
						PhotoManager.__instance.MakeSprite(prefab5, TargetLevel[num]);
						LocalizedTarget[num] = Localization.instance.Localize(prefab5.GetComponent<Character>().m_name);
					}
					return true;
				}
				if (Type == QuestType.Harvest)
				{
					for (int num2 = 0; num2 < TargetAmount; num2++)
					{
						GameObject prefab6 = ZNetScene.instance.GetPrefab(TargetPrefab[num2]);
						if (!Object.op_Implicit((Object)(object)prefab6.GetComponent<Pickable>()))
						{
							return false;
						}
						PhotoManager.__instance.MakeSprite(prefab6);
						LocalizedTarget[num2] = Localization.instance.Localize(prefab6.GetComponent<Pickable>().GetHoverName());
					}
					return true;
				}
				if (Type == QuestType.Move)
				{
					Vector2 val = default(Vector2);
					for (int num3 = 0; num3 < TargetAmount; num3++)
					{
						string[] array2 = TargetPrefab[num3].Split(new char[1] { ',' });
						if (array2.Length < 4)
						{
							return false;
						}
						((Vector2)(ref val))..ctor(float.Parse(array2[0]), float.Parse(array2[1]));
						float num4 = float.Parse(array2[2]);
						string text2 = array2[3].Trim();
						LocalizedTarget[num3] = ("<color=yellow>" + text2 + "</color>").Localize();
					}
					return true;
				}
				if (Type == QuestType.Build)
				{
					for (int num5 = 0; num5 < TargetAmount; num5++)
					{
						GameObject prefab7 = ZNetScene.instance.GetPrefab(TargetPrefab[num5]);
						if (!Object.op_Implicit((Object)(object)prefab7.GetComponent<Piece>()))
						{
							return false;
						}
						LocalizedTarget[num5] = Localization.instance.Localize(prefab7.GetComponent<Piece>().m_name);
					}
					return true;
				}
				return false;
			}

			public string GetLocalizedReward(int index)
			{
				return LocalizedReward[index];
			}

			public string GetLocalizedTarget(int index)
			{
				return LocalizedTarget[index];
			}

			public static bool CanTake(int UID, out string message, out Dialogues_DataTypes.OptionCondition type)
			{
				message = "";
				type = Dialogues_DataTypes.OptionCondition.None;
				if (!AllQuests.ContainsKey(UID) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return false;
				}
				Quest quest = AllQuests[UID];
				if (quest.Condition == null)
				{
					return true;
				}
				foreach (Dialogues_DataTypes.Dialogue_Condition item in quest.Condition.GetInvocationList().Cast<Dialogues_DataTypes.Dialogue_Condition>())
				{
					if (!item(null, out message, out type))
					{
						return false;
					}
				}
				return true;
			}

			public static bool IsAccepted(int UID)
			{
				return AcceptedQuests.ContainsKey(UID);
			}

			public static bool IsOnCooldown(int UID, out int left)
			{
				left = 0;
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return true;
				}
				string key = "[MPASN]questCD=" + UID;
				if (!Player.m_localPlayer.m_customData.ContainsKey(key))
				{
					return false;
				}
				int num = Convert.ToInt32(Player.m_localPlayer.m_customData[key]);
				left = num + AllQuests[UID].Cooldown - EnvMan.instance.GetCurrentDay();
				return left > 0;
			}

			public static void AcceptQuest(int UID, string score = "0", string acceptedTime = null, bool handleEvent = true)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !AcceptedQuests.ContainsKey(UID) && AllQuests.ContainsKey(UID))
				{
					AcceptedQuests[UID] = AllQuests[UID];
					AcceptedQuests[UID].ScoreArray = new int[AcceptedQuests[UID].TargetAmount];
					string[] array = score.Split(new char[1] { ',' });
					for (int i = 0; i < array.Length && i < AcceptedQuests[UID].ScoreArray.Length; i++)
					{
						AcceptedQuests[UID].ScoreArray[i] = Convert.ToInt32(array[i]);
					}
					AcceptedQuests[UID].AcceptedTime = ((acceptedTime == null) ? ((long)EnvMan.instance.m_totalSeconds) : Convert.ToInt64(acceptedTime));
					if (handleEvent)
					{
						HandleQuestEvent(UID, QuestEventCondition.OnAcceptQuest);
					}
					InventoryChanged();
					SaveScore(UID);
				}
			}

			private static void SaveScore(int UID)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && AcceptedQuests.ContainsKey(UID))
				{
					string key = "[MPASN]quest=" + UID;
					string text = AcceptedQuests[UID].ScoreArray.Aggregate("", (string current, int i) => current + i + ",").TrimEnd(new char[1] { ',' });
					text = text + ";" + AcceptedQuests[UID].AcceptedTime;
					Player.m_localPlayer.m_customData[key] = text;
					Quests_UIs.AcceptedQuestsUI.UpdateStatus(AcceptedQuests[UID]);
				}
			}

			public static void RemoveQuestComplete(int UID)
			{
				//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b7: Expected O, but got Unknown
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !AcceptedQuests.ContainsKey(UID))
				{
					return;
				}
				Quest quest = AcceptedQuests[UID];
				if (quest.Type == QuestType.Collect)
				{
					for (int i = 0; i < quest.TargetAmount; i++)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab(quest.TargetPrefab[i]);
						if (Utils.CustomCountItems(((Object)prefab).name, quest.TargetLevel[i]) < quest.TargetCount[i])
						{
							return;
						}
					}
					AcceptedQuests.Remove(UID);
					for (int j = 0; j < quest.TargetAmount; j++)
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab(quest.TargetPrefab[j]);
						Utils.CustomRemoveItems(((Object)prefab2).name, quest.TargetCount[j], quest.TargetLevel[j]);
					}
				}
				else
				{
					AcceptedQuests.Remove(UID);
				}
				for (int k = 0; k < quest.RewardsAmount; k++)
				{
					if (quest.RewardType[k] == QuestRewardType.EpicMMO_EXP)
					{
						EpicMMOSystem_API.AddExp(quest.RewardCount[k]);
					}
					else if (quest.RewardType[k] == QuestRewardType.Cozyheim_EXP)
					{
						Cozyheim_LevelingSystem.AddExp(quest.RewardCount[k]);
					}
					else
					{
						if (quest.RewardType[k] == QuestRewardType.GuildAddLevel)
						{
							continue;
						}
						if (quest.RewardType[k] == QuestRewardType.AddCustomValue)
						{
							Player.m_localPlayer.AddCustomValue(quest.RewardPrefab[k], quest.RewardCount[k]);
							continue;
						}
						if (quest.RewardType[k] == QuestRewardType.SetCustomValue)
						{
							if (quest.RewardCount[k] != 0)
							{
								Player.m_localPlayer.SetCustomValue(quest.RewardPrefab[k], quest.RewardCount[k]);
							}
							else
							{
								Player.m_localPlayer.RemoveCustomValue(quest.RewardPrefab[k]);
							}
							continue;
						}
						if (quest.RewardType[k] == QuestRewardType.Battlepass_EXP)
						{
							int num = quest.RewardCount[k];
							Type type = System.Type.GetType("UL_B.Battlepass_Main_Client, UL_B");
							if (type != null)
							{
								MethodInfo methodInfo = AccessTools.Method(type, "AddExp", (Type[])null, (Type[])null);
								if (methodInfo != null)
								{
									methodInfo.Invoke(null, new object[1] { num });
								}
							}
							continue;
						}
						if (quest.RewardType[k] == QuestRewardType.RustyClasses_EXP)
						{
							RustyClassesAPI.AddEXP(quest.RewardCount[k]);
							continue;
						}
						QuestRewardType questRewardType = quest.RewardType[k];
						if ((questRewardType == QuestRewardType.Item || questRewardType == QuestRewardType.Pet) ? true : false)
						{
							Utils.AddItemToPlayer(ZNetScene.instance.GetPrefab(quest.RewardPrefab[k]), quest.RewardCount[k], quest.RewardLevel[k]);
						}
						if (quest.RewardType[k] == QuestRewardType.RandomItem)
						{
							string[] array = quest.RewardPrefab[k].Split(new char[1] { ',' });
							List<RandomItemEntry> list = new List<RandomItemEntry>();
							for (int l = 0; l < array.Length; l += 3)
							{
								string text = array[l];
								ItemDrop component = ZNetScene.instance.GetPrefab(text).GetComponent<ItemDrop>();
								if (Object.op_Implicit((Object)(object)component))
								{
									int amount = int.Parse(array[l + 1]);
									int level = int.Parse(array[l + 2]);
									RandomItemEntry item = new RandomItemEntry(component, amount, level);
									list.Add(item);
								}
							}
							if (list.Count == 0)
							{
								continue;
							}
							RandomItemEntry randomItemEntry = list[Random.Range(0, list.Count)];
							Utils.AddItemToPlayer(((Component)randomItemEntry.Item).gameObject, randomItemEntry.Amount, randomItemEntry.Level);
						}
						if (quest.RewardType[k] == QuestRewardType.Skill && Utils.GetPlayerSkillLevelCustom(quest.RewardPrefab[k]) > (float)((!(Marketplace.TempProfessionsType != null)) ? (-1) : 0))
						{
							((Character)Player.m_localPlayer).GetSkills().CheatRaiseSkill(quest.RewardPrefab[k], (float)quest.RewardCount[k], true);
						}
						if (quest.RewardType[k] == QuestRewardType.Skill_EXP && Utils.GetPlayerSkillLevelCustom(quest.RewardPrefab[k]) > (float)((!(Marketplace.TempProfessionsType != null)) ? (-1) : 0))
						{
							Utils.IncreaseSkillEXP(quest.RewardPrefab[k], quest.RewardCount[k]);
						}
					}
				}
				string key = "[MPASN]quest=" + UID;
				if (Player.m_localPlayer.m_customData.ContainsKey(key))
				{
					Player.m_localPlayer.m_customData.Remove(key);
				}
				string key2 = "[MPASN]questCD=" + UID;
				Player.m_localPlayer.m_customData[key2] = EnvMan.instance.GetCurrentDay().ToString();
				MessageHud.instance.ShowMessage((MessageType)2, ("<color=#00ff00>$mpasn_youfinishedquest:</color> <color=#00FFFF>" + AllQuests[UID].Name + "</color>").Localize(), 0, (Sprite)null, false);
				if (ZNet.instance.GetServerPeer() != null)
				{
					ZPackage val = new ZPackage();
					val.Write(2);
					Player localPlayer = Player.m_localPlayer;
					val.Write(((localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "LocalPlayer");
					val.Write(AllQuests[UID].Name);
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "KGmarket CustomWebhooks", new object[1] { val });
				}
				HandleQuestEvent(UID, QuestEventCondition.OnCompleteQuest);
			}

			public static void RemoveQuestFailed(int UID, QuestEventCondition? condition)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && AcceptedQuests.ContainsKey(UID))
				{
					AcceptedQuests.Remove(UID);
					string key = "[MPASN]quest=" + UID;
					if (Player.m_localPlayer.m_customData.ContainsKey(key))
					{
						Player.m_localPlayer.m_customData.Remove(key);
					}
					if (condition.HasValue)
					{
						HandleQuestEvent(UID, condition.Value);
					}
				}
			}

			public static void ClickQuestButton(int UID)
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !AllQuests.ContainsKey(UID))
				{
					return;
				}
				AssetStorage.AUsrc.Play();
				if (IsOnCooldown(UID, out var left))
				{
					MessageHud.instance.ShowMessage((MessageType)2, string.Format("<color=#00ff00>{0}</color> {1}", left, Localization.instance.Localize("$mpasn_daysleft")), 0, (Sprite)null, false);
				}
				else if (!IsAccepted(UID))
				{
					if (AcceptedQuests.Count < Global_Configs.SyncedGlobalOptions.Value._maxAcceptedQuests)
					{
						if (!CanTake(UID, out string message, out Dialogues_DataTypes.OptionCondition _))
						{
							MessageHud.instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false);
							Quests_UIs.QuestUI.Hide();
						}
						else
						{
							AcceptQuest(UID);
							Quests_UIs.AcceptedQuestsUI.CheckQuests();
						}
					}
				}
				else if (AcceptedQuests[UID].IsComplete())
				{
					RemoveQuestComplete(UID);
					Quests_UIs.AcceptedQuestsUI.CheckQuests();
				}
				else
				{
					RemoveQuestFailed(UID, QuestEventCondition.OnCancelQuest);
					Quests_UIs.AcceptedQuestsUI.CheckQuests();
				}
			}

			public static void TryAddRewardKill(string prefab, int level)
			{
				HashSet<int> hashSet = new HashSet<int>();
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Kill && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefab && level >= item.Value.TargetLevel[i])
						{
							item.Value.ScoreArray[i]++;
							SaveScore(item.Key);
							CheckCharacterTargets();
							if (item.Value.SpecialTag.HasFlagFast(SpecialQuestTag.Autocomplete) && item.Value.IsComplete())
							{
								hashSet.Add(item.Key);
							}
							if (!Global_Configs.SyncedGlobalOptions.Value._allowMultipleQuestScore)
							{
								break;
							}
						}
					}
				}
				if (hashSet.Count <= 0)
				{
					return;
				}
				foreach (int item2 in hashSet)
				{
					RemoveQuestComplete(item2);
				}
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}

			public static void TryAddRewardMove(Vector3 position)
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				HashSet<int> hashSet = new HashSet<int>();
				Vector2 val = default(Vector2);
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Move && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (item.Value.IsComplete(i))
						{
							continue;
						}
						string[] array = item.Value.TargetPrefab[i].Split(new char[1] { ',' });
						if (array.Length < 4)
						{
							continue;
						}
						((Vector2)(ref val))..ctor(float.Parse(array[0]), float.Parse(array[1]));
						float num = float.Parse(array[2]);
						if (Vector2.Distance(new Vector2(position.x, position.z), val) <= num)
						{
							item.Value.ScoreArray[i]++;
							SaveScore(item.Key);
							if (item.Value.SpecialTag.HasFlagFast(SpecialQuestTag.Autocomplete) && item.Value.IsComplete())
							{
								hashSet.Add(item.Key);
							}
							if (!Global_Configs.SyncedGlobalOptions.Value._allowMultipleQuestScore)
							{
								break;
							}
						}
					}
				}
				if (hashSet.Count <= 0)
				{
					return;
				}
				foreach (int item2 in hashSet)
				{
					RemoveQuestComplete(item2);
				}
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}

			public static bool IsQuestTarget(string NPCName)
			{
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Talk && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == NPCName)
						{
							return true;
						}
					}
				}
				return false;
			}

			public static bool HasQuests(Market_NPC.NPCcomponent npc)
			{
				string message;
				Dialogues_DataTypes.OptionCondition type;
				int left;
				if (npc._currentNpcType == Market_NPC.NPCType.Quests && SyncedQuestProfiles.Value.TryGetValue(npc.znv.m_zdo.GET_NPC_Profile(), out List<int> value))
				{
					return value.Any((int quest) => CanTake(quest, out message, out type) && !IsAccepted(quest) && !IsOnCooldown(quest, out left));
				}
				return false;
			}

			public static bool IsQuestTarget(Character c)
			{
				string prefabName = Utils.GetPrefabName(((Component)c).gameObject);
				int level = c.GetLevel();
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Kill && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefabName && level >= item.Value.TargetLevel[i])
						{
							return true;
						}
					}
				}
				return false;
			}

			public static bool IsQuestTarget(Recipe c, int level)
			{
				string name = ((Object)((Component)c.m_item).gameObject).name;
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Craft && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == name && level == item.Value.TargetLevel[i])
						{
							return true;
						}
					}
				}
				return false;
			}

			public static void CheckCharacterTargets()
			{
				foreach (Character allCharacter in Character.GetAllCharacters())
				{
					Transform obj = ((Component)allCharacter).transform.Find("MPASNquest");
					if (obj != null)
					{
						((Component)obj).gameObject.SetActive(IsQuestTarget(allCharacter));
					}
				}
			}

			public static void CheckItemDropsTargets()
			{
				foreach (ItemDrop s_instance in ItemDrop.s_instances)
				{
					Transform obj = ((Component)s_instance).transform.Find("MPASNquest");
					if (obj != null)
					{
						((Component)obj).gameObject.SetActive(IsQuestTarget(s_instance));
					}
				}
			}

			public static void CheckTalkTargets()
			{
				foreach (Market_NPC.NPCcomponent item in Market_NPC.NPCcomponent.ALL)
				{
					if (IsQuestTarget(item.GetNPCName()))
					{
						((Component)((Component)item).transform.Find("MPASNquest")).gameObject.SetActive(true);
						((Component)((Component)item).transform.Find("MPASNHasQuests")).gameObject.SetActive(false);
					}
					else
					{
						((Component)((Component)item).transform.Find("MPASNquest")).gameObject.SetActive(false);
						((Component)((Component)item).transform.Find("MPASNHasQuests")).gameObject.SetActive(HasQuests(item));
					}
				}
			}

			public static void CheckPickableTargets()
			{
				foreach (Pickable pickable in Quest_ProgressionHook.Pickable_Hook.GetPickables())
				{
					if (Object.op_Implicit((Object)(object)pickable))
					{
						Transform obj = ((Component)pickable).transform.Find("MPASNquest");
						if (obj != null)
						{
							((Component)obj).gameObject.SetActive(IsQuestTarget(pickable));
						}
					}
				}
			}

			public static bool IsQuestTarget(Pickable itemDrop)
			{
				string prefabName = Utils.GetPrefabName(((Component)itemDrop).gameObject);
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Harvest && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefabName)
						{
							return true;
						}
					}
				}
				return false;
			}

			public static bool IsQuestTarget(ItemDrop itemDrop)
			{
				string prefabName = Utils.GetPrefabName(((Component)itemDrop).gameObject);
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Collect && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefabName && itemDrop.m_itemData.m_quality == item.Value.TargetLevel[i])
						{
							return true;
						}
					}
				}
				return false;
			}

			public static bool IsQuestTarget(Piece piece)
			{
				string name = ((Object)((Component)piece).gameObject).name;
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Build && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == name)
						{
							return true;
						}
					}
				}
				return false;
			}

			public static void TryAddRewardCraft(string prefab, int level)
			{
				HashSet<int> hashSet = new HashSet<int>();
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Craft && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefab && level == item.Value.TargetLevel[i])
						{
							item.Value.ScoreArray[i]++;
							SaveScore(item.Key);
							if (item.Value.SpecialTag.HasFlagFast(SpecialQuestTag.Autocomplete) && item.Value.IsComplete())
							{
								hashSet.Add(item.Key);
							}
							if (!Global_Configs.SyncedGlobalOptions.Value._allowMultipleQuestScore)
							{
								break;
							}
						}
					}
				}
				if (hashSet.Count <= 0)
				{
					return;
				}
				foreach (int item2 in hashSet)
				{
					RemoveQuestComplete(item2);
				}
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}

			public static bool TryAddRewardBuild(string prefab)
			{
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Build && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefab)
						{
							item.Value.ScoreArray[i]++;
							SaveScore(item.Key);
							if (item.Value.SpecialTag.HasFlagFast(SpecialQuestTag.Autocomplete) && item.Value.IsComplete())
							{
								RemoveQuestComplete(item.Key);
								Quests_UIs.AcceptedQuestsUI.CheckQuests();
							}
							return true;
						}
					}
				}
				return false;
			}

			public static bool TryAddRewardTalk(string name)
			{
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Talk && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == name)
						{
							item.Value.ScoreArray[i] = 1;
							if (item.Value.IsComplete())
							{
								RemoveQuestComplete(item.Key);
							}
							return true;
						}
					}
				}
				return false;
			}

			public static void TryAddRewardPickup(string prefab)
			{
				HashSet<int> hashSet = new HashSet<int>();
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> q) => q.Value.Type == QuestType.Harvest && !q.Value.IsComplete()))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						if (!item.Value.IsComplete(i) && item.Value.TargetPrefab[i] == prefab)
						{
							item.Value.ScoreArray[i]++;
							SaveScore(item.Key);
							CheckPickableTargets();
							if (item.Value.SpecialTag.HasFlagFast(SpecialQuestTag.Autocomplete) && item.Value.IsComplete())
							{
								hashSet.Add(item.Key);
							}
							if (!Global_Configs.SyncedGlobalOptions.Value._allowMultipleQuestScore)
							{
								break;
							}
						}
					}
				}
				if (hashSet.Count <= 0)
				{
					return;
				}
				foreach (int item2 in hashSet)
				{
					RemoveQuestComplete(item2);
				}
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}

			public static void InventoryChanged()
			{
				HashSet<int> hashSet = new HashSet<int>();
				foreach (KeyValuePair<int, Quest> item in AcceptedQuests.Where<KeyValuePair<int, Quest>>((KeyValuePair<int, Quest> t) => t.Value.Type == QuestType.Collect))
				{
					for (int i = 0; i < item.Value.TargetAmount; i++)
					{
						item.Value.ScoreArray[i] = Utils.CustomCountItems(item.Value.TargetPrefab[i], item.Value.TargetLevel[i]);
						SaveScore(item.Key);
						CheckItemDropsTargets();
						if (item.Value.SpecialTag.HasFlagFast(SpecialQuestTag.Autocomplete) && item.Value.IsComplete())
						{
							hashSet.Add(item.Key);
						}
					}
				}
				if (hashSet.Count <= 0)
				{
					return;
				}
				foreach (int item2 in hashSet)
				{
					RemoveQuestComplete(item2);
				}
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}
		}

		internal static readonly CustomSyncedValue<int> SyncedQuestRevision = new CustomSyncedValue<int>(Marketplace.configSync, "questRevision", 0, 100);

		internal static readonly CustomSyncedValue<Dictionary<int, Quest>> SyncedQuestData = new CustomSyncedValue<Dictionary<int, Quest>>(Marketplace.configSync, "questData", new Dictionary<int, Quest>());

		internal static readonly CustomSyncedValue<Dictionary<string, List<int>>> SyncedQuestProfiles = new CustomSyncedValue<Dictionary<string, List<int>>>(Marketplace.configSync, "questProfiles", new Dictionary<string, List<int>>());

		internal static readonly CustomSyncedValue<Dictionary<int, QuestEvent>> SyncedQuestsEvents = new CustomSyncedValue<Dictionary<int, QuestEvent>>(Marketplace.configSync, "questEvents", new Dictionary<int, QuestEvent>());

		public static readonly Dictionary<int, Quest> AllQuests = new Dictionary<int, Quest>();

		public static readonly Dictionary<int, Quest> AcceptedQuests = new Dictionary<int, Quest>(20);

		public static readonly Dictionary<int, HashSet<int>> TransferComplitionQuests = new Dictionary<int, HashSet<int>>();

		public static void HandleQuestEvent(int UID, QuestEventCondition type)
		{
			if (SyncedQuestsEvents.Value.TryGetValue(UID, out QuestEvent value))
			{
				switch (type)
				{
				case QuestEventCondition.OnAcceptQuest:
					value.OnAcceptQuest?.Invoke(null);
					break;
				case QuestEventCondition.OnCancelQuest:
					value.OnCancelQuest?.Invoke(null);
					break;
				case QuestEventCondition.OnCompleteQuest:
					value.OnCompleteQuest?.Invoke(null);
					break;
				case QuestEventCondition.OnQuestTimeout:
					value.OnQuestTimeout?.Invoke(null);
					break;
				case QuestEventCondition.OnDeath:
					value.OnDeath?.Invoke(null);
					break;
				}
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Quests_Main_Client
	{
		[HarmonyPatch(typeof(Game), "Awake")]
		private static class Game_Awake_Patch
		{
			private static void Postfix()
			{
				_moveQuestcounter = 3f;
				_questMovePins.Clear();
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		[ClientOnlyPatch]
		private static class Quest_Main_LoadPatch
		{
			private static void ClearEmptyQuestCooldowns()
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>();
				foreach (KeyValuePair<string, string> customDatum in Player.m_localPlayer.m_customData)
				{
					if (customDatum.Key.Contains("[MPASN]questCD="))
					{
						int num = Convert.ToInt32(customDatum.Key.Split(new char[1] { '=' })[1]);
						if (!Quests_DataTypes.AllQuests.ContainsKey(num) || !Quests_DataTypes.Quest.IsOnCooldown(num, out var _))
						{
							hashSet.Add(customDatum.Key);
						}
					}
					if (customDatum.Key.Contains("[MPASN]quest="))
					{
						int key = Convert.ToInt32(customDatum.Key.Split(new char[1] { '=' })[1]);
						if (!Quests_DataTypes.AllQuests.ContainsKey(key))
						{
							hashSet.Add(customDatum.Key);
						}
					}
				}
				foreach (string item in hashSet)
				{
					Player.m_localPlayer.m_customData.Remove(item);
				}
			}

			private static void LoadQuests()
			{
				Quests_DataTypes.AcceptedQuests.Clear();
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return;
				}
				Dictionary<int, string> dictionary = new Dictionary<int, string>();
				foreach (KeyValuePair<string, string> customDatum in Player.m_localPlayer.m_customData)
				{
					if (customDatum.Key.Contains("[MPASN]quest="))
					{
						int key = Convert.ToInt32(customDatum.Key.Split(new char[1] { '=' })[1]);
						dictionary[key] = customDatum.Value;
					}
				}
				foreach (KeyValuePair<int, string> item in dictionary)
				{
					string[] array = item.Value.Split(new char[1] { ';' });
					string score = array[0];
					string acceptedTime = ((array.Length > 1) ? array[1] : null);
					Quests_DataTypes.Quest.AcceptQuest(item.Key, score, acceptedTime, handleEvent: false);
				}
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}

			private static void InitRawQuests()
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || Quests_DataTypes.SyncedQuestData.Value.Count == 0 || LatestRevision == Quests_DataTypes.SyncedQuestRevision.Value)
				{
					return;
				}
				LatestRevision = Quests_DataTypes.SyncedQuestRevision.Value;
				foreach (KeyValuePair<int, Quests_DataTypes.Quest> item in Quests_DataTypes.SyncedQuestData.Value)
				{
					if (item.Value.Init())
					{
						Quests_DataTypes.AllQuests[item.Key] = item.Value;
						int transferComplition = item.Value.TransferComplition;
						if (transferComplition != 0)
						{
							if (!Quests_DataTypes.TransferComplitionQuests.ContainsKey(transferComplition))
							{
								Quests_DataTypes.TransferComplitionQuests[transferComplition] = new HashSet<int>();
							}
							Quests_DataTypes.TransferComplitionQuests[transferComplition].Add(item.Key);
						}
					}
					else
					{
						Utils.print($"{item.Value.Name} (id {item.Key}) can't finish init");
					}
				}
				foreach (KeyValuePair<Quests_DataTypes.Quest, string> url in Quests_DataTypes.AllQuests.Select<KeyValuePair<int, Quests_DataTypes.Quest>, KeyValuePair<Quests_DataTypes.Quest, string>>((KeyValuePair<int, Quests_DataTypes.Quest> x) => new KeyValuePair<Quests_DataTypes.Quest, string>(x.Value, x.Value.PreviewImage)))
				{
					if (!string.IsNullOrWhiteSpace(url.Value))
					{
						Utils.LoadImageFromWEB(url.Value, delegate(Sprite sprite)
						{
							url.Key.SetPreviewSprite(sprite);
						}, "InitRawQuests");
					}
				}
			}

			public static void Postfix()
			{
				InitRawQuests();
				ClearEmptyQuestCooldowns();
				LoadQuests();
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private class CloseUIMenuLogout
		{
			private static void Postfix()
			{
				Quests_UIs.AcceptedQuestsUI.Hide();
				LatestRevision = int.MaxValue;
			}
		}

		private static ConfigEntry<KeyCode> QuestJournalOpenKey;

		private static int LatestRevision;

		public static ConfigEntry<bool> ShowQuestMark;

		private static Sprite MoveQuestPin;

		private static float _moveQuestcounter = 3f;

		private static readonly Dictionary<int, List<PinData>> _questMovePins = new Dictionary<int, List<PinData>>();

		private const PinType _questMovePinType = 191;

		private static void OnInit()
		{
			MoveQuestPin = AssetStorage.asset.LoadAsset<Sprite>("CircleQuestMove");
			QuestJournalOpenKey = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<KeyCode>("General", "Quest Journal Keycode", (KeyCode)106, (ConfigDescription)null);
			ShowQuestMark = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("General", "Show Quest Mark", true, (ConfigDescription)null);
			Quests_UIs.QuestUI.Init();
			Quests_UIs.AcceptedQuestsUI.Init();
			Quests_DataTypes.SyncedQuestData.ValueChanged += OnQuestDataUpdate;
			Quests_DataTypes.SyncedQuestProfiles.ValueChanged += OnQuestProfilesUpdate;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
			GameEvents.OnPlayerFirstSpawn = (Action)Delegate.Combine(GameEvents.OnPlayerFirstSpawn, new Action(OnPlayerFirstSpawn));
			GameEvents.OnPlayerDeath = (Action)Delegate.Combine(GameEvents.OnPlayerDeath, new Action(OnPlayerDeath));
		}

		private static void OnPlayerDeath()
		{
			foreach (KeyValuePair<int, Quests_DataTypes.Quest> item in Quests_DataTypes.AcceptedQuests.ToList())
			{
				Quests_DataTypes.HandleQuestEvent(item.Key, Quests_DataTypes.QuestEventCondition.OnDeath);
			}
		}

		private static void OnPlayerFirstSpawn()
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode("onplayerfirstspawn");
			if (Quests_DataTypes.AllQuests.TryGetValue(stableHashCode, out Quests_DataTypes.Quest _) && !Quests_DataTypes.Quest.IsOnCooldown(stableHashCode, out var _) && !Quests_DataTypes.Quest.IsAccepted(stableHashCode))
			{
				Quests_DataTypes.Quest.AcceptQuest(stableHashCode);
				Quests_UIs.AcceptedQuestsUI.CheckQuests();
			}
		}

		private static void OnQuestDataUpdate()
		{
			if (Object.op_Implicit((Object)(object)Game.instance) && !Game.instance.m_shuttingDown)
			{
				Quests_DataTypes.AllQuests.Clear();
				Quests_DataTypes.TransferComplitionQuests.Clear();
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Quest_Main_LoadPatch.Postfix();
					Quests_UIs.QuestUI.Reload();
					CreatePins(forceRestart: true);
				}
			}
		}

		private static void OnQuestProfilesUpdate()
		{
			if (Object.op_Implicit((Object)(object)Game.instance) && !Game.instance.m_shuttingDown)
			{
				Quests_UIs.QuestUI.Reload();
			}
		}

		private static void Update(float dt)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				_moveQuestcounter -= dt;
				if (Object.op_Implicit((Object)(object)Minimap.instance) && _moveQuestcounter <= 0f)
				{
					_moveQuestcounter = 3f;
					Quests_DataTypes.Quest.TryAddRewardMove(((Component)Player.m_localPlayer).transform.position);
					CreatePins(forceRestart: false);
				}
			}
			if (Input.GetKeyDown((KeyCode)27) && Quests_UIs.QuestUI.IsVisible())
			{
				Quests_UIs.QuestUI.Hide();
				Menu.instance.OnClose();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Input.GetKeyDown(QuestJournalOpenKey.Value) && ((Character)Player.m_localPlayer).TakeInput())
			{
				Quests_UIs.QuestUI.ClickJournal();
			}
		}

		private static void CreatePins(bool forceRestart)
		{
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			if (forceRestart)
			{
				foreach (KeyValuePair<int, List<PinData>> questMovePin in _questMovePins)
				{
					foreach (PinData item in questMovePin.Value)
					{
						Minimap.instance.RemovePin(item);
					}
				}
				_questMovePins.Clear();
			}
			else
			{
				int[] array = _questMovePins.Keys.ToArray();
				int[] array2 = array;
				foreach (int key in array2)
				{
					if (!Quests_DataTypes.AcceptedQuests.ContainsKey(key))
					{
						for (int j = 0; j < _questMovePins[key].Count; j++)
						{
							PinData val = _questMovePins[key][j];
							Minimap.instance.RemovePin(val);
						}
						_questMovePins.Remove(key);
					}
				}
			}
			foreach (KeyValuePair<int, Quests_DataTypes.Quest> acceptedQuest in Quests_DataTypes.AcceptedQuests)
			{
				if (_questMovePins.ContainsKey(acceptedQuest.Key) || acceptedQuest.Value.Type != Quests_DataTypes.QuestType.Move)
				{
					continue;
				}
				List<PinData> list = new List<PinData>(acceptedQuest.Value.TargetPrefab.Length);
				for (int k = 0; k < acceptedQuest.Value.TargetPrefab.Length; k++)
				{
					if (acceptedQuest.Value.TargetLevel[k] == 0)
					{
						continue;
					}
					string[] array3 = acceptedQuest.Value.TargetPrefab[k].Split(new char[1] { ',' });
					if (array3.Length >= 4)
					{
						float num = float.Parse(array3[0]);
						float num2 = float.Parse(array3[1]);
						float num3 = float.Parse(array3[2]);
						string text = array3[3];
						PinData val2 = new PinData
						{
							m_type = (PinType)191,
							m_pos = new Vector3(num, 0f, num2),
							m_name = "<color=yellow>" + text + "</color>",
							m_icon = MoveQuestPin,
							m_save = false,
							m_checked = false,
							m_ownerID = 0L,
							m_worldSize = num3 * 2f
						};
						if (!string.IsNullOrEmpty(val2.m_name))
						{
							val2.m_NamePinData = new PinNameData(val2);
						}
						list.Add(val2);
					}
				}
				_questMovePins[acceptedQuest.Key] = list;
				Minimap.instance.m_pins.AddRange(list);
			}
			Minimap.instance.m_pinUpdateRequired = true;
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "QP", "QD", "QE" }, new string[] { "OnQuestsProfilesFileChange", "OnQuestDatabaseFileChange", "OnQuestsEventFileChange" })]
	public static class Quests_Main_Server
	{
		[CompilerGenerated]
		private sealed class <DelayMore>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ReadQuestDatabase();
					Utils.print("Quests Database Changed. Sending new info to all clients");
					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();
			}
		}

		private static void OnInit()
		{
			ReadQuestProfiles();
			ReadQuestDatabase();
			ReadEventDatabase();
		}

		private static void OnQuestsProfilesFileChange()
		{
			ReadQuestProfiles();
			Utils.print("Quests Profiles Changed. Sending new info to all clients");
		}

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

		private static void OnQuestDatabaseFileChange()
		{
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(DelayMore());
		}

		private static void OnQuestsEventFileChange()
		{
			ReadEventDatabase();
			Utils.print("Quests Events Changed. Sending new info to all clients");
		}

		private static void ProcessQuestProfiles(IReadOnlyList<string> profiles)
		{
			string key = "default";
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					key = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					continue;
				}
				string[] array = profiles[i].Replace(" ", "").Split(new char[1] { ',' }).Distinct()
					.ToArray();
				if (!Quests_DataTypes.SyncedQuestProfiles.Value.ContainsKey(key))
				{
					Quests_DataTypes.SyncedQuestProfiles.Value.Add(key, new List<int>());
				}
				string[] array2 = array;
				foreach (string text in array2)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(text.ToLower());
					Quests_DataTypes.SyncedQuestProfiles.Value[key].Add(stableHashCode);
				}
			}
		}

		private static void ReadQuestProfiles()
		{
			Quests_DataTypes.SyncedQuestProfiles.Value.Clear();
			string questsProfilesFolder = Market_Paths.QuestsProfilesFolder;
			string[] files = Directory.GetFiles(questsProfilesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string path in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(path).ToList();
				ProcessQuestProfiles(profiles);
			}
			Quests_DataTypes.SyncedQuestProfiles.Update();
		}

		private static void ProcessQuestDatabaseProfiles(string fPath, IReadOnlyList<string> profiles)
		{
			if (profiles.Count == 0)
			{
				return;
			}
			string text = null;
			Quests_DataTypes.SpecialQuestTag specialQuestTag = Quests_DataTypes.SpecialQuestTag.None;
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					text = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					string[] array = text.Split(new char[1] { '=' });
					if (array.Length == 2)
					{
						if (Enum.TryParse<Quests_DataTypes.SpecialQuestTag>(array[1], ignoreCase: true, out var result))
						{
							specialQuestTag |= result;
							text = array[0];
						}
					}
					else
					{
						specialQuestTag = Quests_DataTypes.SpecialQuestTag.None;
					}
				}
				else
				{
					if (text == null)
					{
						continue;
					}
					try
					{
						int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
						string value = profiles[i];
						string text2 = profiles[i + 1];
						string previewImage = "";
						int num = text2.IndexOf("<image=", StringComparison.Ordinal);
						if (num != -1)
						{
							int num2 = text2.IndexOf(">", num, StringComparison.Ordinal);
							if (num2 != -1)
							{
								previewImage = text2.Substring(num + 7, num2 - num - 7);
								text2 = text2.Remove(num, num2 - num + 1);
							}
						}
						string description = profiles[i + 2];
						string text3 = profiles[i + 3];
						string text4 = profiles[i + 4];
						string[] array2 = profiles[i + 5].Replace(" ", "").Split(new char[1] { ',' });
						string s = array2[0];
						string s2 = ((array2.Length > 1) ? array2[1] : "0");
						string input = profiles[i + 6];
						if (!Enum.TryParse<Quests_DataTypes.QuestType>(value, ignoreCase: true, out var result2) || !Enum.IsDefined(typeof(Quests_DataTypes.QuestType), result2))
						{
							text = null;
							continue;
						}
						string[] array3 = text4.Replace(" ", "").Split(new char[1] { '|' });
						int num3 = Mathf.Max(1, array3.Length);
						Quests_DataTypes.QuestRewardType[] array4 = new Quests_DataTypes.QuestRewardType[num3];
						string[] array5 = new string[num3];
						int[] array6 = new int[num3];
						int[] array7 = new int[num3];
						for (int j = 0; j < num3; j++)
						{
							string[] array8 = array3[j].Split(new char[1] { ':' });
							if (!Enum.TryParse<Quests_DataTypes.QuestRewardType>(array8[0], ignoreCase: true, out array4[j]))
							{
								Utils.print("Failed to parse reward type " + array3[j] + " in quest " + text2 + " (File: " + fPath + "). Skipping quest");
								continue;
							}
							string[] array9 = array8[1].Split(new char[1] { ',' });
							Quests_DataTypes.QuestRewardType questRewardType = array4[j];
							if (((uint)(questRewardType - 5) <= 3u || questRewardType == Quests_DataTypes.QuestRewardType.RustyClasses_EXP) ? true : false)
							{
								array5[j] = "NONE";
								array7[j] = int.Parse(array9[0]);
								array6[j] = 1;
							}
							else if (array4[j] == Quests_DataTypes.QuestRewardType.RandomItem)
							{
								array5[j] = array8[1];
								array7[j] = 0;
								array6[j] = 0;
							}
							else
							{
								array5[j] = array9[0];
								array7[j] = int.Parse(array9[1]);
								array6[j] = 1;
							}
							if (array9.Length >= 3)
							{
								array6[j] = Convert.ToInt32(array9[2]);
								if (array4[j] == Quests_DataTypes.QuestRewardType.Pet)
								{
									array6[j]++;
								}
							}
						}
						if (result2 != Quests_DataTypes.QuestType.Talk && result2 != Quests_DataTypes.QuestType.Move)
						{
							text3 = text3.Replace(" ", "");
						}
						string[] array10 = text3.Split(new char[1] { '|' });
						int num4 = Mathf.Max(1, array10.Length);
						string[] array11 = new string[num4];
						int[] array12 = new int[num4];
						int[] array13 = new int[num4];
						for (int k = 0; k < num4; k++)
						{
							string[] array14 = array10[k].Split(new char[1] { ',' });
							array11[k] = array14[0];
							array12[k] = 1;
							array13[k] = 1;
							switch (result2)
							{
							case Quests_DataTypes.QuestType.Kill:
								if (array14.Length >= 3)
								{
									array12[k] = Mathf.Max(1, Convert.ToInt32(array14[2]) + 1);
								}
								array13[k] = Mathf.Max(1, int.Parse(array14[1]));
								break;
							case Quests_DataTypes.QuestType.Collect:
								if (array14.Length >= 3)
								{
									array12[k] = Mathf.Max(1, Convert.ToInt32(array14[2]));
								}
								array13[k] = Mathf.Max(1, int.Parse(array14[1]));
								break;
							case Quests_DataTypes.QuestType.Harvest:
							case Quests_DataTypes.QuestType.Build:
								array13[k] = Mathf.Max(1, int.Parse(array14[1]));
								break;
							case Quests_DataTypes.QuestType.Craft:
								if (array14.Length >= 3)
								{
									array12[k] = Mathf.Max(1, Convert.ToInt32(array14[2]));
								}
								array13[k] = Mathf.Max(1, int.Parse(array14[1]));
								break;
							case Quests_DataTypes.QuestType.Move:
								array11[k] = array10[k].ReplaceSpacesOutsideQuotes();
								if (array14.Length >= 5)
								{
									array12[k] = (bool.Parse(array14[4]) ? 1 : 0);
								}
								break;
							case Quests_DataTypes.QuestType.Talk:
								array11[k] = array10[k].Trim();
								break;
							}
						}
						List<string[]> list = new List<string[]>();
						string[] array15 = input.ReplaceSpacesOutsideQuotes().Split(new char[1] { '|' });
						foreach (string text5 in array15)
						{
							List<string> list2 = new List<string>();
							string[] array16 = text5.Split(new string[1] { Global_Configs.OrConditionSeparator }, StringSplitOptions.RemoveEmptyEntries);
							foreach (string text6 in array16)
							{
								if (!string.IsNullOrWhiteSpace(text6))
								{
									list2.Add(text6);
								}
							}
							list.Add(list2.ToArray());
						}
						int transferComplition = 0;
						string transferComplitionText = "";
						if (profiles.Count > i + 7)
						{
							string text7 = profiles[i + 7];
							if (!string.IsNullOrWhiteSpace(text7) && text7[0] != '[')
							{
								string[] array17 = text7.ReplaceSpacesOutsideQuotes().Split(new char[1] { ',' });
								transferComplition = StringExtensionMethods.GetStableHashCode(array17[0]);
								if (array17.Length > 1)
								{
									transferComplitionText = array17[1];
								}
							}
						}
						Quests_DataTypes.Quest value2 = new Quests_DataTypes.Quest
						{
							RewardsAmount = num3,
							Type = result2,
							RewardType = array4,
							Name = text2,
							Description = description,
							TargetAmount = num4,
							TargetPrefab = array11,
							TargetCount = array13,
							TargetLevel = array12,
							RewardPrefab = array5,
							RewardCount = array7,
							Cooldown = int.Parse(s),
							RewardLevel = array6,
							SpecialTag = specialQuestTag,
							PreviewImage = previewImage,
							TimeLimit = int.Parse(s2),
							Conditions = list,
							TransferComplition = transferComplition,
							TransferComplitionText = transferComplitionText
						};
						if (!Quests_DataTypes.SyncedQuestData.Value.ContainsKey(stableHashCode))
						{
							Quests_DataTypes.SyncedQuestData.Value.Add(stableHashCode, value2);
						}
					}
					catch (Exception arg)
					{
						Utils.print($"Error in Quests {fPath} {text}\n{arg}", ConsoleColor.Red);
					}
					text = null;
				}
			}
		}

		private static void ReadQuestDatabase()
		{
			Quests_DataTypes.SyncedQuestRevision.Value = Random.Range(int.MinValue, int.MaxValue);
			Quests_DataTypes.SyncedQuestData.Value.Clear();
			string questsDatabaseFolder = Market_Paths.QuestsDatabaseFolder;
			string[] files = Directory.GetFiles(questsDatabaseFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ProcessQuestDatabaseProfiles(text, profiles);
			}
			Quests_DataTypes.SyncedQuestData.Update();
		}

		private static void ProcessEventDatabase(IReadOnlyList<string> profiles)
		{
			string text = "default";
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					text = profiles[i].Replace("[", "").Replace("]", "").ToLower();
					continue;
				}
				string[] array = profiles[i].Split(new char[1] { ':' });
				if (array.Length < 2)
				{
					continue;
				}
				string value = array[0];
				string command = array[1].ReplaceSpacesOutsideQuotes();
				if (Enum.TryParse<Quests_DataTypes.QuestEventCondition>(value, out var result) && Enum.IsDefined(typeof(Quests_DataTypes.QuestEventCondition), result))
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
					if (!Quests_DataTypes.SyncedQuestsEvents.Value.ContainsKey(stableHashCode))
					{
						Quests_DataTypes.SyncedQuestsEvents.Value[stableHashCode] = new Quests_DataTypes.QuestEvent();
					}
					switch (result)
					{
					case Quests_DataTypes.QuestEventCondition.OnAcceptQuest:
						Quests_DataTypes.SyncedQuestsEvents.Value[stableHashCode].AddOnAcceptQuest(command);
						break;
					case Quests_DataTypes.QuestEventCondition.OnCompleteQuest:
						Quests_DataTypes.SyncedQuestsEvents.Value[stableHashCode].AddOnCompleteQuest(command);
						break;
					case Quests_DataTypes.QuestEventCondition.OnCancelQuest:
						Quests_DataTypes.SyncedQuestsEvents.Value[stableHashCode].AddOnCancelQuest(command);
						break;
					case Quests_DataTypes.QuestEventCondition.OnQuestTimeout:
						Quests_DataTypes.SyncedQuestsEvents.Value[stableHashCode].AddOnQuestTimeout(command);
						break;
					case Quests_DataTypes.QuestEventCondition.OnDeath:
						Quests_DataTypes.SyncedQuestsEvents.Value[stableHashCode].AddOnDeath(command);
						break;
					}
				}
			}
		}

		private static void ReadEventDatabase()
		{
			Quests_DataTypes.SyncedQuestsEvents.Value.Clear();
			string questsEventsFolder = Market_Paths.QuestsEventsFolder;
			string[] files = Directory.GetFiles(questsEventsFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string path in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(path).ToList();
				ProcessEventDatabase(profiles);
			}
			Quests_DataTypes.SyncedQuestsEvents.Update();
			foreach (KeyValuePair<int, Quests_DataTypes.QuestEvent> item in Quests_DataTypes.SyncedQuestsEvents.Value)
			{
				item.Value.ParseAll();
			}
		}
	}
	public static class Quests_UIs
	{
		internal static class QuestUI
		{
			[HarmonyPatch(typeof(InventoryGui), "Awake")]
			[ClientOnlyPatch]
			private static class InventoryGui_Awake_Patch
			{
				[UsedImplicitly]
				private static void Postfix(InventoryGui __instance)
				{
					UITooltip[] componentsInChildren = RewardGO.GetComponentsInChildren<UITooltip>(true);
					foreach (UITooltip val in componentsInChildren)
					{
						val.m_tooltipPrefab = __instance.m_playerGrid.m_elementPrefab.GetComponent<UITooltip>().m_tooltipPrefab;
					}
				}
			}

			[CompilerGenerated]
			private sealed class <FrameWaitShow>d__29 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0053: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					//IL_006e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0078: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						((Behaviour)((Component)DescriptionScrollbar).gameObject.GetComponent<Image>()).enabled = false;
						((Component)((Component)DescriptionScrollbar).transform.GetChild(0)).gameObject.SetActive(false);
						<>2__current = (object)new WaitForEndOfFrame();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = (object)new WaitForEndOfFrame();
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						((Behaviour)((Component)DescriptionScrollbar).gameObject.GetComponent<Image>()).enabled = true;
						((Component)((Component)DescriptionScrollbar).transform.GetChild(0)).gameObject.SetActive(true);
						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();
				}
			}

			private static GameObject UI;

			private static Transform MainTransform;

			private static GameObject QuestGO;

			private static Transform RewardTransform;

			private static GameObject RewardGO;

			private static Text Description;

			private static Image PreviewImage;

			private static Transform DescriptionTransform;

			private static GameObject QuestTarget;

			private static GameObject QuestTargetText;

			private static Button RestrictionButton;

			private static Text RestrictionText;

			private static Text NPCName;

			private static readonly List<GameObject> AllGO = new List<GameObject>();

			private static readonly List<GameObject> TOREMOVE = new List<GameObject>();

			private static readonly Dictionary<GameObject, int> QuestLink = new Dictionary<GameObject, int>();

			private static readonly List<ContentSizeFitter> AllFilters = new List<ContentSizeFitter>();

			private static Scrollbar QuestsScrollbar;

			private static Scrollbar DescriptionScrollbar;

			private static bool IsJournal;

			private static Transform TargetContent;

			private static string CurrentProfile;

			private static Coroutine LatestEnumeratorFrame;

			public static bool IsVisible()
			{
				if (Object.op_Implicit((Object)(object)UI))
				{
					return UI.activeSelf;
				}
				return false;
			}

			public static void Init()
			{
				UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("QuestHud"));
				MainTransform = UI.transform.Find("Canvas/QuestPanel/QuestList/ListPanel/Scroll View/Viewport/Content");
				QuestGO = AssetStorage.asset.LoadAsset<GameObject>("QuestListItem");
				RewardGO = AssetStorage.asset.LoadAsset<GameObject>("RewardGO");
				RewardTransform = UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Description/Scroll View/Viewport/Content/RewardsContent");
				Description = ((Component)UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Description/Scroll View/Viewport/Content/DescriptionText")).GetComponent<Text>();
				DescriptionTransform = UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Description");
				TargetContent = UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Description/Scroll View/Viewport/Content");
				RestrictionText = ((Component)UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Action/StatusPanel/StatusText")).GetComponent<Text>();
				RestrictionButton = ((Component)UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Action/StatusPanel/StatusButton")).GetComponent<Button>();
				NPCName = ((Component)UI.transform.Find("Canvas/QuestPanel/Header/Text")).GetComponent<Text>();
				Object.DontDestroyOnLoad((Object)(object)UI);
				UI.SetActive(false);
				AllFilters.AddRange(UI.GetComponentsInChildren<ContentSizeFitter>().ToList());
				DescriptionScrollbar = ((Component)UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Description/Scroll View/Scrollbar")).GetComponent<Scrollbar>();
				QuestsScrollbar = ((Component)UI.transform.Find("Canvas/QuestPanel/QuestList/ListPanel/Scroll View/Scrollbar")).GetComponent<Scrollbar>();
				PreviewImage = ((Component)UI.transform.Find("Canvas/QuestPanel/QuestInfoTab/Description/Scroll View/Viewport/Content/IMAGE")).GetComponent<Image>();
				QuestTarget = AssetStorage.asset.LoadAsset<GameObject>("QuestTarget");
				QuestTargetText = AssetStorage.asset.LoadAsset<GameObject>("QuestTargetText");
				Localization.instance.Localize(UI.transform);
			}

			private static void CLICKMAINBUTTONQUEST(Quests_DataTypes.Quest quest, int UID, int index)
			{
				Quests_DataTypes.Quest.ClickQuestButton(UID);
				if (IsVisible())
				{
					int count = AllGO.Count;
					Reload();
					int count2 = AllGO.Count;
					if (count == count2)
					{
						InitQuestData(quest, UID, index);
					}
				}
			}

			private static void ResetUIs()
			{
				Canvas.ForceUpdateCanvases();
				AllFilters.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = false;
				});
				AllFilters.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = true;
				});
				DescriptionScrollbar.value = 1f;
				QuestsScrollbar.value = 1f;
			}

			private static void InitQuestData(Quests_DataTypes.Quest quest, int UID, int index)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0fb3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0f1a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0eb0: Unknown result type (might be due to invalid IL or missing references)
				Quests_DataTypes.Quest quest2 = quest;
				((UnityEventBase)RestrictionButton.onClick).RemoveAllListeners();
				((UnityEvent)RestrictionButton.onClick).AddListener((UnityAction)delegate
				{
					CLICKMAINBUTTONQUEST(quest2, UID, index);
				});
				TOREMOVE.ForEach((Action<GameObject>)Object.Destroy);
				TOREMOVE.Clear();
				SetColors();
				((Graphic)AllGO[index].GetComponent<Image>()).color = Color.yellow;
				AssetStorage.AUsrc.Play();
				((Component)RestrictionText).gameObject.SetActive(false);
				((Component)RestrictionButton).gameObject.SetActive(false);
				((Component)DescriptionTransform).gameObject.SetActive(true);
				string text = ((quest2.TimeLimit > 0) ? ("\n<color=#B20000>" + "$mpasn_questtimelimit".Localize() + ": " + quest2.TimeLimit.ToTime() + "</color>") : "");
				Description.text = quest2.Description.Localize().Replace("\\n", "\n") + text;
				((Component)PreviewImage).gameObject.SetActive(false);
				if ((Object)(object)quest2.GetPreviewSprite != (Object)null)
				{
					((Component)PreviewImage).gameObject.SetActive(true);
					PreviewImage.sprite = quest2.GetPreviewSprite;
				}
				for (int num = quest2.TargetAmount - 1; num >= 0; num--)
				{
					Image component = ((Component)Object.Instantiate<GameObject>(QuestTarget, TargetContent).transform.Find("TargetImage")).GetComponent<Image>();
					Text component2 = Object.Instantiate<GameObject>(QuestTargetText, TargetContent).GetComponent<Text>();
					TOREMOVE.Add(((Component)((Component)component).transform.parent).gameObject);
					TOREMOVE.Add(((Component)component2).gameObject);
					((Component)component).transform.parent.SetSiblingIndex(3);
					((Component)component2).transform.SetSiblingIndex(4);
					switch (quest2.Type)
					{
					case Quests_DataTypes.QuestType.Kill:
						component2.text = string.Format("{0} {1} x{2} <color=#00ff00>{3}{4}</color>", Localization.instance.Localize("$mpasn_" + quest2.Type), quest2.GetLocalizedTarget(num), quest2.TargetCount[num], " ★", quest2.TargetLevel[num] - 1);
						break;
					case Quests_DataTypes.QuestType.Talk:
					case Quests_DataTypes.QuestType.Move:
						component2.text = Localization.instance.Localize("$mpasn_" + quest2.Type) + " " + quest2.GetLocalizedTarget(num);
						break;
					case Quests_DataTypes.QuestType.Collect:
					case Quests_DataTypes.QuestType.Craft:
					{
						string text2 = string.Format(" <color=#00ff00>{0}{1}</color>", " ★", quest2.TargetLevel[num]);
						ItemDrop component3 = ZNetScene.instance.GetPrefab(quest2.TargetPrefab[num]).GetComponent<ItemDrop>();
						if (quest2.TargetLevel[num] == 1 && component3.m_itemData.m_shared.m_maxQuality == 1)
						{
							text2 = "";
						}
						component2.text = string.Format("{0} {1} x{2}{3}", Localization.instance.Localize("$mpasn_" + quest2.Type), quest2.GetLocalizedTarget(num), quest2.TargetCount[num], text2);
						break;
					}
					default:
						component2.text = string.Format("{0} {1} x{2}", Localization.instance.Localize("$mpasn_" + quest2.Type), quest2.GetLocalizedTarget(num), quest2.TargetCount[num]);
						break;
					}
					switch (quest2.Type)
					{
					case Quests_DataTypes.QuestType.Kill:
					case Quests_DataTypes.QuestType.Harvest:
						component.sprite = PhotoManager.__instance.GetSprite(quest2.TargetPrefab[num], AssetStorage.PlaceholderMonsterIcon, quest2.TargetLevel[num]);
						break;
					case Quests_DataTypes.QuestType.Collect:
					case Quests_DataTypes.QuestType.Craft:
						component.sprite = ZNetScene.instance.GetPrefab(quest2.TargetPrefab[num]).GetComponent<ItemDrop>().m_itemData.GetIcon();
						break;
					case Quests_DataTypes.QuestType.Build:
						component.sprite = ZNetScene.instance.GetPrefab(quest2.TargetPrefab[num]).GetComponent<Piece>().m_icon;
						break;
					case Quests_DataTypes.QuestType.Talk:
						component.sprite = AssetStorage.PlaceholderGamblerIcon;
						break;
					case Quests_DataTypes.QuestType.Move:
						component.sprite = AssetStorage.MoveQuestIcon;
						break;
					}
				}
				for (int i = 0; i < quest2.RewardsAmount; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(RewardGO, RewardTransform);
					TOREMOVE.Add(val);
					Text component4 = ((Component)val.transform.Find("Text")).GetComponent<Text>();
					Image component5 = ((Component)val.transform.Find("Images/Icon")).GetComponent<Image>();
					component4.text = string.Format("{0}: {1} x{2} ", Localization.instance.Localize("$mpasn_" + quest2.RewardType[i]), quest2.GetLocalizedReward(i), quest2.RewardCount[i]);
					if (quest2.RewardType[i] == Quests_DataTypes.QuestRewardType.Pet)
					{
						component4.text += string.Format(" <color=#00ff00>{0}{1}</color>", " ★", quest2.RewardLevel[i] - 1);
					}
					else if (quest2.RewardType[i] == Quests_DataTypes.QuestRewardType.RandomItem)
					{
						component4.text = Localization.instance.Localize("$mpasn_" + quest2.RewardType[i]);
					}
					else if (quest2.RewardType[i] == Quests_DataTypes.QuestRewardType.Item && ZNetScene.instance.GetPrefab(quest2.RewardPrefab[i]).GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1)
					{
						component4.text += string.Format(" <color=#00ff00>{0}{1}</color>", " ★", quest2.RewardLevel[i]);
					}
					UITooltip componentInChildren = val.GetComponentInChildren<UITooltip>();
					componentInChildren.m_topic = "Reward";
					componentInChildren.m_text = "";
					switch (quest2.RewardType[i])
					{
					case Quests_DataTypes.QuestRewardType.Pet:
						component5.sprite = PhotoManager.__instance.GetSprite(quest2.RewardPrefab[i], AssetStorage.PlaceholderMonsterIcon, quest2.RewardLevel[i]);
						componentInChildren.m_topic = quest2.GetLocalizedReward(i) + string.Format(" <color=#00ff00>{0}{1}</color>", " ★", quest2.RewardLevel[i] - 1);
						componentInChildren.m_text = Localization.instance.Localize("$mpasn_tooltip_pet");
						break;
					case Quests_DataTypes.QuestRewardType.Item:
						component5.sprite = ZNetScene.instance.GetPrefab(quest2.RewardPrefab[i]).GetComponent<ItemDrop>().m_itemData.GetIcon();
						componentInChildren.m_topic = quest2.GetLocalizedReward(i);
						componentInChildren.m_text = ItemData.GetTooltip(ZNetScene.instance.GetPrefab(quest2.RewardPrefab[i]).GetComponent<ItemDrop>().m_itemData, quest2.RewardLevel[i], false, (float)Game.m_worldLevel, -1);
						break;
					case Quests_DataTypes.QuestRewardType.RandomItem:
					{
						component5.sprite = AssetStorage.RandomItemIcon;
						componentInChildren.m_topic = Localization.instance.Localize("$mpasn_RandomItem");
						string[] array = quest2.RewardPrefab[i].Split(new char[1] { ',' });
						string text3 = "";
						Dictionary<Quests_DataTypes.RandomItemEntry, int> dictionary = new Dictionary<Quests_DataTypes.RandomItemEntry, int>();
						for (int j = 0; j < array.Length; j += 3)
						{
							string text4 = array[j];
							ItemDrop component6 = ZNetScene.instance.GetPrefab(text4).GetComponent<ItemDrop>();
							if (Object.op_Implicit((Object)(object)component6))
							{
								int amount = int.Parse(array[j + 1]);
								int level = int.Parse(array[j + 2]);
								Quests_DataTypes.RandomItemEntry randomItemEntry = new Quests_DataTypes.RandomItemEntry(component6, amount, level);
								if (!dictionary.ContainsKey(randomItemEntry))
								{
									dictionary.Add(randomItemEntry, 0);
								}
								Quests_DataTypes.RandomItemEntry key = randomItemEntry;
								int value = dictionary[key] + 1;
								dictionary[key] = value;
							}
						}
						int num2 = dictionary.Values.Sum();
						foreach (KeyValuePair<Quests_DataTypes.RandomItemEntry, int> item in dictionary)
						{
							double num3 = Math.Round((double)item.Value / (double)num2, 3) * 100.0;
							text3 += string.Format("{0} <color=yellow>x{1}</color> <color=#00ff00>{2}{3}</color> <color=#808080>({4}%)</color>\n", item.Key.Item.m_itemData.m_shared.m_name, item.Key.Amount, " ★", item.Key.Level, num3);
						}
						componentInChildren.m_text = text3;
						break;
					}
					case Quests_DataTypes.QuestRewardType.Skill:
					case Quests_DataTypes.QuestRewardType.Skill_EXP:
						component5.sprite = Utils.GetSkillIcon(quest2.RewardPrefab[i]);
						componentInChildren.m_topic = quest2.GetLocalizedReward(i);
						componentInChildren.m_text = Localization.instance.Localize((quest2.RewardType[i] == Quests_DataTypes.QuestRewardType.Skill_EXP) ? "$mpasn_tooltip_addskillexp" : "$mpasn_tooltip_addskilllevel") + " x" + quest2.RewardCount[i];
						break;
					case Quests_DataTypes.QuestRewardType.EpicMMO_EXP:
						component5.sprite = AssetStorage.EpicMMO_Exp;
						componentInChildren.m_topic = Localization.instance.Localize("$mpasn_EpicMMO_EXP");
						componentInChildren.m_text = Localization.instance.Localize("$mpasn_tooltip_epicmmo ") + "x" + quest2.RewardCount[i];
						break;
					case Quests_DataTypes.QuestRewardType.Cozyheim_EXP:
						component5.sprite = AssetStorage.Cozyheim_Exp;
						componentInChildren.m_topic = Localization.instance.Localize("$mpasn_Cozyheim_EXP");
						componentInChildren.m_text = Localization.instance.Localize("$mpasn_tooltip_cozyheim ") + "x" + quest2.RewardCount[i];
						break;
					case Quests_DataTypes.QuestRewardType.GuildAddLevel:
						component5.sprite = null;
						componentInChildren.m_topic = Localization.instance.Localize("$mpasn_GuildAddLevel");
						componentInChildren.m_text = $"+{quest2.RewardCount[i]}";
						break;
					case Quests_DataTypes.QuestRewardType.Battlepass_EXP:
						component5.sprite = AssetStorage.Battlepass_Exp;
						componentInChildren.m_topic = Localization.instance.Localize("$mpasn_Battlepass_EXP");
						componentInChildren.m_text = $"+{quest2.RewardCount[i]}";
						break;
					case Quests_DataTypes.QuestRewardType.SetCustomValue:
					case Quests_DataTypes.QuestRewardType.AddCustomValue:
						component5.sprite = Utils.TryFindIcon(quest2.RewardPrefab[i], AssetStorage.CustomValue_Icon);
						componentInChildren.m_topic = Localization.instance.Localize("$mpasn_CustomValue");
						componentInChildren.m_text = string.Format("{0} {1} {2}{3}", Localization.instance.Localize("$mpasn_CustomValue"), quest2.GetLocalizedReward(i), (quest2.RewardCount[i] > 0) ? "+" : "-", quest2.RewardCount[i]);
						break;
					case Quests_DataTypes.QuestRewardType.RustyClasses_EXP:
						component5.sprite = AssetStorage.RustyClassesIcon;
						componentInChildren.m_topic = "Rusty Classes EXP";
						componentInChildren.m_text = $"+{quest2.RewardCount[i]}";
						break;
					}
				}
				string message;
				Dialogues_DataTypes.OptionCondition type;
				if (Quests_DataTypes.Quest.IsOnCooldown(UID, out var left))
				{
					((Component)RestrictionText).gameObject.SetActive(true);
					RestrictionText.text = string.Format("{0}: <color=#00ff00>{1}</color> {2}", Localization.instance.Localize("$mpasn_cooldown"), left, Localization.instance.Localize("$mpasn_daysleft"));
				}
				else if (Quests_DataTypes.Quest.IsAccepted(UID))
				{
					if (Quests_DataTypes.AcceptedQuests[UID].IsComplete())
					{
						int transferComplition = Quests_DataTypes.AcceptedQuests[UID].TransferComplition;
						if (transferComplition != 0 && transferComplition != StringExtensionMethods.GetStableHashCode(CurrentProfile))
						{
							((Component)RestrictionText).gameObject.SetActive(true);
							RestrictionText.text = Localization.instance.Localize("$mpasn_youcantcompletequesthere");
							string transferComplitionText = Quests_DataTypes.AcceptedQuests[UID].TransferComplitionText;
							if (!string.IsNullOrWhiteSpace(transferComplitionText))
							{
								Text restrictionText = RestrictionText;
								restrictionText.text = restrictionText.text + "\n<color=yellow>(" + transferComplitionText + ")</color>";
							}
						}
						else
						{
							((Component)((Component)RestrictionButton).transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_complete");
							((Component)RestrictionButton).gameObject.SetActive(true);
							((Graphic)((Component)RestrictionButton).gameObject.GetComponent<Image>()).color = new Color(0.57f, 1f, 0.63f);
						}
					}
					else
					{
						((Component)((Component)RestrictionButton).transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_cancelquest");
						((Component)RestrictionButton).gameObject.SetActive(true);
						((Graphic)((Component)RestrictionButton).gameObject.GetComponent<Image>()).color = new Color(1f, 0.27f, 0.35f);
					}
				}
				else if (!Quests_DataTypes.Quest.CanTake(UID, out message, out type))
				{
					((Component)RestrictionText).gameObject.SetActive(true);
					RestrictionText.text = message;
				}
				else
				{
					((Component)RestrictionButton).gameObject.SetActive(true);
					((Component)((Component)RestrictionButton).transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_takequest");
					((Graphic)((Component)RestrictionButton).gameObject.GetComponent<Image>()).color = new Color(1f, 1f, 1f);
				}
				if (IsJournal)
				{
					((Component)RestrictionButton).gameObject.SetActive(false);
					((Component)RestrictionText).gameObject.SetActive(false);
				}
				Canvas.ForceUpdateCanvases();
				AllFilters.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = false;
				});
				AllFilters.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = true;
				});
				DescriptionScrollbar.value = 1f;
				if (LatestEnumeratorFrame != null)
				{
					((MonoBehaviour)Marketplace._thistype).StopCoroutine(LatestEnumeratorFrame);
				}
				LatestEnumeratorFrame = ((MonoBehaviour)Marketplace._thistype).StartCoroutine(FrameWaitShow());
			}

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

			private static void SetColors()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				foreach (KeyValuePair<GameObject, int> item in QuestLink)
				{
					Color val = Color.white;
					int left;
					string message;
					Dialogues_DataTypes.OptionCondition type;
					if (Quests_DataTypes.Quest.IsAccepted(item.Value))
					{
						val = (Quests_DataTypes.AcceptedQuests[item.Value].IsComplete() ? Color.green : Color.red);
					}
					else if (Quests_DataTypes.Quest.IsOnCooldown(item.Value, out left) || !Quests_DataTypes.Quest.CanTake(item.Value, out message, out type))
					{
						val = Color.gray;
					}
					((Graphic)item.Key.GetComponent<Image>()).color = (IsJournal ? Color.white : val);
				}
			}

			public static void Reload()
			{
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Expected O, but got Unknown
				Default();
				AllGO.ForEach((Action<GameObject>)Object.Destroy);
				AllGO.Clear();
				QuestLink.Clear();
				TOREMOVE.ForEach((Action<GameObject>)Object.Destroy);
				TOREMOVE.Clear();
				if (!IsVisible())
				{
					return;
				}
				int num = 0;
				List<int> value;
				List<int> list = (IsJournal ? Quests_DataTypes.AcceptedQuests.Keys.ToList() : (Quests_DataTypes.SyncedQuestProfiles.Value.TryGetValue(CurrentProfile, out value) ? value : new List<int>()));
				if (Quests_DataTypes.TransferComplitionQuests.TryGetValue(StringExtensionMethods.GetStableHashCode(CurrentProfile), out HashSet<int> value2))
				{
					List<int> list2 = new List<int>();
					foreach (int item in value2)
					{
						if (Quests_DataTypes.AllQuests.ContainsKey(item) && Quests_DataTypes.Quest.IsAccepted(item) && Quests_DataTypes.AcceptedQuests[item].IsComplete())
						{
							list2.Add(item);
						}
					}
					if (list2.Count > 0)
					{
						list2.AddRange(list);
						list = list2;
					}
				}
				foreach (int questID in list)
				{
					if (!Quests_DataTypes.AllQuests.TryGetValue(questID, out Quests_DataTypes.Quest data))
					{
						continue;
					}
					if (!Quests_DataTypes.Quest.IsAccepted(questID))
					{
						string message;
						Dialogues_DataTypes.OptionCondition type;
						bool flag = Quests_DataTypes.Quest.CanTake(questID, out message, out type);
						if ((!flag && Global_Configs.SyncedGlobalOptions.Value._hideOtherQuestRequirementQuests && type == Dialogues_DataTypes.OptionCondition.QuestFinished) || (!flag && type == Dialogues_DataTypes.OptionCondition.IsVIP) || (Quests_DataTypes.Quest.IsOnCooldown(questID, out var left) && left > 5000))
						{
							continue;
						}
					}
					GameObject val = Object.Instantiate<GameObject>(QuestGO, MainTransform);
					((Component)val.transform.Find("Text")).GetComponent<Text>().text = data.Name.Localize();
					((Component)val.transform.Find("ImageList").GetChild((int)data.Type)).gameObject.SetActive(true);
					QuestLink[val] = questID;
					int send = num;
					((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						InitQuestData(data, questID, send);
					});
					num++;
					AllGO.Add(val);
				}
				SetColors();
			}

			private static void Default()
			{
				AllGO.ForEach((Action<GameObject>)Object.Destroy);
				AllGO.Clear();
				QuestLink.Clear();
				((UnityEventBase)RestrictionButton.onClick).RemoveAllListeners();
				TOREMOVE.ForEach((Action<GameObject>)Object.Destroy);
				TOREMOVE.Clear();
				Description.text = "";
				RestrictionText.text = "";
				((Component)RestrictionText).gameObject.SetActive(false);
				((Component)RestrictionButton).gameObject.SetActive(false);
				((Component)DescriptionTransform).gameObject.SetActive(false);
			}

			public static void ClickJournal()
			{
				AssetStorage.AUsrc.Play();
				if (IsVisible())
				{
					Hide();
					return;
				}
				IsJournal = true;
				ResetUIs();
				CurrentProfile = "";
				UI.SetActive(true);
				NPCName.text = Localization.instance.Localize("$mpasn_questjournal");
				Reload();
			}

			public static void Show(string profile, string _npcName)
			{
				IsJournal = false;
				ResetUIs();
				CurrentProfile = profile;
				UI.SetActive(true);
				_npcName = Utils.RichTextFormatting(_npcName);
				NPCName.text = (string.IsNullOrEmpty(_npcName) ? Localization.instance.Localize("$mpasn_Quests") : _npcName);
				Reload();
			}

			public static void Hide()
			{
				ResetUIs();
				UI.SetActive(false);
				AllGO.ForEach((Action<GameObject>)Object.Destroy);
				AllGO.Clear();
				TOREMOVE.ForEach((Action<GameObject>)Object.Destroy);
				TOREMOVE.Clear();
				QuestLink.Clear();
			}
		}

		public static class AcceptedQuestsUI
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static UnityAction <0>__ClickHideButton;

				public static UnityAction <1>__ClickJournal;

				public static UnityAction<float> <2>__ScrollBarValueChange;
			}

			[CompilerGenerated]
			private sealed class <UpdateTimedQuests>d__11 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				private WaitForSeconds <yield>5__2;

				private HashSet<int> <toRemove>5__3;

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

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

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

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<yield>5__2 = null;
					<toRemove>5__3 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Expected O, but got Unknown
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
						{
							foreach (KeyValuePair<int, Quests_DataTypes.Quest> acceptedQuest in Quests_DataTypes.AcceptedQuests)
							{
								if (acceptedQuest.Value.TimeLimit > 0)
								{
									long num2 = CalculateTimeLeft(acceptedQuest.Value);
									GameObject value;
									if (num2 <= 0)
									{
										<toRemove>5__3.Add(acceptedQuest.Key);
									}
									else if (UpdateData.TryGetValue(acceptedQuest.Value, out value))
									{
										((Component)value.transform.Find("QuestName")).GetComponent<Text>().text = ("<color=yellow> [ " + acceptedQuest.Value.Name + " ]</color>").Localize() + "\n (<color=red>" + CalculateTimeLeft(acceptedQuest.Value).ToTime() + "</color>)";
									}
								}
							}
							foreach (int item in <toRemove>5__3)
							{
								string text = Quests_DataTypes.AcceptedQuests[item].Name.Localize();
								MessageHud.instance.ShowMessage((MessageType)2, text + " $mpasn_questtimelimitfail", 0, (Sprite)null, false);
								Quests_DataTypes.Quest.RemoveQuestFailed(item, Quests_DataTypes.QuestEventCondition.OnQuestTimeout);
								CheckQuests();
							}
							<toRemove>5__3.Clear();
						}
					}
					else
					{
						<>1__state = -1;
						<yield>5__2 = new WaitForSeconds(1f);
						<toRemove>5__3 = new HashSet<int>();
					}
					<>2__current = <yield>5__2;
					<>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();
				}
			}

			private static GameObject UI;

			private static Transform MainTransform;

			private static GameObject QuestGO;

			private static readonly Dictionary<Quests_DataTypes.Quest, GameObject> UpdateData = new Dictionary<Quests_DataTypes.Quest, GameObject>();

			private static readonly List<ContentSizeFitter> AllFilters = new List<ContentSizeFitter>();

			private static Scrollbar MainBar;

			public static bool IsVisible()
			{
				if (Object.op_Implicit((Object)(object)UI))
				{
					return UI.activeSelf;
				}
				return false;
			}

			private static void InitQuestData(GameObject go, Quests_DataTypes.Quest data, int UID)
			{
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				//IL_027a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				string text = ((data.TimeLimit > 0) ? ("\n (<color=red>" + CalculateTimeLeft(data).ToTime() + "</color>)") : "");
				((Component)go.transform.Find("QuestName")).GetComponent<Text>().text = ("<color=yellow> [ " + data.Name + " ]</color>").Localize() + text;
				((UnityEvent)((Component)go.transform.Find("QuestName/Button")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					AssetStorage.AUsrc.Play();
					Quests_DataTypes.Quest.RemoveQuestFailed(UID, Quests_DataTypes.QuestEventCondition.OnCancelQuest);
					CheckQuests();
					QuestUI.Reload();
				});
				Transform val = go.transform.Find("Duplicate");
				((Component)val).gameObject.SetActive(false);
				for (int i = 0; i < data.TargetAmount; i++)
				{
					GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, go.transform);
					((Object)val2).name = i.ToString();
					string text2;
					switch (data.Type)
					{
					case Quests_DataTypes.QuestType.Kill:
						text2 = $" (<color=#00ff00>{data.TargetLevel[i] - 1}★</color>)";
						break;
					case Quests_DataTypes.QuestType.Collect:
					case Quests_DataTypes.QuestType.Craft:
						text2 = $" (<color=#00ff00>{data.TargetLevel[i]}★</color>)";
						break;
					default:
						text2 = "";
						break;
					}
					string text3 = text2;
					Quests_DataTypes.QuestType type = data.Type;
					if ((type == Quests_DataTypes.QuestType.Collect || type == Quests_DataTypes.QuestType.Craft) ? true : false)
					{
						ItemDrop component = ZNetScene.instance.GetPrefab(data.TargetPrefab[i]).GetComponent<ItemDrop>();
						if (data.TargetLevel[i] == 1 && component.m_itemData.m_shared.m_maxQuality == 1)
						{
							text3 = "";
						}
					}
					((Component)val2.transform).GetComponent<Text>().text = "- <color=#FFA400>" + Localization.instance.Localize("$mpasn_" + data.Type) + "</color> " + data.GetLocalizedTarget(i) + text3;
					((Component)val2.transform.Find("Score")).GetComponent<Text>().text = $"[{data.ScoreArray[i]}/{data.TargetCount[i]}]";
					((Graphic)((Component)val2.transform.Find("Score")).GetComponent<Text>()).color = (Color)(data.IsComplete(i) ? Color.green : new Color(1f, 0.6f, 0f));
					val2.SetActive(true);
				}
			}

			public static void UpdateStatus(Quests_DataTypes.Quest data)
			{
				//IL_00a9: 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)
				if (UpdateData.ContainsKey(data))
				{
					GameObject val = UpdateData[data];
					for (int i = 0; i < data.TargetAmount; i++)
					{
						((Component)val.transform.Find($"{i}/Score")).GetComponent<Text>().text = $"[{data.ScoreArray[i]}/{data.TargetCount[i]}]";
						((Graphic)((Component)val.transform.Find($"{i}/Score")).GetComponent<Text>()).color = (Color)(data.IsComplete(i) ? Color.green : new Color(1f, 0.6f, 0f));
					}
				}
			}

			public static void Init()
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Expected O, but got Unknown
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketACCEPTEDquests"));
				MainTransform = UI.transform.Find("UI/panel/ALLSTUFF/Scroll View/Viewport/Content");
				QuestGO = AssetStorage.asset.LoadAsset<GameObject>("AcceptedQuestGONew");
				ButtonClickedEvent onClick = ((Component)UI.transform.Find("UI/panel/btn")).GetComponent<Button>().onClick;
				object obj = <>O.<0>__ClickHideButton;
				if (obj == null)
				{
					UnityAction val = ClickHideButton;
					<>O.<0>__ClickHideButton = val;
					obj = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("UI/panel/btn2")).GetComponent<Button>().onClick;
				object obj2 = <>O.<1>__ClickJournal;
				if (obj2 == null)
				{
					UnityAction val2 = QuestUI.ClickJournal;
					<>O.<1>__ClickJournal = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				Object.DontDestroyOnLoad((Object)(object)UI);
				UI.SetActive(false);
				AllFilters.AddRange(UI.GetComponentsInChildren<ContentSizeFitter>().ToList());
				MainBar = UI.GetComponentInChildren<Scrollbar>();
				((UnityEvent<float>)(object)MainBar.onValueChanged).AddListener((UnityAction<float>)ScrollBarValueChange);
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(UpdateTimedQuests());
			}

			private static long CalculateTimeLeft(Quests_DataTypes.Quest quest)
			{
				long num = quest.TimeLimit + quest.AcceptedTime;
				long num2 = (long)EnvMan.instance.m_totalSeconds;
				long val = num - num2;
				return Math.Max(0L, val);
			}

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

			private static void ScrollBarValueChange(float arg0)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}

			private static void ClickHideButton()
			{
				AssetStorage.AUsrc.Play();
				GameObject gameObject = ((Component)UI.transform.Find("UI/panel/ALLSTUFF")).gameObject;
				gameObject.SetActive(!gameObject.activeSelf);
			}

			public static void CheckQuests()
			{
				Quests_DataTypes.Quest.CheckCharacterTargets();
				Quests_DataTypes.Quest.CheckItemDropsTargets();
				Quests_DataTypes.Quest.CheckPickableTargets();
				Quests_DataTypes.Quest.CheckTalkTargets();
				if (Quests_DataTypes.AcceptedQuests.Count == 0)
				{
					Hide();
					return;
				}
				Show();
				foreach (KeyValuePair<Quests_DataTypes.Quest, GameObject> updateDatum in UpdateData)
				{
					Object.Destroy((Object)(object)updateDatum.Value);
				}
				UpdateData.Clear();
				foreach (KeyValuePair<int, Quests_DataTypes.Quest> item in Quests_DataTypes.AcceptedQuests.OrderBy<KeyValuePair<int, Quests_DataTypes.Quest>, string>((KeyValuePair<int, Quests_DataTypes.Quest> d) => d.Value.Name))
				{
					GameObject val = Object.Instantiate<GameObject>(QuestGO, MainTransform);
					InitQuestData(val, item.Value, item.Key);
					UpdateData.Add(item.Value, val);
					val.transform.SetAsLastSibling();
				}
				Canvas.ForceUpdateCanvases();
				AllFilters.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = false;
				});
				AllFilters.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = true;
				});
			}

			private static void Show()
			{
				UI.SetActive(true);
			}

			public static void Hide()
			{
				UI.SetActive(false);
				MainBar.value = 1f;
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class QuestUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (QuestUI.IsVisible())
				{
					__result = true;
				}
			}
		}

		private const string Star_Emoji = " ★";
	}
	public static class Quest_ProgressionHook
	{
		[HarmonyPatch(typeof(Pickable), "RPC_Pick")]
		[ClientOnlyPatch]
		private static class Pickable_Interact_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Pickable __instance, long sender)
			{
				if (!__instance.m_picked)
				{
					string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket QuestPickup", new object[1] { prefabName });
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[ClientOnlyPatch]
		private static class HOOKCRAFTING
		{
			public static void HookCrafting()
			{
				ItemDrop val = InventoryGui.instance.m_craftRecipe?.m_item;
				if (val != null)
				{
					string name = ((Object)val).name;
					ItemData craftUpgradeItem = InventoryGui.instance.m_craftUpgradeItem;
					int num = ((craftUpgradeItem == null) ? 1 : (craftUpgradeItem.m_quality + 1));
					GameEvents.OnItemCrafted?.Invoke(name, num);
					Quests_DataTypes.Quest.TryAddRewardCraft(name, num);
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> code)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(code, (ILGenerator)null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Stloc_S && ((LocalBuilder)i.operand).LocalIndex == 11), (string)null)
				});
				if (val.IsInvalid)
				{
					Utils.print("InventoryGui_DoCrafting_Patch: failed to match", ConsoleColor.Red);
					return val.Instructions();
				}
				val.Advance(1);
				val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(HOOKCRAFTING), "HookCrafting", (Type[])null, (Type[])null))
				});
				return val.Instructions();
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		[ClientOnlyPatch]
		private static class QuestEnemyKill
		{
			[UsedImplicitly]
			private static void Prefix(Character __instance, long sender, HitData hit)
			{
				if (__instance.GetHealth() <= 0f)
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if (Object.op_Implicit((Object)(object)attacker))
				{
					if (attacker.IsPlayer())
					{
						CharacterLastDamageList[__instance] = sender;
					}
					else if (!attacker.IsTamed())
					{
						CharacterLastDamageList[__instance] = 100L;
					}
				}
			}

			[UsedImplicitly]
			private static void Postfix(Character __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.GetHealth() <= 0f && CharacterLastDamageList.ContainsKey(__instance))
				{
					ZPackage val = new ZPackage();
					val.Write(Utils.GetPrefabName(((Component)__instance).gameObject));
					val.Write(__instance.GetLevel());
					val.Write(((Component)__instance).transform.position);
					val.Write(true);
					ZRoutedRpc.instance.InvokeRoutedRPC(CharacterLastDamageList[__instance], "KGmarket QuestKill", new object[1] { val });
					CharacterLastDamageList.Remove(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "ApplyDamage")]
		[ClientOnlyPatch]
		private static class Character_ApplyDamage_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Character __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.GetHealth() <= 0f && CharacterLastDamageList.ContainsKey(__instance))
				{
					ZPackage val = new ZPackage();
					val.Write(Utils.GetPrefabName(((Component)__instance).gameObject));
					val.Write(__instance.GetLevel());
					val.Write(((Component)__instance).transform.position);
					val.Write(true);
					ZRoutedRpc.instance.InvokeRoutedRPC(CharacterLastDamageList[__instance], "KGmarket QuestKill", new object[1] { val });
					CharacterLastDamageList.Remove(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "OnDestroy")]
		[ClientOnlyPatch]
		private static class Character_OnDestroy_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Character __instance)
			{
				if (CharacterLastDamageList.ContainsKey(__instance))
				{
					CharacterLastDamageList.Remove(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnInventoryChanged")]
		[ClientOnlyPatch]
		private static class Player_OnInventoryChanged_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !Player.m_localPlayer.m_isLoading)
				{
					Quests_DataTypes.Quest.InventoryChanged();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		[ClientOnlyPatch]
		private static class HookBuildQuest
		{
			[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;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private MethodInfo <method>5__2;

				private IEnumerator<CodeInstruction> <>7__wrap2;

				private CodeInstruction <instruction>5__4;

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

				object IEnumerator.Current
				{
					[DebuggerHidden]
					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) <= 2u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<method>5__2 = null;
					<>7__wrap2 = null;
					<instruction>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
					//IL_0100: Expected O, but got Unknown
					//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d7: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<method>5__2 = AccessTools.Method(typeof(HookBuildQuest), "PlacedPiece", new Type[1] { typeof(GameObject) }, (Type[])null);
							<>7__wrap2 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							if (<instruction>5__4.opcode == OpCodes.Stloc_0)
							{
								<>2__current = new CodeInstruction(OpCodes.Ldloc_S, (object)0);
								<>1__state = 2;
								return true;
							}
							goto IL_0113;
						case 2:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)<method>5__2);
							<>1__state = 3;
							return true;
						case 3:
							{
								<>1__state = -3;
								goto IL_0113;
							}
							IL_0113:
							<instruction>5__4 = null;
							break;
						}
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							<>2__current = <instruction>5__4;
							<>1__state = 1;
							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__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]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			public static void PlacedPiece(GameObject obj)
			{
				Piece val = ((obj != null) ? obj.GetComponent<Piece>() : null);
				if (val != null)
				{
					string prefabName = Utils.GetPrefabName(((Component)val).gameObject);
					GameEvents.OnStructureBuilt?.Invoke(prefabName);
					if (Quests_DataTypes.Quest.TryAddRewardBuild(prefabName) && Object.op_Implicit((Object)(object)val.m_nview) && val.m_nview.m_zdo != null)
					{
						val.m_nview.m_zdo.Set("MPASNquestBuild", true);
					}
				}
			}

			[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
				};
			}
		}

		[HarmonyPatch(typeof(Humanoid), "Start")]
		[ClientOnlyPatch]
		private static class Character_Awake_Quest
		{
			[UsedImplicitly]
			private static void Postfix(Humanoid __instance)
			{
				//IL_004e: 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_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_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				float radius = ((Character)__instance).m_collider.radius;
				float num = ((Character)__instance).m_collider.height - 1.7f;
				if (Quests_Main_Client.ShowQuestMark.Value)
				{
					GameObject val = Object.Instantiate<GameObject>(AssetStorage.MarketplaceQuestTargetIcon, ((Component)__instance).transform);
					((Object)val).name = "MPASNquest";
					Transform transform = val.transform;
					transform.localPosition += Vector3.up * num;
					Transform transform2 = val.transform;
					transform2.localScale += new Vector3(radius, radius, radius);
					val.SetActive(Quests_DataTypes.Quest.IsQuestTarget((Character)(object)__instance));
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "Awake")]
		[ClientOnlyPatch]
		private static class Pickable_Awake_Quest
		{
			[UsedImplicitly]
			private static void Postfix(Pickable __instance)
			{
				((Component)__instance).gameObject.AddComponent<Pickable_Hook>();
				if (Quests_Main_Client.ShowQuestMark.Value)
				{
					GameObject val = Object.Instantiate<GameObject>(AssetStorage.MarketplaceQuestTargetIcon, ((Component)__instance).transform);
					((Object)val).name = "MPASNquest";
					val.SetActive(Quests_DataTypes.Quest.IsQuestTarget(__instance));
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Awake")]
		[ClientOnlyPatch]
		private static class ItemDrop_Awake_Quest
		{
			[UsedImplicitly]
			private static void Postfix(ItemDrop __instance)
			{
				if (Quests_Main_Client.ShowQuestMark.Value)
				{
					GameObject val = Object.Instantiate<GameObject>(AssetStorage.MarketplaceQuestTargetIcon, ((Component)__instance).transform);
					((Object)val).name = "MPASNquest";
					val.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		[ClientOnlyPatch]
		private static class ItemDrop_Awake_Quest2
		{
			[UsedImplicitly]
			private static void Postfix(ItemDrop __instance)
			{
				Transform obj = ((Component)__instance).transform.Find("MPASNquest");
				if (obj != null)
				{
					((Component)obj).gameObject.SetActive(Quests_DataTypes.Quest.IsQuestTarget(__instance));
				}
			}
		}

		public class Pickable_Hook : MonoBehaviour
		{
			private static readonly List<Pickable> pickables = new List<Pickable>();

			private Pickable pick;

			private void Awake()
			{
				ZNetView component = ((Component)this).GetComponent<ZNetView>();
				if (Object.op_Implicit((Object)(object)component) && component.IsValid())
				{
					pick = ((Component)this).GetComponent<Pickable>();
					if (Object.op_Implicit((Object)(object)pick))
					{
						pickables.Add(pick);
					}
				}
			}

			private void OnDestroy()
			{
				if (Object.op_Implicit((Object)(object)pick))
				{
					pickables.Remove(pick);
				}
			}

			public static List<Pickable> GetPickables()
			{
				return pickables;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "AddRecipeToList")]
		[ClientOnlyPatch]
		private static class TranspileRecipeQuestTest
		{
			[CompilerGenerated]
			private sealed class <TanspileRecipeQuest>d__1 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> code;

				public IEnumerable<CodeInstruction> <>3__code;

				private MethodInfo <method>5__2;

				private bool <isDone>5__3;

				private IEnumerator<CodeInstruction> <>7__wrap3;

				private CodeInstruction <instruction>5__5;

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

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

				[DebuggerHidden]
				public <TanspileRecipeQuest>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) <= 4u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<method>5__2 = null;
					<>7__wrap3 = null;
					<instruction>5__5 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0106: Unknown result type (might be due to invalid IL or missing references)
					//IL_0110: Expected O, but got Unknown
					//IL_012d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0137: Expected O, but got Unknown
					//IL_0156: Unknown result type (might be due to invalid IL or missing references)
					//IL_0160: Expected O, but got Unknown
					//IL_00da: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e4: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<method>5__2 = AccessTools.DeclaredMethod(typeof(TranspileRecipeQuestTest), "ChangeRecipeName", (Type[])null, (Type[])null);
							<isDone>5__3 = false;
							<>7__wrap3 = code.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							if (<instruction>5__5.opcode == OpCodes.Stloc_2 && !<isDone>5__3)
							{
								<isDone>5__3 = true;
								<>2__current = new CodeInstruction(OpCodes.Ldarg_2, (object)null);
								<>1__state = 2;
								return true;
							}
							goto IL_0173;
						case 2:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Ldloca_S, (object)2);
							<>1__state = 3;
							return true;
						case 3:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Ldarg_3, (object)null);
							<>1__state = 4;
							return true;
						case 4:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)<method>5__2);
							<>1__state = 5;
							return true;
						case 5:
							{
								<>1__state = -3;
								goto IL_0173;
							}
							IL_0173:
							<instruction>5__5 = null;
							break;
						}
						if (<>7__wrap3.MoveNext())
						{
							<instruction>5__5 = <>7__wrap3.Current;
							<>2__current = <instruction>5__5;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap3 = 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__wrap3 != null)
					{
						<>7__wrap3.Dispose();
					}
				}

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

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

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

			private static void ChangeRecipeName(Recipe r, ref string str, ItemData item)
			{
				if (Quests_DataTypes.Quest.IsQuestTarget(r, (item == null) ? 1 : (item.m_quality + 1)) && !Enumerable.Contains(str, '★'))
				{
					str = "<color=#00ff00>★</color> " + str;
				}
			}

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

		[HarmonyPatch(typeof(Piece), "DropResources")]
		[ClientOnlyPatch]
		private static class Piece_DropResources_Patch
		{
			[UsedImplicitly]
			private static bool Prefix(Piece __instance)
			{
				return !__instance.m_nview.m_zdo.GetBool("MPASNquestBuild", false);
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		[ClientOnlyPatch]
		private static class Hud_Awake_Patch
		{
			public static int ChildNumber;

			[UsedImplicitly]
			private static void Postfix(Hud __instance)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = AssetStorage.asset.LoadAsset<GameObject>("QuestBuild");
				GameObject val2 = Object.Instantiate<GameObject>(val);
				((Object)val2).name = "QuestBuild";
				val2.transform.SetParent(__instance.m_pieceIconPrefab.transform);
				val2.transform.localPosition = new Vector3(48f, -48f, 0f);
				val2.SetActive(false);
				ChildNumber = __instance.m_pieceIconPrefab.transform.childCount - 1;
				val2.transform.SetAsLastSibling();
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdatePieceList")]
		[ClientOnlyPatch]
		private static class Hud_UpdatePieceList_Patch
		{
			[CompilerGenerated]
			private sealed class <Patch>d__2 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> code;

				public IEnumerable<CodeInstruction> <>3__code;

				private MethodInfo <method>5__2;

				private IEnumerator<CodeInstruction> <>7__wrap2;

				private CodeInstruction <instruction>5__4;

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

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

				[DebuggerHidden]
				public <Patch>d__2(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) <= 3u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<method>5__2 = null;
					<>7__wrap2 = null;
					<instruction>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0104: Unknown result type (might be due to invalid IL or missing references)
					//IL_010e: Expected O, but got Unknown
					//IL_013d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0147: Expected O, but got Unknown
					//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e1: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<method>5__2 = AccessTools.DeclaredPropertySetter(typeof(Image), "sprite");
							<>7__wrap2 = code.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							if (<instruction>5__4.opcode == OpCodes.Callvirt && <instruction>5__4.operand == <method>5__2)
							{
								<>2__current = new CodeInstruction(OpCodes.Ldloc_S, (object)12);
								<>1__state = 2;
								return true;
							}
							goto IL_015a;
						case 2:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Ldloc_S, (object)11);
							<>1__state = 3;
							return true;
						case 3:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Hud_UpdatePieceList_Patch), "SpriteEnabler", (Type[])null, (Type[])null));
							<>1__state = 4;
							return true;
						case 4:
							{
								<>1__state = -3;
								goto IL_015a;
							}
							IL_015a:
							<instruction>5__4 = null;
							break;
						}
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							<>2__current = <instruction>5__4;
							<>1__state = 1;
							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()
				{
					<Patch>d__2 <Patch>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Patch>d__ = this;
					}
					else
					{
						<Patch>d__ = new <Patch>d__2(0);
					}
					<Patch>d__.code = <>3__code;
					return <Patch>d__;
				}

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

			private static void SpriteEnabler(Piece p, PieceIconData data)
			{
				GameObject gameObject = ((Component)data.m_go.transform.GetChild(Hud_Awake_Patch.ChildNumber)).gameObject;
				if (!Object.op_Implicit((Object)(object)p))
				{
					gameObject.SetActive(false);
				}
				else
				{
					gameObject.SetActive(Quests_DataTypes.Quest.IsQuestTarget(p));
				}
			}

			private static void Prefix(Hud __instance)
			{
				if (__instance.m_pieceIcons == null)
				{
					return;
				}
				foreach (PieceIconData pieceIcon in __instance.m_pieceIcons)
				{
					((Component)pieceIcon.m_go.transform.GetChild(Hud_Awake_Patch.ChildNumber)).gameObject.SetActive(false);
				}
			}

			[IteratorStateMachine(typeof(<Patch>d__2))]
			[HarmonyTranspiler]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Patch(IEnumerable<CodeInstruction> code)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Patch>d__2(-2)
				{
					<>3__code = code
				};
			}
		}

		private static readonly Dictionary<Character, long> CharacterLastDamageList = new Dictionary<Character, long>();

		[MarketplaceRPC("KGmarket QuestPickup", Market_Autoload.Type.Client)]
		private static void QuestPickup(long sender, string prefab)
		{
			Quests_DataTypes.Quest.TryAddRewardPickup(prefab);
			GameEvents.OnHarvest?.Invoke(prefab);
		}

		[MarketplaceRPC("KGmarket QuestKill", Market_Autoload.Type.Client)]
		private static void QuestKillEvent(long sender, ZPackage pkg)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			string text = pkg.ReadString();
			int num = pkg.ReadInt();
			Vector3 val = pkg.ReadVector3();
			bool flag = pkg.ReadBool();
			GameEvents.OnCreatureKilled?.Invoke(text, num);
			if (Global_Configs.SyncedGlobalOptions.Value._allowKillQuestsInParty && flag && Groups.API.IsLoaded())
			{
				List<Groups.PlayerReference> list = Groups.API.GroupPlayers();
				if (list != null && list.Count > 1)
				{
					foreach (Groups.PlayerReference item in list)
					{
						if (item.peerId != ZDOMan.instance.m_sessionID)
						{
							ZPackage val2 = new ZPackage();
							val2.Write(text);
							val2.Write(num);
							val2.Write(val);
							val2.Write(false);
							ZRoutedRpc.instance.InvokeRoutedRPC(item.peerId, "KGmarket QuestKill", new object[1] { val2 });
						}
					}
				}
			}
			if (flag || !(Vector3.Distance(((Component)Player.m_localPlayer).transform.position, val) >= 100f))
			{
				Quests_DataTypes.Quest.TryAddRewardKill(text, num);
			}
		}
	}
}
namespace Marketplace.Modules.PlayersTag
{
	public static class PlayersTag_DataTypes
	{
		internal static readonly CustomSyncedValue<Dictionary<string, string>> SyncedPlayersTagData = new CustomSyncedValue<Dictionary<string, string>>(Marketplace.configSync, "kgPlayersTagData", new Dictionary<string, string>());
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Last, "OnInit", new string[] { "PlayerTags.cfg" }, new string[] { "OnPlayerTagsChange" })]
	public static class PlayerTags_Main_Server
	{
		[HarmonyPatch(typeof(ZNet), "UpdatePlayerList")]
		[ServerOnlyPatch]
		private static class ZNet_UpdatePlayerList_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNet __instance)
			{
				//IL_0015: 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_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: 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_005e: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < __instance.m_players.Count; i++)
				{
					if (PlayersTag_DataTypes.SyncedPlayersTagData.Value.TryGetValue(__instance.m_players[i].m_userInfo.m_id.m_userID, out string value))
					{
						PlayerInfo val = __instance.m_players[i];
						val.m_name = value + " " + val.m_name;
						__instance.m_players[i] = val;
					}
				}
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			ReadPlayerTags();
		}

		private static void ReadPlayerTags()
		{
			PlayersTag_DataTypes.SyncedPlayersTagData.Value.Clear();
			IReadOnlyList<string> readOnlyList = File.ReadAllLines(Market_Paths.PlayerTagsConfig);
			foreach (string item in readOnlyList)
			{
				string[] array = item.Split(new char[1] { ':' });
				if (array.Length == 2)
				{
					PlayersTag_DataTypes.SyncedPlayersTagData.Value[array[0].Trim(new char[1] { ' ' })] = array[1].Trim(new char[1] { ' ' });
				}
			}
			PlayersTag_DataTypes.SyncedPlayersTagData.Update();
		}

		[UsedImplicitly]
		private static void OnPlayerTagsChange()
		{
			ReadPlayerTags();
			Utils.print("Player Tags changed, sending to peers");
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class PlayerTag_Main_Client
	{
		[HarmonyPatch(typeof(Player), "GetHoverName")]
		[ClientOnlyPatch]
		private static class Player_GetHoverName_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Player __instance, ref string __result)
			{
				if (((Character)__instance).m_nview.IsValid())
				{
					string @string = ((Character)__instance).m_nview.m_zdo.GetString("Marketplace_PlayerTag", "");
					if (!(@string == ""))
					{
						__result = @string + " " + __result;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetPlayerID")]
		[ClientOnlyPatch]
		private static class Player_SetPlayerID_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).m_nview.m_zdo.Set("Marketplace_PlayerTag", PlayersTag_DataTypes.SyncedPlayersTagData.Value.TryGetValue(Global_Configs._localUserID, out string value) ? value : "");
				}
			}
		}

		[HarmonyPatch(typeof(UserInfo), "GetLocalUser")]
		[ClientOnlyPatch]
		private static class UserInfo_GetLocalUser_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref UserInfo __result)
			{
				if (PlayersTag_DataTypes.SyncedPlayersTagData.Value.TryGetValue(Global_Configs._localUserID, out string value))
				{
					__result.Name = value + " " + __result.Name;
				}
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			PlayersTag_DataTypes.SyncedPlayersTagData.ValueChanged += OnTagsUpdate;
		}

		private static void OnTagsUpdate()
		{
			if (Object.op_Implicit((Object)(object)Game.instance) && !Game.instance.m_shuttingDown && Object.op_Implicit((Object)(object)Player.m_localPlayer) && ((Character)Player.m_localPlayer).m_nview.IsValid())
			{
				((Character)Player.m_localPlayer).m_nview.m_zdo.Set("Marketplace_PlayerTag", PlayersTag_DataTypes.SyncedPlayersTagData.Value.TryGetValue(Global_Configs._localUserID, out string value) ? value : "");
			}
		}
	}
}
namespace Marketplace.Modules.Dialogues
{
	public static class Dialogues_DataTypes
	{
		public delegate bool Dialogue_Condition(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition typeCondition);

		[Serializable]
		public class CustomSpawnZDO : ISerializableParameter
		{
			public Dictionary<string, int> Ints;

			public Dictionary<string, float> Floats;

			public Dictionary<string, long> Longs;

			public Dictionary<string, string> Strings;

			public Dictionary<string, bool> Bools;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(Ints != null);
				if (Ints != null)
				{
					pkg.Write(Ints.Count);
					foreach (KeyValuePair<string, int> @int in Ints)
					{
						pkg.Write(@int.Key);
						pkg.Write(@int.Value);
					}
				}
				pkg.Write(Floats != null);
				if (Floats != null)
				{
					pkg.Write(Floats.Count);
					foreach (KeyValuePair<string, float> @float in Floats)
					{
						pkg.Write(@float.Key);
						pkg.Write(@float.Value);
					}
				}
				pkg.Write(Strings != null);
				if (Strings != null)
				{
					pkg.Write(Strings.Count);
					foreach (KeyValuePair<string, string> @string in Strings)
					{
						pkg.Write(@string.Key);
						pkg.Write(@string.Value);
					}
				}
				pkg.Write(Bools != null);
				if (Bools != null)
				{
					pkg.Write(Bools.Count);
					foreach (KeyValuePair<string, bool> @bool in Bools)
					{
						pkg.Write(@bool.Key);
						pkg.Write(@bool.Value);
					}
				}
				pkg.Write(Longs != null);
				if (Longs == null)
				{
					return;
				}
				pkg.Write(Longs.Count);
				foreach (KeyValuePair<string, long> @long in Longs)
				{
					pkg.Write(@long.Key);
					pkg.Write(@long.Value);
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				if (pkg.ReadBool())
				{
					int num = pkg.ReadInt();
					Ints = new Dictionary<string, int>(num);
					for (int i = 0; i < num; i++)
					{
						string key = pkg.ReadString();
						int value = pkg.ReadInt();
						Ints[key] = value;
					}
				}
				if (pkg.ReadBool())
				{
					int num2 = pkg.ReadInt();
					Floats = new Dictionary<string, float>(num2);
					for (int j = 0; j < num2; j++)
					{
						string key2 = pkg.ReadString();
						float value2 = pkg.ReadSingle();
						Floats[key2] = value2;
					}
				}
				if (pkg.ReadBool())
				{
					int num3 = pkg.ReadInt();
					Strings = new Dictionary<string, string>(num3);
					for (int k = 0; k < num3; k++)
					{
						string key3 = pkg.ReadString();
						string value3 = pkg.ReadString();
						Strings[key3] = value3;
					}
				}
				if (pkg.ReadBool())
				{
					int num4 = pkg.ReadInt();
					Bools = new Dictionary<string, bool>(num4);
					for (int l = 0; l < num4; l++)
					{
						string key4 = pkg.ReadString();
						bool value4 = pkg.ReadBool();
						Bools[key4] = value4;
					}
				}
				if (pkg.ReadBool())
				{
					int num5 = pkg.ReadInt();
					Longs = new Dictionary<string, long>(num5);
					for (int m = 0; m < num5; m++)
					{
						string key5 = pkg.ReadString();
						long value5 = pkg.ReadLong();
						Longs[key5] = value5;
					}
				}
			}
		}

		private enum OptionCommand
		{
			OpenUI,
			PlaySound,
			GiveQuest,
			RemoveQuest,
			FinishQuest,
			GiveItem,
			GiveItemWithData,
			SetPlayerData,
			RemoveItem,
			Spawn,
			SpawnXYZ,
			SpawnWithData,
			SpawnXYZWithData,
			Teleport,
			Damage,
			Heal,
			GiveBuff,
			AddPin,
			PingMap,
			AddEpicMMOExp,
			AddCozyheimExp,
			PlayAnimation,
			EnterPassword,
			GuildAddLevel,
			Battlepass_EXP,
			ConsoleCommand,
			AddCustomValue,
			SetCustomValue,
			PlayVideo,
			AddRustyClassesEXP,
			SendWebhook,
			AddPlayerKey,
			RemovePlayerKey,
			SetPlayerGuild,
			SetPlayerGuildRank,
			SetNPCModelLocal,
			SetNPCModelGlobal,
			SetNPCNameLocal,
			SetNPCNameGlobal,
			SetNPCPatrol,
			SetFaction,
			RemoveFaction
		}

		public enum OptionCondition : byte
		{
			None = 0,
			HasItem = 1,
			NotHasItem = 129,
			HasBuff = 2,
			NotHasBuff = 130,
			SkillMore = 3,
			SkillLess = 131,
			GlobalKey = 4,
			NotGlobalKey = 132,
			HasQuest = 5,
			NotHasQuest = 133,
			QuestProgressDone = 6,
			QuestProgressNotDone = 134,
			QuestFinished = 7,
			QuestNotFinished = 135,
			EpicMMOLevelMore = 8,
			EpicMMOLevelLess = 136,
			CozyheimLevelMore = 9,
			CozyheimLevelLess = 137,
			HasAchievement = 10,
			NotHasAchievement = 138,
			HasAchievementScore = 11,
			NotHasAchievementScore = 139,
			CustomValueMore = 12,
			CustomValueLess = 140,
			ModInstalled = 13,
			NotModInstalled = 141,
			IronGateStatMore = 14,
			IronGateStatLess = 142,
			HasGuild = 15,
			NotHasGuild = 143,
			HasGuildWithName = 16,
			NotHasGuildWithName = 144,
			GuildLevelMore = 17,
			GuildLevelLess = 145,
			GuildHasAchievement = 18,
			GuildNotHasAchievement = 146,
			IsVIP = 20,
			NotIsVIP = 148,
			RustyClassesLevelMore = 21,
			RustyClassesLevelLess = 149,
			HasPlayerKey = 22,
			NotHasPlayerKey = 150,
			NPCModelEquals = 23,
			NotNPCModelEquals = 151,
			HealthMore = 24,
			HealthLess = 152,
			MaxHealthMore = 25,
			MaxHealthLess = 153,
			StaminaMore = 26,
			StaminaLess = 154,
			MaxStaminaMore = 27,
			MaxStaminaLess = 155,
			EitrMore = 28,
			EitrLess = 156,
			MaxEitrMore = 29,
			MaxEitrLess = 157,
			PlayerHasAllCustomDataKeys = 30,
			PlayerHasOneOfCustomDataKeys = 31,
			NPCNameEquals = 32,
			NotNPCNameEquals = 160,
			HasFaction = 33,
			NotHasFaction = 161,
			HasAnyFaction = 34,
			NotHasAnyFaction = 162,
			OtherQuest = 100,
			NotFinished = 101,
			Skill = 102
		}

		public class RawDialogue : ISerializableParameter
		{
			public enum InteractionType
			{
				Option,
				Interaction,
				InRange,
				OutRange
			}

			public class RawPlayerOption
			{
				public InteractionType Type;

				public string Text;

				public string Icon;

				[YamlMember(Alias = "TransitionTo")]
				public string NextUID;

				public string[] RandomTransition = Array.Empty<string>();

				public string[] Commands = Array.Empty<string>();

				public List<KeyValuePair<int, string>> RandomCommands = new List<KeyValuePair<int, string>>();

				public List<string[]> Conditions = new List<string[]>();

				public bool AlwaysVisible = true;

				public Color32 Color = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);

				public string OverrideError;
			}

			[YamlMember(Alias = "Name")]
			public string UID;

			[YamlMember(Alias = "Text")]
			public string Text;

			[YamlMember(Alias = "Background Image Link")]
			public string BG_Image;

			[YamlMember(Alias = "Interactions")]
			public RawPlayerOption[] Interactions = Array.Empty<RawPlayerOption>();

			public void Serialize(ref ZPackage pkg)
			{
				//IL_0207: 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)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				pkg.Write(UID ?? "default");
				pkg.Write(Text ?? "");
				pkg.Write(BG_Image ?? "");
				pkg.Write(Interactions.Length);
				RawPlayerOption[] interactions = Interactions;
				foreach (RawPlayerOption rawPlayerOption in interactions)
				{
					pkg.Write((int)rawPlayerOption.Type);
					pkg.Write(rawPlayerOption.Text ?? "");
					pkg.Write(rawPlayerOption.Icon ?? "");
					pkg.Write(rawPlayerOption.NextUID ?? "");
					pkg.Write(rawPlayerOption.RandomTransition.Length);
					string[] randomTransition = rawPlayerOption.RandomTransition;
					foreach (string text in randomTransition)
					{
						pkg.Write(text);
					}
					pkg.Write(rawPlayerOption.Commands.Length);
					string[] commands = rawPlayerOption.Commands;
					foreach (string text2 in commands)
					{
						pkg.Write(text2);
					}
					pkg.Write(rawPlayerOption.RandomCommands.Count);
					foreach (KeyValuePair<int, string> randomCommand in rawPlayerOption.RandomCommands)
					{
						pkg.Write(randomCommand.Key);
						pkg.Write(randomCommand.Value);
					}
					pkg.Write(rawPlayerOption.Conditions.Count);
					foreach (string[] condition in rawPlayerOption.Conditions)
					{
						pkg.Write(condition.Length);
						string[] array = condition;
						foreach (string text3 in array)
						{
							pkg.Write(text3);
						}
					}
					pkg.Write(rawPlayerOption.AlwaysVisible);
					pkg.Write(Utils.ColorToVec3(Color32.op_Implicit(rawPlayerOption.Color)));
					pkg.Write(rawPlayerOption.OverrideError ?? "");
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				//IL_01fa: 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_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				UID = pkg.ReadString();
				Text = pkg.ReadString();
				BG_Image = pkg.ReadString();
				int num = pkg.ReadInt();
				Interactions = new RawPlayerOption[num];
				for (int i = 0; i < num; i++)
				{
					Interactions[i] = new RawPlayerOption
					{
						Type = (InteractionType)pkg.ReadInt(),
						Text = pkg.ReadString(),
						Icon = pkg.ReadString(),
						NextUID = pkg.ReadString(),
						RandomTransition = new string[pkg.ReadInt()]
					};
					for (int j = 0; j < Interactions[i].RandomTransition.Length; j++)
					{
						Interactions[i].RandomTransition[j] = pkg.ReadString();
					}
					int num2 = pkg.ReadInt();
					Interactions[i].Commands = new string[num2];
					for (int k = 0; k < num2; k++)
					{
						Interactions[i].Commands[k] = pkg.ReadString();
					}
					int num3 = pkg.ReadInt();
					Interactions[i].RandomCommands = new List<KeyValuePair<int, string>>(num3);
					for (int l = 0; l < num3; l++)
					{
						int key = pkg.ReadInt();
						string value = pkg.ReadString();
						Interactions[i].RandomCommands.Add(new KeyValuePair<int, string>(key, value));
					}
					int num4 = pkg.ReadInt();
					Interactions[i].Conditions = new List<string[]>();
					for (int m = 0; m < num4; m++)
					{
						int num5 = pkg.ReadInt();
						string[] array = new string[num5];
						for (int n = 0; n < num5; n++)
						{
							array[n] = pkg.ReadString();
						}
						Interactions[i].Conditions.Add(array);
					}
					Interactions[i].AlwaysVisible = pkg.ReadBool();
					Interactions[i].Color = Color32.op_Implicit(Utils.Vec3ToColor(pkg.ReadVector3()));
					Interactions[i].OverrideError = pkg.ReadString();
				}
			}
		}

		public class Dialogue
		{
			public class PlayerInteraction
			{
				public RawDialogue.InteractionType Type;

				public string Text;

				public Sprite Icon;

				public string NextUID;

				public string[] RandomTransition;

				public Action<Market_NPC.NPCcomponent> Command;

				public Dictionary<int, Action<Market_NPC.NPCcomponent>> RandomCommands;

				public Dialogue_Condition Conditions;

				public bool AlwaysVisible;

				public Color Color = Color.white;

				public string OverrideError;

				public string NextTransition
				{
					get
					{
						if (!string.IsNullOrWhiteSpace(NextUID))
						{
							return NextUID;
						}
						if (RandomTransition.Length == 0)
						{
							return null;
						}
						string text = RandomTransition[Random.Range(0, RandomTransition.Length)];
						if (!string.IsNullOrWhiteSpace(text))
						{
							return text;
						}
						return null;
					}
				}

				public void CallCommands(Market_NPC.NPCcomponent npc)
				{
					if (Command != null)
					{
						Command(npc);
					}
					if (RandomCommands == null || RandomCommands.Count <= 0)
					{
						return;
					}
					foreach (KeyValuePair<int, Action<Market_NPC.NPCcomponent>> randomCommand in RandomCommands)
					{
						int num = Random.Range(0, 100);
						if (num < randomCommand.Key && Object.op_Implicit((Object)(object)Player.m_localPlayer))
						{
							randomCommand.Value?.Invoke(npc);
						}
					}
				}

				public bool CheckCondition(Market_NPC.NPCcomponent npc, out string reason)
				{
					reason = "";
					if (Conditions == null)
					{
						return true;
					}
					foreach (Dialogue_Condition item in Conditions.GetInvocationList().Cast<Dialogue_Condition>())
					{
						if (!item(npc, out reason, out var _))
						{
							if (!string.IsNullOrWhiteSpace(OverrideError))
							{
								reason = OverrideError;
							}
							return false;
						}
					}
					return true;
				}
			}

			public string Text;

			public Sprite BG_Image;

			public PlayerInteraction[] Interactions = Array.Empty<PlayerInteraction>();

			public static Action<Market_NPC.NPCcomponent> ParseCommands(IEnumerable<string> commands)
			{
				Action<Market_NPC.NPCcomponent> action = null;
				foreach (string command in commands)
				{
					try
					{
						string[] split = command.Replace(":", ",").Split(new char[1] { ',' });
						if (!Enum.TryParse<OptionCommand>(split[0], ignoreCase: true, out var result))
						{
							continue;
						}
						switch (result)
						{
						case OptionCommand.AddPlayerKey:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text8 = split[1];
								((Humanoid)Player.m_localPlayer).AddUniqueKey(text8);
							});
							break;
						case OptionCommand.RemovePlayerKey:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text7 = split[1];
								((Humanoid)Player.m_localPlayer).RemoveUniqueKey(text7);
							});
							break;
						case OptionCommand.GuildAddLevel:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Guild ownGuild = Guilds.API.GetOwnGuild();
								if (ownGuild != null)
								{
									ownGuild.General.level += int.Parse(split[1]);
									Guilds.API.SaveGuild(ownGuild);
								}
							});
							break;
						case OptionCommand.EnterPassword:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								string title = split[1];
								string password = split[2];
								string onSuccess = split[3];
								string onFail = split[4];
								new DialoguePassword(npc, title, password, onSuccess, onFail);
							});
							break;
						case OptionCommand.PlayAnimation:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								if (npc != null)
								{
									npc.zanim.SetTrigger(split[1]);
								}
							});
							break;
						case OptionCommand.OpenUI:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								string text = ((split.Length > 1) ? split[1] : null);
								string text2 = ((split.Length > 2) ? split[2] : null);
								if (Object.op_Implicit((Object)(object)npc))
								{
									if (string.IsNullOrWhiteSpace(text))
									{
										text = npc._currentNpcType.ToString();
									}
									if (string.IsNullOrWhiteSpace(text2))
									{
										text2 = npc.znv.m_zdo.GET_NPC_Profile();
									}
									string @string = npc.znv.m_zdo.GetString("KGnpcNameOverride", "");
									Market_NPC.NPCcomponent.OpenUIForType(text, text2, @string);
								}
								else
								{
									Market_NPC.NPCcomponent.OpenUIForType(text, text2, "");
								}
							});
							break;
						case OptionCommand.SetPlayerGuild:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Guilds.PlayerReference player = Guilds.PlayerReference.forOwnPlayer();
								Guilds.API.RemovePlayerFromGuild(player);
								string text3 = split[1];
								Guild guild = null;
								guild = ((!int.TryParse(text3, out var result2)) ? Guilds.API.GetGuild(text3) : Guilds.API.GetGuild(result2));
								if (guild != null)
								{
									Guilds.API.AddPlayerToGuild(player, guild);
									Guilds.API.SaveGuild(guild);
								}
							});
							break;
						case OptionCommand.SetNPCModelLocal:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								if (Object.op_Implicit((Object)(object)npc))
								{
									string text4 = split[1];
									if (Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(text4)))
									{
										npc.OverrideModelLocal(text4);
									}
								}
							});
							break;
						case OptionCommand.SetNPCNameLocal:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								if (Object.op_Implicit((Object)(object)npc))
								{
									string npcName = split[1].Replace("_", " ");
									npc.ApplyName(npcName);
								}
							});
							break;
						case OptionCommand.SetNPCNameGlobal:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								//IL_0036: Unknown result type (might be due to invalid IL or missing references)
								if (Object.op_Implicit((Object)(object)npc))
								{
									string text5 = split[1].Replace("_", " ");
									ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, npc.znv.m_zdo.m_uid, "KGmarket overridename", new object[1] { text5 });
								}
							});
							break;
						case OptionCommand.SetNPCPatrol:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								//IL_0027: Unknown result type (might be due to invalid IL or missing references)
								if (Object.op_Implicit((Object)(object)npc))
								{
									string text6 = split[1];
									ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, npc.znv.m_zdo.m_uid, "KGmarket GetPatrolData", new object[1] { text6 });
								}
							});
							break;
						case OptionCommand.SetFaction:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Player.m_localPlayer.m_customData["MPASN_Faction"] = split[1].ToLower();
								Factions_Client.FindMyFaction(notify: true);
							});
							break;
						case OptionCommand.RemoveFaction:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Player.m_localPlayer.m_customData.Remove("MPASN_Faction");
								Factions_Client.FindMyFaction(notify: true);
							});
							break;
						case OptionCommand.SetNPCModelGlobal:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								//IL_003a: Unknown result type (might be due to invalid IL or missing references)
								if (Object.op_Implicit((Object)(object)npc))
								{
									string text9 = split[1];
									if (Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(text9)))
									{
										ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, npc.znv.m_zdo.m_uid, "KGmarket overridemodel", new object[1] { text9 });
									}
								}
							});
							break;
						case OptionCommand.SetPlayerGuildRank:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Guild ownGuild2 = Guilds.API.GetOwnGuild();
								if (ownGuild2 != null)
								{
									Guilds.PlayerReference player2 = Guilds.PlayerReference.forOwnPlayer();
									Ranks result3;
									Ranks? ranks = (Enum.TryParse<Ranks>(split[1], ignoreCase: true, out result3) ? new Ranks?(result3) : null);
									if (ranks.HasValue)
									{
										Guilds.API.UpdatePlayerRank(player2, ranks.Value);
									}
								}
							});
							break;
						case OptionCommand.PlaySound:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate(Market_NPC.NPCcomponent npc)
							{
								if (AssetStorage.NPC_AudioClips.TryGetValue(split[1], out AudioClip value))
								{
									if (Object.op_Implicit((Object)(object)npc))
									{
										npc.NPC_SoundSource.Stop();
										npc.NPC_SoundSource.clip = value;
										npc.NPC_SoundSource.Play();
									}
									else
									{
										AssetStorage.AUsrc.PlayOneShot(value);
									}
								}
							});
							break;
						case OptionCommand.PlayVideo:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								float multiplier = ((split.Length > 2) ? ((float)int.Parse(split[2]) / 100f) : 0.5f);
								VideoPlayerUI.StartVideo(split[1], multiplier);
							});
							break;
						case OptionCommand.GiveQuest:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text10 = split[1].ToLower();
								Quests_DataTypes.Quest.AcceptQuest(StringExtensionMethods.GetStableHashCode(text10), "0", null, handleEvent: false);
								Quests_UIs.AcceptedQuestsUI.CheckQuests();
							});
							break;
						case OptionCommand.ConsoleCommand:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_006b: Unknown result type (might be due to invalid IL or missing references)
								//IL_0075: Expected O, but got Unknown
								split[1] = split[1].Replace("{playername}", Game.instance.m_playerProfile.m_playerName);
								if (Terminal.commands.TryGetValue(split[1].Split(new char[1] { ' ' }, StringSplitOptions.None)[0].ToLower(), out var value2))
								{
									Player.m_debugMode = true;
									value2.RunAction(new ConsoleEventArgs(split[1], (Terminal)(object)Console.instance));
									Player.m_debugMode = false;
								}
							});
							break;
						case OptionCommand.Battlepass_EXP:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Type type = Type.GetType("UL_B.Battlepass_Main_Client, UL_B");
								if (type != null)
								{
									MethodInfo methodInfo = AccessTools.Method(type, "AddExp", (Type[])null, (Type[])null);
									if (methodInfo != null)
									{
										methodInfo.Invoke(null, new object[1] { Convert.ToInt32(split[1]) });
									}
								}
							});
							break;
						case OptionCommand.SetCustomValue:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string key = split[1];
								int num = int.Parse(split[2]);
								if (num != 0)
								{
									Player.m_localPlayer.SetCustomValue(key, num);
								}
								else
								{
									Player.m_localPlayer.RemoveCustomValue(key);
								}
							});
							break;
						case OptionCommand.AddCustomValue:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string key2 = split[1];
								int value3 = int.Parse(split[2]);
								Player.m_localPlayer.AddCustomValue(key2, value3);
							});
							break;
						case OptionCommand.GiveItem:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text11 = split[1];
								GameObject prefab = ZNetScene.instance.GetPrefab(text11);
								if (Object.op_Implicit((Object)(object)prefab) && Object.op_Implicit((Object)(object)prefab.GetComponent<ItemDrop>()))
								{
									int count = int.Parse(split[2]);
									int level = int.Parse(split[3]);
									Utils.AddItemToPlayer(prefab, count, level);
								}
							});
							break;
						case OptionCommand.GiveItemWithData:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text12 = split[1];
								GameObject prefab2 = ZNetScene.instance.GetPrefab(text12);
								if (Object.op_Implicit((Object)(object)prefab2) && Object.op_Implicit((Object)(object)prefab2.GetComponent<ItemDrop>()))
								{
									int count2 = int.Parse(split[2]);
									int level2 = int.Parse(split[3]);
									string text13 = split[4].ToLower();
									if (!CustomSpawnZDOData_Synced.Value.TryGetValue(text13, out CustomSpawnZDO value4))
									{
										Utils.print("No custom spawn data found for key " + text13, ConsoleColor.DarkRed);
									}
									else
									{
										Utils.AddItemToPlayer(prefab2, count2, level2, value4);
									}
								}
							});
							break;
						case OptionCommand.SetPlayerData:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text14 = split[1].ToLower();
								if (!CustomSpawnZDOData_Synced.Value.TryGetValue(text14, out CustomSpawnZDO value5))
								{
									Utils.print("No custom spawn data found for key " + text14, ConsoleColor.DarkRed);
								}
								else
								{
									Utils.print(JSON.ToNiceJSON(value5));
									if (value5.Ints != null)
									{
										foreach (KeyValuePair<string, int> @int in value5.Ints)
										{
											((Character)Player.m_localPlayer).m_nview.m_zdo.Set(@int.Key, @int.Value);
										}
									}
									if (value5.Floats != null)
									{
										foreach (KeyValuePair<string, float> @float in value5.Floats)
										{
											((Character)Player.m_localPlayer).m_nview.m_zdo.Set(@float.Key, @float.Value);
										}
									}
									if (value5.Strings != null)
									{
										foreach (KeyValuePair<string, string> string2 in value5.Strings)
										{
											((Character)Player.m_localPlayer).m_nview.m_zdo.Set(string2.Key, string2.Value);
										}
									}
									if (value5.Bools != null)
									{
										foreach (KeyValuePair<string, bool> @bool in value5.Bools)
										{
											((Character)Player.m_localPlayer).m_nview.m_zdo.Set(@bool.Key, @bool.Value);
										}
									}
									if (value5.Longs != null)
									{
										foreach (KeyValuePair<string, long> @long in value5.Longs)
										{
											((Character)Player.m_localPlayer).m_nview.m_zdo.Set(@long.Key, @long.Value);
										}
									}
								}
							});
							break;
						case OptionCommand.RemoveItem:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								Utils.CustomRemoveItems(split[1], int.Parse(split[2]), 1);
							});
							break;
						case OptionCommand.Spawn:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_0028: Unknown result type (might be due to invalid IL or missing references)
								//IL_002d: Unknown result type (might be due to invalid IL or missing references)
								//IL_006d: Unknown result type (might be due to invalid IL or missing references)
								//IL_0076: Unknown result type (might be due to invalid IL or missing references)
								//IL_007c: Unknown result type (might be due to invalid IL or missing references)
								//IL_008a: Unknown result type (might be due to invalid IL or missing references)
								//IL_009e: Unknown result type (might be due to invalid IL or missing references)
								//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
								string text15 = split[1];
								GameObject prefab3 = ZNetScene.instance.GetPrefab(text15);
								if (Object.op_Implicit((Object)(object)prefab3))
								{
									Vector3 position = ((Component)Player.m_localPlayer).transform.position;
									int num2 = int.Parse(split[2]);
									int num3 = int.Parse(split[3]);
									Vector3 val = default(Vector3);
									for (int i = 0; i < num2; i++)
									{
										float num4 = Random.Range(-15, 15);
										float num5 = Random.Range(-15, 15);
										((Vector3)(ref val))..ctor(position.x + num4, position.y, position.z + num5);
										Utils.CustomFindFloor(val, out val.y, 3f);
										GameObject val2 = Object.Instantiate<GameObject>(prefab3, val, Quaternion.identity);
										Character component = val2.GetComponent<Character>();
										if (component != null)
										{
											component.SetLevel(Mathf.Max(1, num3 + 1));
										}
										ItemDrop component2 = val2.GetComponent<ItemDrop>();
										if (component2 != null)
										{
											component2.SetQuality(num3);
										}
									}
								}
							});
							break;
						case OptionCommand.SpawnWithData:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_0028: Unknown result type (might be due to invalid IL or missing references)
								//IL_002d: Unknown result type (might be due to invalid IL or missing references)
								//IL_00a4: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
								//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
								//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
								//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
								string text16 = split[1];
								GameObject prefab4 = ZNetScene.instance.GetPrefab(text16);
								if (Object.op_Implicit((Object)(object)prefab4))
								{
									Vector3 position2 = ((Component)Player.m_localPlayer).transform.position;
									int num6 = int.Parse(split[2]);
									int num7 = int.Parse(split[3]);
									string text17 = split[4].ToLower();
									if (!CustomSpawnZDOData_Synced.Value.TryGetValue(text17, out CustomSpawnZDO value6))
									{
										Utils.print("No custom spawn data found for key " + text17, ConsoleColor.DarkRed);
									}
									else
									{
										Vector3 val3 = default(Vector3);
										for (int j = 0; j < num6; j++)
										{
											float num8 = Random.Range(-15, 15);
											float num9 = Random.Range(-15, 15);
											((Vector3)(ref val3))..ctor(position2.x + num8, position2.y, position2.z + num9);
											Utils.CustomFindFloor(val3, out val3.y, 3f);
											GameObject val4 = Object.Instantiate<GameObject>(prefab4, val3, Quaternion.identity);
											ZNetView component3 = val4.GetComponent<ZNetView>();
											if (component3 != null)
											{
												Character component4 = val4.GetComponent<Character>();
												if (component4 != null)
												{
													component4.SetLevel(Mathf.Max(1, num7 + 1));
												}
												ItemDrop component5 = val4.GetComponent<ItemDrop>();
												if (component5 != null)
												{
													component5.SetQuality(num7);
													component5.LoadFromExternalZDO(component3.m_zdo);
												}
												if (value6.Ints != null)
												{
													foreach (KeyValuePair<string, int> int2 in value6.Ints)
													{
														component3.m_zdo.Set(int2.Key, int2.Value);
													}
												}
												if (value6.Floats != null)
												{
													foreach (KeyValuePair<string, float> float2 in value6.Floats)
													{
														component3.m_zdo.Set(float2.Key, float2.Value);
													}
												}
												if (value6.Strings != null)
												{
													foreach (KeyValuePair<string, string> string3 in value6.Strings)
													{
														component3.m_zdo.Set(string3.Key, string3.Value);
													}
												}
												if (value6.Bools != null)
												{
													foreach (KeyValuePair<string, bool> bool2 in value6.Bools)
													{
														component3.m_zdo.Set(bool2.Key, bool2.Value);
													}
												}
												if (value6.Longs != null)
												{
													foreach (KeyValuePair<string, long> long2 in value6.Longs)
													{
														component3.m_zdo.Set(long2.Key, long2.Value);
													}
												}
											}
										}
									}
								}
							});
							break;
						case OptionCommand.SpawnXYZ:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_009e: Unknown result type (might be due to invalid IL or missing references)
								//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
								//IL_00af: Unknown result type (might be due to invalid IL or missing references)
								//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
								//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
								string text18 = split[1];
								GameObject prefab5 = ZNetScene.instance.GetPrefab(text18);
								if (Object.op_Implicit((Object)(object)prefab5))
								{
									int num10 = int.Parse(split[2]);
									int num11 = int.Parse(split[3]);
									Vector3 val5 = default(Vector3);
									((Vector3)(ref val5))..ctor((float)int.Parse(split[4]), (float)int.Parse(split[5]), (float)int.Parse(split[6]));
									int num12 = int.Parse(split[7]);
									Vector3 val6 = default(Vector3);
									for (int k = 0; k < num10; k++)
									{
										float num13 = Random.Range(-num12, num12);
										float num14 = Random.Range(-num12, num12);
										((Vector3)(ref val6))..ctor(val5.x + num13, val5.y, val5.z + num14);
										GameObject val7 = Object.Instantiate<GameObject>(prefab5, val6, Quaternion.identity);
										Character component6 = val7.GetComponent<Character>();
										if (component6 != null)
										{
											component6.SetLevel(Mathf.Max(1, num11 + 1));
										}
										ItemDrop component7 = val7.GetComponent<ItemDrop>();
										if (component7 != null)
										{
											component7.SetQuality(num11);
										}
									}
								}
							});
							break;
						case OptionCommand.SpawnXYZWithData:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
								//IL_00df: Unknown result type (might be due to invalid IL or missing references)
								//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
								//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
								//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
								string text19 = split[1];
								GameObject prefab6 = ZNetScene.instance.GetPrefab(text19);
								if (Object.op_Implicit((Object)(object)prefab6))
								{
									int num15 = int.Parse(split[2]);
									int num16 = int.Parse(split[3]);
									Vector3 val8 = default(Vector3);
									((Vector3)(ref val8))..ctor((float)int.Parse(split[4]), (float)int.Parse(split[5]), (float)int.Parse(split[6]));
									int num17 = int.Parse(split[7]);
									string text20 = split[8].ToLower();
									if (!CustomSpawnZDOData_Synced.Value.TryGetValue(text20, out CustomSpawnZDO value7))
									{
										Utils.print("No custom spawn data found for key " + text20, ConsoleColor.DarkRed);
									}
									else
									{
										Vector3 val9 = default(Vector3);
										for (int l = 0; l < num15; l++)
										{
											float num18 = Random.Range(-num17, num17);
											float num19 = Random.Range(-num17, num17);
											((Vector3)(ref val9))..ctor(val8.x + num18, val8.y, val8.z + num19);
											GameObject val10 = Object.Instantiate<GameObject>(prefab6, val9, Quaternion.identity);
											ZNetView component8 = val10.GetComponent<ZNetView>();
											if (component8 != null)
											{
												if (value7.Ints != null)
												{
													foreach (KeyValuePair<string, int> int3 in value7.Ints)
													{
														component8.m_zdo.Set(int3.Key, int3.Value);
													}
												}
												if (value7.Floats != null)
												{
													foreach (KeyValuePair<string, float> float3 in value7.Floats)
													{
														component8.m_zdo.Set(float3.Key, float3.Value);
													}
												}
												if (value7.Strings != null)
												{
													foreach (KeyValuePair<string, string> string4 in value7.Strings)
													{
														component8.m_zdo.Set(string4.Key, string4.Value);
													}
												}
												if (value7.Bools != null)
												{
													foreach (KeyValuePair<string, bool> bool3 in value7.Bools)
													{
														component8.m_zdo.Set(bool3.Key, bool3.Value);
													}
												}
												if (value7.Longs != null)
												{
													foreach (KeyValuePair<string, long> long3 in value7.Longs)
													{
														component8.m_zdo.Set(long3.Key, long3.Value);
													}
												}
												Character component9 = val10.GetComponent<Character>();
												if (component9 != null)
												{
													component9.SetLevel(Mathf.Max(1, num16 + 1));
												}
												ItemDrop component10 = val10.GetComponent<ItemDrop>();
												if (component10 != null)
												{
													component10.SetQuality(num16);
													component10.LoadFromExternalZDO(component8.m_zdo);
												}
											}
										}
									}
								}
							});
							break;
						case OptionCommand.Teleport:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_0079: Unknown result type (might be due to invalid IL or missing references)
								//IL_0088: Unknown result type (might be due to invalid IL or missing references)
								if ((split.Length <= 4 || !bool.Parse(split[4])) && !((Humanoid)Player.m_localPlayer).IsTeleportable())
								{
									MessageHud.instance.ShowMessage((MessageType)2, "$msg_noteleport".Localize(), 0, (Sprite)null, false);
								}
								else
								{
									int num20 = int.Parse(split[1]);
									int num21 = int.Parse(split[2]);
									int num22 = int.Parse(split[3]);
									((Character)Player.m_localPlayer).TeleportTo(new Vector3((float)num20, (float)num21, (float)num22), ((Component)Player.m_localPlayer).transform.rotation, true);
								}
							});
							break;
						case OptionCommand.Damage:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_000e: Unknown result type (might be due to invalid IL or missing references)
								//IL_0014: Expected O, but got Unknown
								int num23 = int.Parse(split[1]);
								HitData val11 = new HitData();
								val11.m_damage.m_damage = num23;
								((Character)Player.m_localPlayer).Damage(val11);
							});
							break;
						case OptionCommand.Heal:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								int num24 = int.Parse(split[1]);
								((Character)Player.m_localPlayer).Heal((float)num24, true);
							});
							break;
						case OptionCommand.RemoveQuest:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string text21 = split[1].ToLower();
								bool flag = split.Length > 2 && bool.Parse(split[2]);
								Quests_DataTypes.Quest.RemoveQuestFailed(StringExtensionMethods.GetStableHashCode(text21), flag ? new Quests_DataTypes.QuestEventCondition?(Quests_DataTypes.QuestEventCondition.OnCancelQuest) : null);
								Quests_UIs.AcceptedQuestsUI.CheckQuests();
							});
							break;
						case OptionCommand.GiveBuff:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								((Character)Player.m_localPlayer).GetSEMan().RemoveStatusEffect(StringExtensionMethods.GetStableHashCode(split[1]), true);
								StatusEffect val12 = ((Character)Player.m_localPlayer).GetSEMan().AddStatusEffect(StringExtensionMethods.GetStableHashCode(split[1]), true, 0, 0f);
								if (Object.op_Implicit((Object)(object)val12) && split.Length > 2)
								{
									val12.m_ttl = Mathf.Min(1f, float.Parse(split[2]));
								}
							});
							break;
						case OptionCommand.FinishQuest:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								int stableHashCode = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								if (Quests_DataTypes.AllQuests.ContainsKey(stableHashCode))
								{
									Quests_DataTypes.Quest.RemoveQuestComplete(stableHashCode);
									Quests_UIs.AcceptedQuestsUI.CheckQuests();
								}
							});
							break;
						case OptionCommand.PingMap:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_0049: Unknown result type (might be due to invalid IL or missing references)
								//IL_004b: Unknown result type (might be due to invalid IL or missing references)
								//IL_0050: Unknown result type (might be due to invalid IL or missing references)
								//IL_005b: Unknown result type (might be due to invalid IL or missing references)
								//IL_0061: Unknown result type (might be due to invalid IL or missing references)
								//IL_0066: Unknown result type (might be due to invalid IL or missing references)
								//IL_0078: Expected O, but got Unknown
								//IL_007d: Unknown result type (might be due to invalid IL or missing references)
								Vector3 val13 = default(Vector3);
								((Vector3)(ref val13))..ctor((float)int.Parse(split[2]), (float)int.Parse(split[3]), (float)int.Parse(split[4]));
								long num25 = Random.Range(-10000, 10000);
								Chat.instance.AddInworldText((GameObject)null, num25, val13, (Type)3, new UserInfo
								{
									Name = "",
									UserId = new PlatformUserID("")
								}, split[1]);
								Minimap.instance.ShowPointOnMap(val13);
								Minimap.instance.m_largeZoom = 0.1f;
							});
							break;
						case OptionCommand.AddPin:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								//IL_0036: Unknown result type (might be due to invalid IL or missing references)
								//IL_004a: Unknown result type (might be due to invalid IL or missing references)
								//IL_0050: Unknown result type (might be due to invalid IL or missing references)
								//IL_005c: Unknown result type (might be due to invalid IL or missing references)
								Vector3 val14 = default(Vector3);
								((Vector3)(ref val14))..ctor((float)int.Parse(split[2]), (float)int.Parse(split[3]), (float)int.Parse(split[4]));
								Minimap.instance.AddPin(val14, (PinType)175, split[1], true, false, 0L, default(PlatformUserID));
								Minimap.instance.ShowPointOnMap(val14);
								Minimap.instance.m_largeZoom = 0.1f;
							});
							break;
						case OptionCommand.AddEpicMMOExp:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								int value8 = int.Parse(split[1]);
								EpicMMOSystem_API.AddExp(value8);
							});
							break;
						case OptionCommand.AddRustyClassesEXP:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								int amount = int.Parse(split[1]);
								RustyClassesAPI.AddEXP(amount);
							});
							break;
						case OptionCommand.SendWebhook:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								string link = "https://" + split[1];
								if (Uri.TryCreate(link, UriKind.Absolute, out Uri _))
								{
									string text22 = split[2];
									foreach (KeyValuePair<string, Func<string>> replacement in Dialogues_UI._replacements)
									{
										text22 = text22.Replace(replacement.Key, replacement.Value());
									}
									Task.Run(async delegate
									{
										string value9 = "{\"username\":\"Dialogue Webhook\",\"content\":\"" + text22 + "\"}";
										HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(link);
										httpWebRequest.ContentType = "application/json";
										httpWebRequest.Method = "POST";
										using (StreamWriter streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
										{
											await streamWriter.WriteAsync(value9);
										}
										await httpWebRequest.GetResponseAsync();
									});
								}
							});
							break;
						case OptionCommand.AddCozyheimExp:
							action = (Action<Market_NPC.NPCcomponent>)Delegate.Combine(action, (Action<Market_NPC.NPCcomponent>)delegate
							{
								int amount2 = int.Parse(split[1]);
								Cozyheim_LevelingSystem.AddExp(amount2);
							});
							break;
						}
					}
					catch (Exception arg)
					{
						Utils.print($"Error while parsing dialogue command ({command}):\n{arg}");
					}
				}
				return action;
			}

			public static Dialogue_Condition CombineOrConditions(IEnumerable<string[]> allConditions, bool isQuest = false)
			{
				Dialogue_Condition dialogue_Condition = null;
				foreach (string[] allCondition in allConditions)
				{
					List<Dialogue_Condition> orConditions = new List<Dialogue_Condition>();
					for (int i = 0; i < allCondition.Length; i++)
					{
						Dialogue_Condition dialogue_Condition2 = ParseCondition(allCondition[i], isQuest);
						if (dialogue_Condition2 != null)
						{
							orConditions.Add(dialogue_Condition2);
						}
					}
					if (orConditions.Count == 1)
					{
						dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, orConditions[0]);
					}
					else
					{
						if (orConditions.Count <= 1)
						{
							continue;
						}
						dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
						{
							string text = "";
							OptionCondition optionCondition = OptionCondition.None;
							foreach (Dialogue_Condition item in orConditions)
							{
								if (item(npc, out reason, out type))
								{
									return true;
								}
								text = reason;
								optionCondition = type;
							}
							reason = text;
							type = optionCondition;
							return false;
						});
					}
				}
				return dialogue_Condition;
			}

			public static Dialogue_Condition ParseCondition(string condition, bool isQuest = false)
			{
				Dialogue_Condition dialogue_Condition = null;
				if (string.IsNullOrWhiteSpace(condition))
				{
					return null;
				}
				try
				{
					string[] split = condition.Replace(":", ",").Split(new char[1] { ',' });
					bool flag = false;
					if (split[0][0] == '!')
					{
						flag = true;
						split[0] = split[0].Substring(1);
					}
					if (Enum.TryParse<OptionCondition>(split[0], ignoreCase: true, out var result))
					{
						if (flag)
						{
							result = result.Reverse();
						}
						switch (result)
						{
						case OptionCondition.None:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								reason = "";
								type = OptionCondition.None;
								return true;
							});
							break;
						case OptionCondition.IsVIP:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.IsVIP;
								reason = Localization.instance.Localize("$mpasn_onlyforvip") ?? "";
								return Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(Global_Configs._localUserID);
							});
							break;
						case OptionCondition.CustomValueMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.CustomValueMore;
								string key2 = split[1];
								reason = string.Format("{0}: <color=#00ff00>{1}. Current: {2}</color>", Localization.instance.Localize("$mpasn_needcustomvalue"), split[1], Player.m_localPlayer.GetCustomValue(key2));
								return Player.m_localPlayer.GetCustomValue(key2) >= int.Parse(split[2]);
							});
							break;
						case OptionCondition.CustomValueLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.CustomValueLess;
								string key = split[1];
								reason = string.Format("{0}: <color=#00ff00>{1}. Current: {2}</color>", Localization.instance.Localize("$mpasn_dontneedcustomvalue"), split[1], Player.m_localPlayer.GetCustomValue(key));
								return Player.m_localPlayer.GetCustomValue(key) < int.Parse(split[2]);
							});
							break;
						case OptionCondition.NotIsVIP:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotIsVIP;
								reason = Localization.instance.Localize("$mpasn_notforvip") ?? "";
								return !Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(Global_Configs._localUserID);
							});
							break;
						case OptionCondition.RustyClassesLevelMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.RustyClassesLevelMore;
								int num = int.Parse(split[1]);
								int level = RustyClassesAPI.GetLevel();
								reason = string.Format("{0} <color=#00ff00>{1}</color>. Current: <color=#00ff00>{2}</color>", Localization.instance.Localize("$mpasn_needrustyclasseslevel"), num, level);
								return level >= num;
							});
							break;
						case OptionCondition.RustyClassesLevelLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.RustyClassesLevelLess;
								int num2 = int.Parse(split[1]);
								int level2 = RustyClassesAPI.GetLevel();
								reason = string.Format("{0} <color=#00ff00>{1}</color>. Current: <color=#00ff00>{2}</color>", Localization.instance.Localize("$mpasn_needrustyclasseslevel"), num2, level2);
								return level2 < num2;
							});
							break;
						case OptionCondition.HasGuild:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								reason = "$mpasn_noguild".Localize();
								type = OptionCondition.HasGuild;
								return Guilds.API.GetOwnGuild() != null;
							});
							break;
						case OptionCondition.NotHasGuild:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								reason = "$mpasn_hasguild".Localize();
								type = OptionCondition.NotHasGuild;
								return Guilds.API.GetOwnGuild() == null;
							});
							break;
						case OptionCondition.GuildLevelMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.GuildLevelMore;
								int num3 = int.Parse(split[1]);
								int num4 = Guilds.API.GetOwnGuild()?.General.level ?? int.MinValue;
								reason = string.Format("{0} <color=#00ff00>{1}</color>. Current: <color=#00ff00>{2}</color>", Localization.instance.Localize("$mpasn_needguildlevelmore"), num3, num4);
								return num4 >= num3;
							});
							break;
						case OptionCondition.GuildLevelLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.GuildLevelLess;
								int num5 = int.Parse(split[1]);
								int num6 = Guilds.API.GetOwnGuild()?.General.level ?? int.MaxValue;
								reason = string.Format("{0} <color=#00ff00>{1}</color>. Current: <color=#00ff00>{2}</color>", Localization.instance.Localize("$mpasn_needguildlevelless"), num5, num6);
								return num6 < num5;
							});
							break;
						case OptionCondition.HasGuildWithName:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasGuildWithName;
								reason = Localization.instance.Localize("$mpasn_needguildname") + ": <color=#00ff00>" + split[1] + "</color>";
								Guild ownGuild = Guilds.API.GetOwnGuild();
								return ownGuild != null && ownGuild.Name == split[1];
							});
							break;
						case OptionCondition.NotHasGuildWithName:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasGuildWithName;
								reason = Localization.instance.Localize("$mpasn_dontneedguildname") + ": <color=#00ff00>" + split[1] + "</color>";
								Guild ownGuild2 = Guilds.API.GetOwnGuild();
								return ownGuild2 == null || ownGuild2.Name != split[1];
							});
							break;
						case OptionCondition.GuildHasAchievement:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.GuildHasAchievement;
								reason = Localization.instance.Localize("$mpasn_needguildachievement") + ": <color=#00ff00>" + split[1] + "</color>";
								return Guilds.API.GetOwnGuild()?.Achievements.ContainsKey(split[1]) ?? false;
							});
							break;
						case OptionCondition.GuildNotHasAchievement:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.GuildNotHasAchievement;
								reason = Localization.instance.Localize("$mpasn_dontneedguildachievement") + ": <color=#00ff00>" + split[1] + "</color>";
								Guild ownGuild3 = Guilds.API.GetOwnGuild();
								return ownGuild3 == null || !ownGuild3.Achievements.ContainsKey(split[1]);
							});
							break;
						case OptionCondition.IronGateStatMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								//IL_003c: Unknown result type (might be due to invalid IL or missing references)
								reason = "";
								type = OptionCondition.IronGateStatMore;
								if (!Enum.TryParse<PlayerStatType>(split[1], ignoreCase: true, out PlayerStatType result2))
								{
									return false;
								}
								int num7 = int.Parse(split[2]);
								float num8 = Game.instance.m_playerProfile.m_playerStats[result2];
								reason = string.Format("{0}: <color=#00ff00>{1} x{2}</color>. Current: <color=#00ff00>{3}</color>", Localization.instance.Localize("$mpasn_needIronGateStatMore"), ((object)(PlayerStatType)(ref result2)).ToString().BigLettersToSpaces(), num7, (int)num8);
								return num8 >= (float)num7;
							});
							break;
						case OptionCondition.IronGateStatLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								//IL_003f: Unknown result type (might be due to invalid IL or missing references)
								reason = "";
								type = OptionCondition.IronGateStatLess;
								if (!Enum.TryParse<PlayerStatType>(split[1], ignoreCase: true, out PlayerStatType result3))
								{
									return false;
								}
								int num9 = int.Parse(split[2]);
								float num10 = Game.instance.m_playerProfile.m_playerStats[result3];
								reason = string.Format("{0}: <color=#00ff00>{1} x{2}</color>. <color=#00ff00>Current: {3}</color>", Localization.instance.Localize("$mpasn_needIronGateStatLess"), ((object)(PlayerStatType)(ref result3)).ToString().BigLettersToSpaces(), num9, (int)num10);
								return num10 < (float)num9;
							});
							break;
						case OptionCondition.ModInstalled:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.ModInstalled;
								string key3 = split[1];
								reason = Localization.instance.Localize("$mpasn_needmodinstalled") + ": <color=#00ff00>" + split[1] + "</color>";
								return Chainloader.PluginInfos.ContainsKey(key3);
							});
							break;
						case OptionCondition.NotModInstalled:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotModInstalled;
								string key4 = split[1];
								reason = Localization.instance.Localize("$mpasn_dontneedmodinstalled") + ": <color=#00ff00>" + split[1] + "</color>";
								return !Chainloader.PluginInfos.ContainsKey(key4);
							});
							break;
						case OptionCondition.HasAchievement:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasAchievement;
								reason = Localization.instance.Localize("$mpasn_needtitle") + ": <color=#00ff00>" + LeaderBoard_Main_Client.GetAchievementName(split[1]) + "</color>";
								return LeaderBoard_Main_Client.HasAchievement(split[1]);
							});
							break;
						case OptionCondition.NotHasAchievement:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasAchievement;
								reason = Localization.instance.Localize("$mpasn_dontneedtitle") + ": <color=#00ff00>" + LeaderBoard_Main_Client.GetAchievementName(split[1]) + "</color>";
								return !LeaderBoard_Main_Client.HasAchievement(split[1]);
							});
							break;
						case OptionCondition.HasAchievementScore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasAchievementScore;
								reason = Localization.instance.Localize("$mpasn_needtitlescore") + ": <color=#00ff00>" + split[1] + "</color>";
								Leaderboard_DataTypes.Client_Leaderboard value;
								return Leaderboard_DataTypes.SyncedClientLeaderboard.Value.TryGetValue(Global_Configs._localUserID + "_" + Game.instance.m_playerProfile.m_playerName, out value) && Leaderboard_UI.GetAchievementScore(value.Achievements) >= int.Parse(split[1]);
							});
							break;
						case OptionCondition.NotHasAchievementScore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasAchievementScore;
								reason = Localization.instance.Localize("$mpasn_dontneedtitlescore") + ": <color=#00ff00>" + split[1] + "</color>";
								Leaderboard_DataTypes.Client_Leaderboard value2;
								return Leaderboard_DataTypes.SyncedClientLeaderboard.Value.TryGetValue(Global_Configs._localUserID + "_" + Game.instance.m_playerProfile.m_playerName, out value2) && Leaderboard_UI.GetAchievementScore(value2.Achievements) < int.Parse(split[1]);
							});
							break;
						case OptionCondition.SkillMore:
						case OptionCondition.Skill:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.SkillMore;
								reason = Localization.instance.Localize("$mpasn_notenoughskilllevel") + ": <color=#00ff00>" + Utils.LocalizeSkill(split[1]) + " " + split[2] + "</color>";
								return Utils.GetPlayerSkillLevelCustom(split[1]) >= (float)int.Parse(split[2]);
							});
							break;
						case OptionCondition.SkillLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.SkillLess;
								reason = Localization.instance.Localize("$mpasn_toomuchskilllevel") + ": <color=#00ff00>" + Utils.LocalizeSkill(split[1]) + " " + split[2] + "</color>";
								return Utils.GetPlayerSkillLevelCustom(split[1]) < (float)int.Parse(split[2]);
							});
							break;
						case OptionCondition.QuestFinished:
						case OptionCondition.OtherQuest:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.QuestFinished;
								reason = "";
								int stableHashCode = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								if (!Quests_DataTypes.AllQuests.ContainsKey(stableHashCode))
								{
									return true;
								}
								reason = Localization.instance.Localize("$mpasn_needtofinishquest") + ": <color=#00ff00>" + Quests_DataTypes.AllQuests[stableHashCode].Name + "</color>";
								int left;
								return Quests_DataTypes.Quest.IsOnCooldown(stableHashCode, out left);
							});
							break;
						case OptionCondition.NotFinished:
						case OptionCondition.QuestNotFinished:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.QuestNotFinished;
								reason = "";
								int stableHashCode2 = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								Quests_DataTypes.Quest value3;
								int left2;
								return !Quests_DataTypes.AllQuests.TryGetValue(stableHashCode2, out value3) || !Quests_DataTypes.Quest.IsOnCooldown(stableHashCode2, out left2);
							});
							break;
						case OptionCondition.HasItem:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasItem;
								reason = "";
								GameObject prefab = ZNetScene.instance.GetPrefab(split[1]);
								if (!Object.op_Implicit((Object)(object)prefab) || !Object.op_Implicit((Object)(object)prefab.GetComponent<ItemDrop>()))
								{
									return true;
								}
								reason = Localization.instance.Localize("$mpasn_needhasitem") + ": <color=#00ff00>" + Localization.instance.Localize(prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name) + " x" + split[2] + "</color>";
								int level3 = ((split.Length <= 3) ? 1 : int.Parse(split[3]));
								return Utils.CustomCountItems(split[1], level3) >= int.Parse(split[2]);
							});
							break;
						case OptionCondition.NotHasItem:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasItem;
								reason = "";
								GameObject prefab2 = ZNetScene.instance.GetPrefab(split[1]);
								if (!Object.op_Implicit((Object)(object)prefab2) || !Object.op_Implicit((Object)(object)prefab2.GetComponent<ItemDrop>()))
								{
									return true;
								}
								reason = Localization.instance.Localize("$mpasn_neednothasitem") + ": <color=#00ff00>" + Localization.instance.Localize(prefab2.GetComponent<ItemDrop>().m_itemData.m_shared.m_name) + " x" + split[2] + "</color>";
								int level4 = ((split.Length <= 3) ? 1 : int.Parse(split[3]));
								return Utils.CustomCountItems(split[1], level4) < int.Parse(split[2]);
							});
							break;
						case OptionCondition.NPCModelEquals:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NPCModelEquals;
								reason = "";
								return Object.op_Implicit((Object)(object)npc) && npc.LocalModelOverride == split[1];
							});
							break;
						case OptionCondition.NotNPCModelEquals:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotNPCModelEquals;
								reason = "";
								return Object.op_Implicit((Object)(object)npc) && npc.LocalModelOverride != split[1];
							});
							break;
						case OptionCondition.NPCNameEquals:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NPCNameEquals;
								reason = "";
								return Object.op_Implicit((Object)(object)npc) && npc.GetNPCName() == split[1];
							});
							break;
						case OptionCondition.HasFaction:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasFaction;
								reason = Localization.instance.Localize("$mpasn_needfaction") + ": <color=#00ff00>" + split[1] + "</color>";
								string value4;
								return Object.op_Implicit((Object)(object)Player.m_localPlayer) && Player.m_localPlayer.m_customData.TryGetValue("MPASN_Faction", out value4) && value4 == split[1].ToLower();
							});
							break;
						case OptionCondition.NotHasFaction:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasFaction;
								reason = Localization.instance.Localize("$mpasn_dontneedfaction") + ": <color=#00ff00>" + split[1] + "</color>";
								string value5;
								return Object.op_Implicit((Object)(object)Player.m_localPlayer) && (!Player.m_localPlayer.m_customData.TryGetValue("MPASN_Faction", out value5) || value5 != split[1].ToLower());
							});
							break;
						case OptionCondition.HasAnyFaction:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasAnyFaction;
								reason = Localization.instance.Localize("$mpasn_needanyfaction") + ": <color=#00ff00>" + split[1] + "</color>";
								string value6;
								return Object.op_Implicit((Object)(object)Player.m_localPlayer) && Player.m_localPlayer.m_customData.TryGetValue("MPASN_Faction", out value6) && Factions_DataTypes.SyncedFactions.Value.ContainsKey(value6);
							});
							break;
						case OptionCondition.NotHasAnyFaction:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasAnyFaction;
								reason = Localization.instance.Localize("$mpasn_dontneedanyfaction") + ": <color=#00ff00>" + split[1] + "</color>";
								string value7;
								return Object.op_Implicit((Object)(object)Player.m_localPlayer) && (!Player.m_localPlayer.m_customData.TryGetValue("MPASN_Faction", out value7) || !Factions_DataTypes.SyncedFactions.Value.ContainsKey(value7));
							});
							break;
						case OptionCondition.NotNPCNameEquals:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotNPCNameEquals;
								reason = "";
								return Object.op_Implicit((Object)(object)npc) && npc.GetNPCName() != split[1];
							});
							break;
						case OptionCondition.GlobalKey:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.GlobalKey;
								reason = Localization.instance.Localize("$mpasn_needglobalkey") + ": <color=#00ff00>" + split[1] + "</color>";
								return ZoneSystem.instance.GetGlobalKey(split[1]);
							});
							break;
						case OptionCondition.NotGlobalKey:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotGlobalKey;
								reason = Localization.instance.Localize("$mpasn_notneedglobalkey") + ": <color=#00ff00>" + split[1] + "</color>";
								return !ZoneSystem.instance.GetGlobalKey(split[1]);
							});
							break;
						case OptionCondition.HasPlayerKey:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasPlayerKey;
								reason = Localization.instance.Localize("$mpasn_needplayerkey") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Humanoid)Player.m_localPlayer).HaveUniqueKey(split[1]);
							});
							break;
						case OptionCondition.NotHasPlayerKey:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasPlayerKey;
								reason = Localization.instance.Localize("$mpasn_notneedplayerkey") + ": <color=#00ff00>" + split[1] + "</color>";
								return !((Humanoid)Player.m_localPlayer).HaveUniqueKey(split[1]);
							});
							break;
						case OptionCondition.HasBuff:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasBuff;
								StatusEffect val = ((IEnumerable<StatusEffect>)ObjectDB.instance.m_StatusEffects).FirstOrDefault((Func<StatusEffect, bool>)((StatusEffect s) => ((Object)s).name == split[1]));
								string text = (((Object)(object)val == (Object)null) ? split[1] : Localization.instance.Localize(val.m_name));
								reason = Localization.instance.Localize("$mpasn_needhasbuff") + ": <color=#00ff00>" + text + "</color>";
								return ((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(StringExtensionMethods.GetStableHashCode(split[1]));
							});
							break;
						case OptionCondition.NotHasBuff:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasBuff;
								StatusEffect val2 = ((IEnumerable<StatusEffect>)ObjectDB.instance.m_StatusEffects).FirstOrDefault((Func<StatusEffect, bool>)((StatusEffect s) => ((Object)s).name == split[1]));
								string text2 = (((Object)(object)val2 == (Object)null) ? split[1] : Localization.instance.Localize(val2.m_name));
								reason = Localization.instance.Localize("$mpasn_notneedhasbuff") + ": <color=#00ff00>" + text2 + "</color>";
								return !((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(StringExtensionMethods.GetStableHashCode(split[1]));
							});
							break;
						case OptionCondition.QuestProgressDone:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.QuestProgressDone;
								reason = "";
								int stableHashCode3 = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								if (!Quests_DataTypes.AllQuests.TryGetValue(stableHashCode3, out Quests_DataTypes.Quest value8) || !Quests_DataTypes.AcceptedQuests.ContainsKey(stableHashCode3))
								{
									return false;
								}
								reason = Localization.instance.Localize("$mpasn_queststillnotfinished") + ": <color=#00ff00>" + value8.Name + "</color>";
								return Quests_DataTypes.AllQuests[stableHashCode3].IsComplete();
							});
							break;
						case OptionCondition.QuestProgressNotDone:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.QuestProgressNotDone;
								reason = "";
								int stableHashCode4 = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								if (!Quests_DataTypes.AllQuests.TryGetValue(stableHashCode4, out Quests_DataTypes.Quest value9) || !Quests_DataTypes.AcceptedQuests.ContainsKey(stableHashCode4))
								{
									return false;
								}
								reason = Localization.instance.Localize("$mpasn_questalreadyfinished") + ": <color=#00ff00>" + value9.Name + "</color>";
								return !Quests_DataTypes.AllQuests[stableHashCode4].IsComplete();
							});
							break;
						case OptionCondition.HasQuest:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HasQuest;
								reason = "";
								int stableHashCode5 = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								if (!Quests_DataTypes.AllQuests.TryGetValue(stableHashCode5, out Quests_DataTypes.Quest value10))
								{
									return false;
								}
								reason = Localization.instance.Localize("$mpasn_questnottaken") + ": <color=#00ff00>" + value10.Name + "</color>";
								return Quests_DataTypes.AcceptedQuests.ContainsKey(stableHashCode5);
							});
							break;
						case OptionCondition.NotHasQuest:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.NotHasQuest;
								reason = "";
								int stableHashCode6 = StringExtensionMethods.GetStableHashCode(split[1].ToLower());
								if (!Quests_DataTypes.AllQuests.TryGetValue(stableHashCode6, out Quests_DataTypes.Quest value11))
								{
									return false;
								}
								reason = Localization.instance.Localize("$mpasn_questtaken") + ": <color=#00ff00>" + value11.Name + "</color>";
								return !Quests_DataTypes.AcceptedQuests.ContainsKey(stableHashCode6);
							});
							break;
						case OptionCondition.EpicMMOLevelMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.EpicMMOLevelMore;
								reason = Localization.instance.Localize("$mpasn_needepicmmolevel") + ": <color=#00ff00>" + split[1] + "</color>";
								return EpicMMOSystem_API.GetLevel() >= int.Parse(split[1]);
							});
							break;
						case OptionCondition.EpicMMOLevelLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.EpicMMOLevelLess;
								reason = Localization.instance.Localize("$mpasn_toomuchepicmmolevel") + ": <color=#00ff00>" + split[1] + "</color>";
								return EpicMMOSystem_API.GetLevel() < int.Parse(split[1]);
							});
							break;
						case OptionCondition.CozyheimLevelMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.CozyheimLevelMore;
								reason = Localization.instance.Localize("$mpasn_needcozyheimlevel") + ": <color=#00ff00>" + split[1] + "</color>";
								return Cozyheim_LevelingSystem.GetLevel() >= int.Parse(split[1]);
							});
							break;
						case OptionCondition.CozyheimLevelLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.CozyheimLevelLess;
								reason = Localization.instance.Localize("$mpasn_toomuchcozyheimlevel") + ": <color=#00ff00>" + split[1] + "</color>";
								return Cozyheim_LevelingSystem.GetLevel() < int.Parse(split[1]);
							});
							break;
						case OptionCondition.HealthMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HealthMore;
								reason = Localization.instance.Localize("$mpasn_needcurrenthealthmore") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetHealth() >= (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.HealthLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.HealthLess;
								reason = Localization.instance.Localize("$mpasn_needcurrenthealthless") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetHealth() < (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.StaminaMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.StaminaMore;
								reason = Localization.instance.Localize("$mpasn_needcurrentstaminamore") + ": <color=#00ff00>" + split[1] + "</color>";
								return Player.m_localPlayer.GetStamina() >= (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.StaminaLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.StaminaLess;
								reason = Localization.instance.Localize("$mpasn_needcurrentstaminaless") + ": <color=#00ff00>" + split[1] + "</color>";
								return Player.m_localPlayer.GetStamina() < (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.EitrLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.EitrLess;
								reason = Localization.instance.Localize("$mpasn_needcurrenteitrless") + ": <color=#00ff00>" + split[1] + "</color>";
								return Player.m_localPlayer.GetEitr() < (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.EitrMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.EitrMore;
								reason = Localization.instance.Localize("$mpasn_needcurrenteitrmore") + ": <color=#00ff00>" + split[1] + "</color>";
								return Player.m_localPlayer.GetEitr() >= (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.MaxHealthMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.MaxHealthMore;
								reason = Localization.instance.Localize("$mpasn_needmaxhealthmore") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetMaxHealth() >= (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.MaxHealthLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.MaxHealthLess;
								reason = Localization.instance.Localize("$mpasn_needmaxhealthless") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetMaxHealth() < (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.MaxStaminaMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.MaxStaminaMore;
								reason = Localization.instance.Localize("$mpasn_needmaxstaminamore") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetMaxStamina() >= (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.MaxStaminaLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.MaxStaminaLess;
								reason = Localization.instance.Localize("$mpasn_needmaxstaminaless") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetMaxStamina() < (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.MaxEitrMore:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.MaxEitrMore;
								reason = Localization.instance.Localize("$mpasn_needmaxeitrmore") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetMaxEitr() >= (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.MaxEitrLess:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.MaxEitrLess;
								reason = Localization.instance.Localize("$mpasn_needmaxeitrless") + ": <color=#00ff00>" + split[1] + "</color>";
								return ((Character)Player.m_localPlayer).GetMaxEitr() < (float)int.Parse(split[1]);
							});
							break;
						case OptionCondition.PlayerHasAllCustomDataKeys:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.PlayerHasAllCustomDataKeys;
								string key5 = split[1];
								if (!CustomSpawnZDOData_Synced.Value.TryGetValue(key5, out CustomSpawnZDO value12))
								{
									reason = "No custom data found";
									return false;
								}
								reason = split[2];
								foreach (KeyValuePair<string, bool> @bool in value12.Bools)
								{
									if (((Character)Player.m_localPlayer).m_nview.m_zdo.GetBool(@bool.Key, false) != @bool.Value)
									{
										return false;
									}
								}
								foreach (KeyValuePair<string, float> @float in value12.Floats)
								{
									if (Math.Abs(((Character)Player.m_localPlayer).m_nview.m_zdo.GetFloat(@float.Key, 0f) - @float.Value) > 0.01f)
									{
										return false;
									}
								}
								foreach (KeyValuePair<string, int> @int in value12.Ints)
								{
									if (((Character)Player.m_localPlayer).m_nview.m_zdo.GetInt(@int.Key, 0) != @int.Value)
									{
										return false;
									}
								}
								foreach (KeyValuePair<string, string> @string in value12.Strings)
								{
									if (((Character)Player.m_localPlayer).m_nview.m_zdo.GetString(@string.Key, "") != @string.Value)
									{
										return false;
									}
								}
								return true;
							});
							break;
						case OptionCondition.PlayerHasOneOfCustomDataKeys:
							dialogue_Condition = (Dialogue_Condition)Delegate.Combine(dialogue_Condition, (Dialogue_Condition)delegate(Market_NPC.NPCcomponent npc, out string reason, out OptionCondition type)
							{
								type = OptionCondition.PlayerHasOneOfCustomDataKeys;
								string key6 = split[1];
								if (!CustomSpawnZDOData_Synced.Value.TryGetValue(key6, out CustomSpawnZDO value13))
								{
									reason = "No custom data found";
									return false;
								}
								reason = split[2];
								foreach (KeyValuePair<string, bool> bool2 in value13.Bools)
								{
									if (((Character)Player.m_localPlayer).m_nview.m_zdo.GetBool(bool2.Key, false) != bool2.Value)
									{
										return true;
									}
								}
								foreach (KeyValuePair<string, float> float2 in value13.Floats)
								{
									if (Math.Abs(((Character)Player.m_localPlayer).m_nview.m_zdo.GetFloat(float2.Key, 0f) - float2.Value) > 0.01f)
									{
										return true;
									}
								}
								foreach (KeyValuePair<string, int> int2 in value13.Ints)
								{
									if (((Character)Player.m_localPlayer).m_nview.m_zdo.GetInt(int2.Key, 0) != int2.Value)
									{
										return true;
									}
								}
								foreach (KeyValuePair<string, string> string2 in value13.Strings)
								{
									if (((Character)Player.m_localPlayer).m_nview.m_zdo.GetString(string2.Key, "") != string2.Value)
									{
										return true;
									}
								}
								return false;
							});
							break;
						}
					}
				}
				catch (Exception arg)
				{
					Utils.print(string.Format("Error while parsing {0} condition ({1}):\n{2}", isQuest ? "Quest" : "Dialogue", condition, arg));
				}
				return dialogue_Condition;
			}

			public static implicit operator Dialogue(RawDialogue raw)
			{
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				Dialogue dialogue = new Dialogue();
				dialogue.Text = raw.Text;
				dialogue.Interactions = new PlayerInteraction[raw.Interactions.Length];
				dialogue.BG_Image = Utils.TryFindIcon(raw.BG_Image);
				Dialogue dialogue2 = dialogue;
				for (int i = 0; i < raw.Interactions.Length; i++)
				{
					dialogue2.Interactions[i] = new PlayerInteraction
					{
						Type = raw.Interactions[i].Type,
						Text = raw.Interactions[i].Text,
						Icon = Utils.TryFindIcon(raw.Interactions[i].Icon),
						NextUID = raw.Interactions[i].NextUID,
						RandomTransition = raw.Interactions[i].RandomTransition,
						Conditions = CombineOrConditions(raw.Interactions[i].Conditions),
						Command = ParseCommands(raw.Interactions[i].Commands),
						RandomCommands = raw.Interactions[i].RandomCommands.ToDictionary<KeyValuePair<int, string>, int, Action<Market_NPC.NPCcomponent>>((KeyValuePair<int, string> entry) => entry.Key, (KeyValuePair<int, string> entry) => ParseCommands(new <>z__ReadOnlySingleElementList<string>(entry.Value))),
						AlwaysVisible = raw.Interactions[i].AlwaysVisible,
						Color = Color32.op_Implicit(raw.Interactions[i].Color),
						OverrideError = raw.Interactions[i].OverrideError
					};
				}
				return dialogue2;
			}
		}

		public class DialoguePassword : TextReceiver
		{
			private string _password;

			private string _onSuccess;

			private string _onFail;

			private Market_NPC.NPCcomponent _npc;

			public DialoguePassword(Market_NPC.NPCcomponent npc, string title, string password, string onSuccess, string onFail)
			{
				_password = password;
				_onSuccess = onSuccess;
				_onFail = onFail;
				_npc = npc;
				TextInput.instance.RequestText((TextReceiver)(object)this, title, 30);
			}

			public string GetText()
			{
				return "";
			}

			public void SetText(string text)
			{
				if (text == _password)
				{
					if (!string.IsNullOrEmpty(_onSuccess))
					{
						Dialogues_UI.LoadDialogue(_npc, _onSuccess.ToLower());
					}
				}
				else if (!string.IsNullOrEmpty(_onFail))
				{
					Dialogues_UI.LoadDialogue(_npc, _onFail.ToLower());
				}
			}
		}

		internal static readonly CustomSyncedValue<List<RawDialogue>> SyncedDialoguesData = new CustomSyncedValue<List<RawDialogue>>(Marketplace.configSync, "dialoguesData", new List<RawDialogue>());

		internal static readonly Dictionary<string, Dialogue> ClientReadyDialogues = new Dictionary<string, Dialogue>();

		public static CustomSyncedValue<Dictionary<string, CustomSpawnZDO>> CustomSpawnZDOData_Synced = new CustomSyncedValue<Dictionary<string, CustomSpawnZDO>>(Marketplace.configSync, "customSpawnZDOData", new Dictionary<string, CustomSpawnZDO>());

		private const byte reverseFlag = 128;

		private static OptionCondition Reverse(this OptionCondition condition)
		{
			return condition ^ (OptionCondition)128;
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Dialogues_Main_Client
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		[HarmonyPriority(-10000)]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				InitDialogues();
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			Dialogues_UI.Init();
			Dialogues_DataTypes.SyncedDialoguesData.ValueChanged += InitDialogues;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Dialogues_UI.IsVisible())
			{
				Dialogues_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		private static void InitDialogues()
		{
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			Dialogues_DataTypes.ClientReadyDialogues.Clear();
			foreach (Dialogues_DataTypes.RawDialogue item in Dialogues_DataTypes.SyncedDialoguesData.Value)
			{
				Dialogues_DataTypes.ClientReadyDialogues[item.UID] = item;
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "DI", "DSCD" }, new string[] { "OnDialoguesChange", "OnCustomSpawnDataChange" })]
	public class Dialogues_Main_Server
	{
		private enum InputType
		{
			Text,
			Transition,
			Command,
			RandomCommand,
			Icon,
			Condition,
			AlwaysVisible,
			Color,
			RandomTransition,
			OverrideError
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			ReadDialoguesData();
			ReadCustomSpawnData();
		}

		private static void ProcessDialogueProfiles(string fPath, IReadOnlyList<string> profiles)
		{
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			Dialogues_DataTypes.RawDialogue rawDialogue = null;
			List<Dialogues_DataTypes.RawDialogue.RawPlayerOption> list = null;
			for (int i = 0; i < profiles.Count; i++)
			{
				try
				{
					if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
					{
						continue;
					}
					if (profiles[i].StartsWith("["))
					{
						if (rawDialogue != null)
						{
							rawDialogue.Interactions = list.ToArray();
							Dialogues_DataTypes.SyncedDialoguesData.Value.Add(rawDialogue);
							rawDialogue = null;
						}
						string[] array = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
							.Split(new char[1] { '=' });
						rawDialogue = new Dialogues_DataTypes.RawDialogue
						{
							UID = array[0].ToLower(),
							BG_Image = ((array.Length > 1) ? array[1] : null)
						};
						list = new List<Dialogues_DataTypes.RawDialogue.RawPlayerOption>();
					}
					else
					{
						if (rawDialogue == null)
						{
							continue;
						}
						if (rawDialogue.Text == null)
						{
							rawDialogue.Text = profiles[i].Replace("\\n", "\n");
							continue;
						}
						Dialogues_DataTypes.RawDialogue.RawPlayerOption rawPlayerOption = new Dialogues_DataTypes.RawDialogue.RawPlayerOption();
						List<KeyValuePair<int, string>> list2 = new List<KeyValuePair<int, string>>();
						string text = profiles[i];
						if (text.StartsWith("@interaction"))
						{
							rawPlayerOption.Type = Dialogues_DataTypes.RawDialogue.InteractionType.Interaction;
							text = text.Replace("@interaction", "").Trim();
						}
						else if (text.StartsWith("@inrange"))
						{
							rawPlayerOption.Type = Dialogues_DataTypes.RawDialogue.InteractionType.InRange;
							text = text.Replace("@inrange", "").Trim();
						}
						else if (text.StartsWith("@outrange"))
						{
							rawPlayerOption.Type = Dialogues_DataTypes.RawDialogue.InteractionType.OutRange;
							text = text.Replace("@outrange", "").Trim();
						}
						List<string> list3 = new List<string>();
						List<string[]> list4 = new List<string[]>();
						string[] array2 = text.Split(new char[1] { '|' });
						string[] array3 = array2;
						foreach (string text2 in array3)
						{
							string[] array4 = text2.Split(new char[1] { ':' }, 2);
							if (array4.Length != 2 || !Enum.TryParse<InputType>(array4[0], ignoreCase: true, out var result))
							{
								continue;
							}
							switch (result)
							{
							case InputType.Text:
								rawPlayerOption.Text = array4[1].Trim().Replace("\\n", "\n");
								break;
							case InputType.Transition:
								rawPlayerOption.NextUID = array4[1].Replace(" ", "").ToLower();
								break;
							case InputType.RandomTransition:
								rawPlayerOption.RandomTransition = array4[1].Replace(" ", "").ToLower().Split(new char[1] { ',' });
								break;
							case InputType.Command:
								list3.Add(array4[1].ReplaceSpacesOutsideQuotes());
								break;
							case InputType.RandomCommand:
							{
								string[] array7 = array4[1].Split(new char[1] { ',' }, 2);
								if (array7.Length == 2 && int.TryParse(array7[0].Trim(), out var result2))
								{
									list2.Add(new KeyValuePair<int, string>(result2, array7[1].ReplaceSpacesOutsideQuotes()));
								}
								break;
							}
							case InputType.Condition:
							{
								List<string> list5 = new List<string>();
								string[] array6 = array4[1].ReplaceSpacesOutsideQuotes().Split(new string[1] { Global_Configs.OrConditionSeparator }, StringSplitOptions.RemoveEmptyEntries);
								foreach (string text3 in array6)
								{
									if (!string.IsNullOrWhiteSpace(text3))
									{
										list5.Add(text3);
									}
								}
								list4.Add(list5.ToArray());
								break;
							}
							case InputType.Icon:
								rawPlayerOption.Icon = array4[1].Replace(" ", "");
								break;
							case InputType.AlwaysVisible:
								rawPlayerOption.AlwaysVisible = bool.Parse(array4[1].Replace(" ", ""));
								break;
							case InputType.OverrideError:
								rawPlayerOption.OverrideError = array4[1].Trim();
								break;
							case InputType.Color:
							{
								string[] array5 = array4[1].Split(new char[1] { ',' });
								if (array5.Length == 3)
								{
									rawPlayerOption.Color = new Color32(byte.Parse(array5[0]), byte.Parse(array5[1]), byte.Parse(array5[2]), byte.MaxValue);
								}
								break;
							}
							}
						}
						rawPlayerOption.Commands = list3.ToArray();
						rawPlayerOption.Conditions = list4;
						rawPlayerOption.RandomCommands = list2;
						list.Add(rawPlayerOption);
						continue;
					}
				}
				catch (Exception ex)
				{
					Utils.print($"Error reading {fPath} (line {i + 1}):\n" + ex);
					break;
				}
			}
			if (rawDialogue != null)
			{
				rawDialogue.Interactions = list.ToArray();
				Dialogues_DataTypes.SyncedDialoguesData.Value.Add(rawDialogue);
			}
		}

		private static void ReadDialoguesData()
		{
			Dialogues_DataTypes.SyncedDialoguesData.Value.Clear();
			string dialoguesFolder = Market_Paths.DialoguesFolder;
			string[] files = Directory.GetFiles(dialoguesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ProcessDialogueProfiles(text, profiles);
			}
			Dialogues_DataTypes.SyncedDialoguesData.Update();
		}

		private static void ReadCustomSpawnData()
		{
			string dialoguesCustomSpawnDataFolder = Market_Paths.DialoguesCustomSpawnDataFolder;
			string[] files = Directory.GetFiles(dialoguesCustomSpawnDataFolder, "*.yml", SearchOption.AllDirectories);
			IDeserializer deserializer = new DeserializerBuilder().Build();
			Dictionary<string, Dialogues_DataTypes.CustomSpawnZDO> dictionary = new Dictionary<string, Dialogues_DataTypes.CustomSpawnZDO>();
			string[] array = files;
			foreach (string text in array)
			{
				try
				{
					string input = File.ReadAllText(text);
					Dialogues_DataTypes.CustomSpawnZDO value = deserializer.Deserialize<Dialogues_DataTypes.CustomSpawnZDO>(input);
					string key = Path.GetFileNameWithoutExtension(text).ToLower();
					dictionary[key] = value;
				}
				catch (Exception ex)
				{
					Utils.print("Error reading " + text + ":\n" + ex);
					return;
				}
			}
			Dialogues_DataTypes.CustomSpawnZDOData_Synced.Value = dictionary;
		}

		[UsedImplicitly]
		private static void OnDialoguesChange()
		{
			ReadDialoguesData();
			Utils.print("NpcDialogues changed, sending options to peers");
		}

		[UsedImplicitly]
		private static void OnCustomSpawnDataChange()
		{
			ReadCustomSpawnData();
			Utils.print("NpcDialogues CustomSpawnData changed, sending options to peers");
		}
	}
	public static class Dialogues_UI
	{
		private enum Fade
		{
			Show,
			Hide
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class BankerUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsVisible())
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		[ClientOnlyPatch]
		private static class Player_OnDeath_Patch
		{
			[UsedImplicitly]
			private static void Prefix()
			{
				Hide();
			}
		}

		[CompilerGenerated]
		private sealed class <HideCoroutine>d__21 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Hide();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <SmoothAlphaCoroutine>d__18 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Fade type;

			public float time;

			private float <start>5__2;

			private float <target>5__3;

			private float <counter>5__4;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<start>5__2 = ((type != Fade.Show) ? 1 : 0);
					CanvasAlpha.alpha = <start>5__2;
					<target>5__3 = ((type == Fade.Show) ? 1 : 0);
					<counter>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<counter>5__4 <= 1f)
				{
					if (!Object.op_Implicit((Object)(object)UI))
					{
						return false;
					}
					<counter>5__4 += Time.unscaledDeltaTime / time;
					float num = ((<counter>5__4 < 1f) ? (1f - Mathf.Pow(1f - <counter>5__4, 2f)) : 1f);
					CanvasAlpha.alpha = Mathf.Clamp01(Mathf.Lerp(<start>5__2, <target>5__3, num));
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				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();
			}
		}

		private static GameObject UI = null;

		private static GameObject Dialogue_Element = null;

		private static readonly List<GameObject> Elements = new List<GameObject>();

		private static Text NPC_Name = null;

		private static Text Dialogue_Text = null;

		private static Image BG_Image = null;

		private static Transform Content = null;

		private static CanvasGroup CanvasAlpha = null;

		private static readonly Dictionary<int, Action> HotbarActions = new Dictionary<int, Action>();

		private static readonly KeyCode[] hotbarKeys;

		private static Coroutine FadeCoroutine;

		public static Dictionary<string, Func<string>> _replacements;

		public static bool IsVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		private static void ResetFitters()
		{
			Canvas.ForceUpdateCanvases();
			ContentSizeFitter[] componentsInChildren = UI.GetComponentsInChildren<ContentSizeFitter>();
			foreach (ContentSizeFitter val in componentsInChildren)
			{
				((Behaviour)val).enabled = false;
				((Behaviour)val).enabled = true;
			}
		}

		public static void Init()
		{
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("NPCDialogueUI"));
			CanvasAlpha = UI.GetComponent<CanvasGroup>();
			Dialogue_Element = AssetStorage.asset.LoadAsset<GameObject>("Dialogue_Option");
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.SetActive(false);
			NPC_Name = ((Component)UI.transform.Find("GO/NPC_Name")).GetComponent<Text>();
			Dialogue_Text = ((Component)UI.transform.Find("GO/Dialogue_Text")).GetComponent<Text>();
			Content = UI.transform.Find("GO");
			BG_Image = ((Component)UI.transform.Find("GO/BACKGROUND")).GetComponent<Image>();
			Default();
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(PressHotbarUpdate));
		}

		private static void PressHotbarUpdate(float dt)
		{
			if (!IsVisible() || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			for (int i = 0; i < hotbarKeys.Length; i++)
			{
				if (Input.GetKeyDown(hotbarKeys[i]) && HotbarActions.TryGetValue(i + 1, out Action value))
				{
					value();
				}
			}
		}

		private static void Default()
		{
			foreach (GameObject element in Elements)
			{
				Object.Destroy((Object)(object)element);
			}
			Elements.Clear();
			NPC_Name.text = "";
			Dialogue_Text.text = "";
			HotbarActions.Clear();
		}

		private static void SmoothAlpha(Fade type, float time)
		{
			if (FadeCoroutine != null)
			{
				((MonoBehaviour)Marketplace._thistype).StopCoroutine(FadeCoroutine);
			}
			FadeCoroutine = ((MonoBehaviour)Marketplace._thistype).StartCoroutine(SmoothAlphaCoroutine(type, time));
		}

		[IteratorStateMachine(typeof(<SmoothAlphaCoroutine>d__18))]
		private static IEnumerator SmoothAlphaCoroutine(Fade type, float time)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SmoothAlphaCoroutine>d__18(0)
			{
				type = type,
				time = time
			};
		}

		public static void LoadDialogue(Market_NPC.NPCcomponent npc, string UID)
		{
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			Market_NPC.NPCcomponent npc2 = npc;
			Default();
			if (!Dialogues_DataTypes.ClientReadyDialogues.TryGetValue(UID, out Dialogues_DataTypes.Dialogue value))
			{
				Hide(nextFrame: true);
				return;
			}
			Dialogues_DataTypes.Dialogue.PlayerInteraction[] interactions = value.Interactions;
			foreach (Dialogues_DataTypes.Dialogue.PlayerInteraction playerInteraction in interactions)
			{
				if (playerInteraction.Type == Dialogues_DataTypes.RawDialogue.InteractionType.Interaction && playerInteraction.CheckCondition(npc2, out string _))
				{
					playerInteraction.CallCommands(npc2);
				}
			}
			if (value.Interactions.All((Dialogues_DataTypes.Dialogue.PlayerInteraction i) => i.Type != Dialogues_DataTypes.RawDialogue.InteractionType.Option))
			{
				return;
			}
			UI.SetActive(true);
			SmoothAlpha(Fade.Show, 0.5f);
			string text = "";
			if (Object.op_Implicit((Object)(object)npc2))
			{
				text = npc2.GetClearNPCName();
				if (string.IsNullOrWhiteSpace(text))
				{
					text = Localization.instance.Localize("$mpasn_" + npc2._currentNpcType);
				}
			}
			NPC_Name.text = text;
			Dialogue_Text.text = "\"" + Localization.instance.Localize(value.Text) + "\"";
			foreach (KeyValuePair<string, Func<string>> replacement in _replacements)
			{
				Dialogue_Text.text = Dialogue_Text.text.Replace(replacement.Key, replacement.Value());
			}
			if ((Object)(object)value.BG_Image != (Object)null)
			{
				BG_Image.sprite = value.BG_Image;
				((Component)BG_Image).gameObject.SetActive(true);
			}
			else
			{
				((Component)BG_Image).gameObject.SetActive(false);
			}
			int num = 0;
			Dialogues_DataTypes.Dialogue.PlayerInteraction[] interactions2 = value.Interactions;
			foreach (Dialogues_DataTypes.Dialogue.PlayerInteraction option in interactions2)
			{
				if (option.Type != 0)
				{
					continue;
				}
				bool flag = false;
				if (!option.CheckCondition(npc2, out string reason2))
				{
					if (!option.AlwaysVisible)
					{
						continue;
					}
					flag = true;
				}
				GameObject val = Object.Instantiate<GameObject>(Dialogue_Element, Content);
				Elements.Add(val);
				string text2 = option.Text;
				foreach (KeyValuePair<string, Func<string>> replacement2 in _replacements)
				{
					text2 = text2.Replace(replacement2.Key, replacement2.Value());
				}
				((Component)val.transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize(text2);
				Text component = ((Component)val.transform.Find("Indexer/Text")).GetComponent<Text>();
				int num2 = ++num;
				component.text = num2.ToString();
				if ((Object)(object)option.Icon != (Object)null)
				{
					((Component)val.transform.Find("Text/Icon")).GetComponent<Image>().sprite = option.Icon;
				}
				((Graphic)((Component)val.transform.Find("line")).GetComponent<Image>()).color = option.Color;
				((Graphic)((Component)val.transform.Find("Indexer/bg")).GetComponent<Image>()).color = option.Color;
				if (flag)
				{
					Object.Destroy((Object)(object)val.GetComponent<Button>());
					((Graphic)((Component)val.transform.Find("line")).GetComponent<Image>()).color = Color.red;
					((Graphic)((Component)val.transform.Find("Indexer/bg")).GetComponent<Image>()).color = Color.red;
					if (!string.IsNullOrWhiteSpace(reason2))
					{
						Text component2 = ((Component)val.transform.Find("Text")).GetComponent<Text>();
						component2.text += ("\n<color=red>[</color>" + reason2 + "<color=red>]</color>").Localize();
					}
				}
				else
				{
					HotbarActions[num] = OnClick;
					((UnityEvent)val.GetComponent<Button>().onClick).AddListener(new UnityAction(OnClick));
				}
				void OnClick()
				{
					AssetStorage.AUsrc.Play();
					if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
					{
						if (!option.CheckCondition(npc2, out string reason3))
						{
							if (!string.IsNullOrWhiteSpace(reason3))
							{
								MessageHud.instance.ShowMessage((MessageType)2, "<color=red>[</color>" + reason3 + "<color=red>]</color>", 0, (Sprite)null, false);
							}
						}
						else
						{
							option.CallCommands(npc2);
							string nextTransition = option.NextTransition;
							if (nextTransition != null)
							{
								LoadDialogue(npc2, nextTransition);
							}
							else
							{
								Hide(nextFrame: true);
							}
						}
					}
				}
			}
			ResetFitters();
		}

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

		public static void Hide(bool nextFrame = false)
		{
			if (IsVisible())
			{
				if (nextFrame)
				{
					((MonoBehaviour)Marketplace._thistype).StartCoroutine(HideCoroutine());
				}
				else
				{
					UI.SetActive(false);
				}
			}
		}

		static Dialogues_UI()
		{
			KeyCode[] array = new KeyCode[10];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			hotbarKeys = (KeyCode[])(object)array;
			_replacements = new Dictionary<string, Func<string>> { 
			{
				"%playername%",
				delegate
				{
					Player localPlayer = Player.m_localPlayer;
					return ((localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "Player";
				}
			} };
		}
	}
}
namespace Marketplace.Modules.MainMarketplace
{
	public static class JC_API_Class
	{
		public static void JC_Api_Tooltip(ItemData item, GameObject JC)
		{
			Jewelcrafting.API.FillItemContainerTooltip(item, JC.transform.parent, showInteract: false);
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Marketplace_Main_Server
	{
		[UsedImplicitly]
		private static void OnInit()
		{
		}

		[MarketplaceRPC("KGmarket ReceiveItem", Market_Autoload.Type.Server)]
		private static void ReceiveItemFromClient(long sender, string data)
		{
			if (data.Length <= 0)
			{
				return;
			}
			Marketplace_DataTypes.ClientMarketSendData clientMarketSendData = JSON.ToObject<Marketplace_DataTypes.ClientMarketSendData>(data);
			if (clientMarketSendData.Count > 0)
			{
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer != null)
				{
					string hostName = peer.m_socket.GetHostName();
					global::Marketplace.DB.DB.MarketSlot marketSlot = new global::Marketplace.DB.DB.MarketSlot(clientMarketSendData, hostName);
					global::Marketplace.DB.DB._context.Marketplace_AddItem(marketSlot);
					SaveMarketAndSendToClients();
					Market_Logger.Log(Market_Logger.LogType.Marketplace, $"Player User ID: {hostName} added an item {marketSlot.ItemPrefab} with quantity: {marketSlot.Count} price: {marketSlot.Price}");
					global::Marketplace.DiscordStuff.DiscordStuff.SendMarketplaceWebhook(marketSlot);
				}
			}
		}

		private static void SaveMarketAndSendToClients()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			List<global::Marketplace.DB.DB.MarketSlot> list = global::Marketplace.DB.DB._context.Marketplace_GetItems();
			ZPackage pkg = new ZPackage();
			pkg.Write(int.MaxValue);
			pkg.Write(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				list[i].Serialize(ref pkg);
			}
			pkg.Compress();
			foreach (ZNetPeer peer in ZNet.instance.m_peers)
			{
				if (peer.IsReady())
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "KGmarket ReceiveTradepostData", new object[1] { pkg });
				}
			}
			if (ZNet.IsSinglePlayer)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.m_id, "KGmarket ReceiveTradepostData", new object[1] { pkg });
			}
		}

		[MarketplaceRPC("KGmarket ReceiveTradepostData_s", Market_Autoload.Type.Server)]
		private static void ReceiveTradepostRequest(long sender, int revision)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			List<global::Marketplace.DB.DB.MarketSlot> list = global::Marketplace.DB.DB._context.Marketplace_GetItems();
			ZPackage pkg = new ZPackage();
			pkg.Write(revision);
			pkg.Write(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				list[i].Serialize(ref pkg);
			}
			pkg.Compress();
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket ReceiveTradepostData", new object[1] { pkg });
		}

		[MarketplaceRPC("KGmarket RemoveItemAdmin", Market_Autoload.Type.Server)]
		private static void RemoveItemAdminStatus(long sender, int id)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				if (ZNet.instance.m_adminList != null && ZNet.instance.ListContainsId(ZNet.instance.m_adminList, hostName))
				{
					global::Marketplace.DB.DB._context.Marketplace_RemoveItem(id);
					SaveMarketAndSendToClients();
				}
			}
		}

		[MarketplaceRPC("KGmarket RequestBuyItem", Market_Autoload.Type.Server)]
		private static void RequestBuyItem(long sender, ZPackage data)
		{
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			if (data == null)
			{
				return;
			}
			int num = data.ReadInt();
			int num2 = data.ReadInt();
			int num3 = data.ReadInt();
			string itemPrefab = data.ReadString();
			global::Marketplace.DB.DB.MarketSlot slotByID = global::Marketplace.DB.DB._context.GetSlotByID(num);
			if (slotByID != null)
			{
				Marketplace_DataTypes.ClientMarketSendData clientMarketSendData = null;
				if (num3 >= slotByID.Count)
				{
					global::Marketplace.DB.DB._context.Marketplace_RemoveItem(num);
					clientMarketSendData = slotByID.ToClient();
					int num4 = num3 - slotByID.Count;
					num2 = slotByID.Count * slotByID.Price;
					if (num4 > 0)
					{
						global::Marketplace.DB.DB.MarketSlot obj = new global::Marketplace.DB.DB.MarketSlot
						{
							Count = num4 * slotByID.Price,
							ItemPrefab = itemPrefab,
							Quality = 1
						};
						string text = JSON.ToJSON(obj);
						ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket BuyItemAnswer", new object[1] { text });
					}
				}
				else
				{
					int count = slotByID.Count - num3;
					slotByID.Count = num3;
					clientMarketSendData = slotByID.ToClient();
					slotByID.Count = count;
					global::Marketplace.DB.DB._context.ModifyExisting(slotByID);
				}
				SaveMarketAndSendToClients();
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer != null)
				{
					string hostName = peer.m_socket.GetHostName();
					string sellerUserID = slotByID.SellerUserID;
					string playerName = peer.m_playerName;
					if (hostName == sellerUserID)
					{
						CentralizedMailSystem_Server.AddMail("$mpasn_CMS_TradePost", "$mpasn_CMS_TradePost_SlotCancelled", $"$mpasn_CMS_TradePost_SlotCancelledMessage:\n<link=kg.CMSLINK:100><color=#ffbf00><u><b>[•{slotByID.LocalizeKey()} x{num3}]</b></u></color></link>", hostName, new Marketplace_DataTypes.ClientMarketSendData[1] { clientMarketSendData });
						Market_Logger.Log(Market_Logger.LogType.Marketplace, $"{playerName} (ID: {hostName}) cancelled his slot {slotByID.ItemPrefab} quantity: {slotByID.Count} price: {slotByID.Price}. He took: {num3} items");
						return;
					}
					int num5 = (Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(sellerUserID) ? Global_Configs.SyncedGlobalOptions.Value._vipmarketTaxes : Global_Configs.SyncedGlobalOptions.Value._marketTaxes);
					num5 = Mathf.Max(0, num5);
					float num6 = (float)num2 - (float)num2 * ((float)num5 / 100f);
					CentralizedMailSystem_Server.AddMail("$mpasn_CMS_TradePost", "$mpasn_CMS_TradePost_SlotBought", $"$mpasn_CMS_TradePost_YouBoughtItemFrom {slotByID.SellerName}:\n<link=kg.CMSLINK:100><color=#ffbf00><u><b>[•{slotByID.LocalizeKey()} x{num3}]</b></u></color></link>\n$mpasn_CMS_Price: {slotByID.Price}", hostName, new Marketplace_DataTypes.ClientMarketSendData[1] { clientMarketSendData });
					Marketplace_DataTypes.ClientMarketSendData clientMarketSendData2 = new Marketplace_DataTypes.ClientMarketSendData
					{
						Count = (int)Math.Min(2147483647L, (long)num6),
						ItemPrefab = itemPrefab,
						Quality = 1
					};
					CentralizedMailSystem_Server.AddMail("$mpasn_CMS_TradePost", "$mpasn_CMS_TradePost_Income", $"$mpasn_CMS_TradePost_YouSoldItem:\n<link=kg.CMSLINK:0><color=#ffbf00><u><b>[•{slotByID.LocalizeKey()} x{num3}]</b></u></color></link>\n$mpasn_CMS_Price: {slotByID.Price}\n$mpasn_CMS_Taxes: {num5}%", sellerUserID, new Marketplace_DataTypes.ClientMarketSendData[1] { clientMarketSendData2 }, new Marketplace_DataTypes.ClientMarketSendData[1] { clientMarketSendData });
					Market_Logger.Log(Market_Logger.LogType.Marketplace, $"{playerName} (ID: {hostName}) bought {slotByID.SellerName}'s (ID: {sellerUserID}) slot {slotByID.ItemPrefab} quantity: {slotByID.Count} (bought: x{num3}) price: {slotByID.Price}");
				}
			}
			else
			{
				global::Marketplace.DB.DB.MarketSlot obj2 = new global::Marketplace.DB.DB.MarketSlot
				{
					Count = num2,
					ItemPrefab = itemPrefab,
					Quality = 1
				};
				string text2 = JSON.ToJSON(obj2);
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket BuyItemAnswer", new object[1] { text2 });
				List<global::Marketplace.DB.DB.MarketSlot> list = global::Marketplace.DB.DB._context.Marketplace_GetItems();
				ZPackage pkg = new ZPackage();
				pkg.Write(int.MaxValue);
				pkg.Write(list.Count);
				for (int i = 0; i < list.Count; i++)
				{
					list[i].Serialize(ref pkg);
				}
				pkg.Compress();
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket ReceiveTradepostData", new object[1] { pkg });
			}
		}
	}
	public static class Marketplace_DataTypes
	{
		public class ClientMarketSendData
		{
			public string ItemPrefab;

			public int Count;

			public int Price;

			public string SellerName;

			public ItemData_ItemCategory ItemCategory;

			public int Quality;

			public int Variant;

			public string CUSTOMdata = "{}";

			public string CrafterName = "";

			public long CrafterID;

			public byte DurabilityPercent;

			public string Currency;

			[BsonIgnore]
			public string ItemName
			{
				get
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(ItemPrefab);
					if (prefab == null)
					{
						return ItemPrefab;
					}
					return prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				}
			}
		}

		public enum ItemData_ItemCategory
		{
			ALL,
			WEAPONS,
			ARMOR,
			CONSUMABLE,
			TOOLS,
			RESOURCES
		}

		public enum MarketMode
		{
			BUY,
			SELL
		}

		public enum SortBy
		{
			None,
			ItemName,
			Count,
			Price,
			Seller
		}

		public enum SortType
		{
			UP,
			DOWN
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Marketplace_Main_Client
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class MarketplaceUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (Marketplace_UI.IsPanelVisible())
				{
					__result = true;
				}
			}
		}

		public static List<global::Marketplace.DB.DB.MarketSlot> MarketData = new List<global::Marketplace.DB.DB.MarketSlot>();

		private static int _requestRevision = 0;

		[UsedImplicitly]
		private static void OnInit()
		{
			Marketplace_UI.Init();
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
			Global_Configs.SyncedGlobalOptions.ValueChanged += Marketplace_UI.ReloadCurrency;
		}

		public static void RequestData()
		{
			MarketData.Clear();
			_requestRevision++;
			ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket ReceiveTradepostData_s", new object[1] { _requestRevision });
		}

		[MarketplaceRPC("KGmarket ReceiveTradepostData", Market_Autoload.Type.Client)]
		private static void OnMarketplaceUpdate(long sender, ZPackage pkg)
		{
			if (!Marketplace_UI.IsPanelVisible() || Marketplace_UI.currentMarketMode != 0)
			{
				return;
			}
			pkg.Decompress();
			int num = pkg.ReadInt();
			if (_requestRevision <= num)
			{
				MarketData.Clear();
				int num2 = pkg.ReadInt();
				List<global::Marketplace.DB.DB.MarketSlot> list = new List<global::Marketplace.DB.DB.MarketSlot>(num2);
				for (int i = 0; i < num2; i++)
				{
					global::Marketplace.DB.DB.MarketSlot marketSlot = new global::Marketplace.DB.DB.MarketSlot();
					marketSlot.Deserialize(ref pkg);
					list.Add(marketSlot);
				}
				MarketData = list;
				if (Marketplace_UI.IsPanelVisible())
				{
					Marketplace_UI.OnMarketplaceDataUpdate();
				}
			}
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Marketplace_UI.IsPanelVisible())
			{
				Marketplace_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		[MarketplaceRPC("KGmarket BuyItemAnswer", Market_Autoload.Type.Client)]
		private static void InstantiateItemFromServer(long sender, string data)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			if (sender != ZRoutedRpc.instance.GetServerPeerID() || data.Length <= 0)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			global::Marketplace.DB.DB.MarketSlot marketSlot = JSON.ToObject<global::Marketplace.DB.DB.MarketSlot>(data);
			GameObject prefab = ZNetScene.instance.GetPrefab(marketSlot.ItemPrefab);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return;
			}
			string text = Localization.instance.Localize("$mpasn_added", new string[2]
			{
				marketSlot.Count.ToString(),
				Localization.instance.Localize(prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name)
			});
			MessageHud.instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			marketSlot.Quality = Mathf.Max(1, marketSlot.Quality);
			int num = marketSlot.Count;
			Dictionary<string, string> dictionary = JSON.ToObject<Dictionary<string, string>>(marketSlot.CUSTOMdata);
			while (num > 0)
			{
				Vector2i val = ((Humanoid)localPlayer).m_inventory.FindEmptySlot(true);
				if (val.x < 0)
				{
					break;
				}
				int num2 = Math.Min(num, component.m_itemData.m_shared.m_maxStackSize);
				num -= num2;
				((Humanoid)localPlayer).m_inventory.AddItem(marketSlot.ItemPrefab, num2, component.m_itemData.GetMaxDurability(marketSlot.Quality) * Mathf.Clamp01((float)(int)marketSlot.DurabilityPercent / 100f), val, false, marketSlot.Quality, marketSlot.Variant, marketSlot.CrafterID, marketSlot.CrafterName, dictionary, Game.m_worldLevel, true);
			}
			if (num > 0)
			{
				while (num > 0)
				{
					int num3 = Math.Min(num, component.m_itemData.m_shared.m_maxStackSize);
					num -= num3;
					Transform transform = ((Component)localPlayer).transform;
					Vector3 position = transform.position;
					ItemDrop component2 = Object.Instantiate<GameObject>(prefab, position + Vector3.up, transform.rotation).GetComponent<ItemDrop>();
					component2.m_itemData.m_customData = dictionary;
					component2.m_itemData.m_quality = marketSlot.Quality;
					component2.m_itemData.m_stack = num3;
					component2.m_itemData.m_crafterName = marketSlot.CrafterName;
					component2.m_itemData.m_crafterID = marketSlot.CrafterID;
					component2.m_itemData.m_worldLevel = Game.m_worldLevel;
					component2.m_itemData.m_variant = marketSlot.Variant;
					component2.m_itemData.m_durability = component.m_itemData.GetMaxDurability(marketSlot.Quality) * Mathf.Clamp01((float)(int)marketSlot.DurabilityPercent / 100f);
					component2.Save();
					component2.OnPlayerDrop();
					((Component)component2).GetComponent<Rigidbody>().velocity = transform.forward + Vector3.up;
					((Humanoid)localPlayer).m_dropEffects.Create(position, Quaternion.identity, (Transform)null, 1f, -1);
				}
			}
		}
	}
	public static class Marketplace_UI
	{
		private enum MarketSize
		{
			Large,
			Medium,
			Small
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			private static void Postfix()
			{
				ReloadCurrency();
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			private static bool done;

			[UsedImplicitly]
			private static void Postfix(FejdStartup __instance)
			{
				if (done)
				{
					return;
				}
				done = true;
				Transform obj = ((Component)__instance).transform.Find("StartGame/Panel/JoinPanel/serverCount");
				TextMeshProUGUI val = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
				if (val != null)
				{
					TMP_Text[] componentsInChildren = UI.GetComponentsInChildren<TMP_Text>(true);
					foreach (TMP_Text val2 in componentsInChildren)
					{
						val2.font = ((TMP_Text)val).font;
					}
				}
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__SortValueList;

			public static UnityAction <1>__ClickBUYcategoryButton;

			public static UnityAction <2>__ClickSELLcategoryButton;

			public static UnityAction<string> <3>__SearchTabValue;

			public static UnityAction<string> <4>__SetQuantityValueChange;

			public static UnityAction<string> <5>__SetPriceValueChange;

			public static UnityAction<string> <6>__SetBuyQuantityChange;

			public static UnityAction <7>__SELLITEMCLICK;

			public static UnityAction <8>__BUYITEMCLICK;

			public static UnityAction <9>__MySalesClick;

			public static UnityAction <10>__ClickAnonButton;

			public static Action<GameObject> <11>__Destroy;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__43_0;

			public static UnityAction <>9__43_1;

			public static UnityAction <>9__43_2;

			public static UnityAction <>9__43_3;

			public static UnityAction <>9__43_4;

			public static UnityAction <>9__43_5;

			public static UnityAction <>9__43_6;

			public static UnityAction <>9__43_7;

			public static UnityAction<int> <>9__43_8;

			public static UnityAction <>9__43_9;

			public static UnityAction <>9__43_10;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__61_0;

			public static Func<ItemData, ItemData> <>9__62_1;

			public static Func<ItemData, int> <>9__62_2;

			public static Action<ItemData> <>9__74_0;

			public static Action<ContentSizeFitter> <>9__76_0;

			public static Action<ContentSizeFitter> <>9__76_1;

			public static Action<Scrollbar> <>9__76_2;

			public static Action<ContentSizeFitter> <>9__77_0;

			public static Action<ContentSizeFitter> <>9__77_1;

			public static Action<Scrollbar> <>9__77_2;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_0;

			public static Func<global::Marketplace.DB.DB.MarketSlot, uint> <>9__80_1;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_3;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_4;

			public static Func<global::Marketplace.DB.DB.MarketSlot, string> <>9__80_5;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_6;

			public static Func<global::Marketplace.DB.DB.MarketSlot, int> <>9__80_7;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_8;

			public static Func<global::Marketplace.DB.DB.MarketSlot, int> <>9__80_9;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_10;

			public static Func<global::Marketplace.DB.DB.MarketSlot, string> <>9__80_11;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_12;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_13;

			public static Func<global::Marketplace.DB.DB.MarketSlot, string> <>9__80_14;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_15;

			public static Func<global::Marketplace.DB.DB.MarketSlot, int> <>9__80_16;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_17;

			public static Func<global::Marketplace.DB.DB.MarketSlot, int> <>9__80_18;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_19;

			public static Func<global::Marketplace.DB.DB.MarketSlot, string> <>9__80_20;

			public static Func<global::Marketplace.DB.DB.MarketSlot, bool> <>9__80_2;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, bool> <>9__80_21;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, bool> <>9__80_22;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, string> <>9__80_23;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, bool> <>9__80_24;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, int> <>9__80_25;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, bool> <>9__80_26;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, bool> <>9__80_27;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, string> <>9__80_28;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, bool> <>9__80_29;

			public static Func<Marketplace_DataTypes.ClientMarketSendData, int> <>9__80_30;

			internal void <Init>b__43_0()
			{
				PageIncrementor(1);
			}

			internal void <Init>b__43_1()
			{
				PageIncrementor(-1);
			}

			internal void <Init>b__43_2()
			{
				ChangeSortBy(1);
			}

			internal void <Init>b__43_3()
			{
				ChangeSortBy(2);
			}

			internal void <Init>b__43_4()
			{
				ChangeSortBy(1);
			}

			internal void <Init>b__43_5()
			{
				ChangeSortBy(2);
			}

			internal void <Init>b__43_6()
			{
				ChangeSortBy(3);
			}

			internal void <Init>b__43_7()
			{
				ChangeSortBy(4);
			}

			internal void <Init>b__43_8(int _)
			{
				OnCurrencyChange();
			}

			internal void <Init>b__43_9()
			{
				Hide();
				AssetStorage.AUsrc.Play();
			}

			internal void <Init>b__43_10()
			{
				ChangeSize(increase: true);
			}

			internal bool <SELLITEMCLICK>b__61_0(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.SellerUserID == Global_Configs._localUserID;
			}

			internal ItemData <CountItemByData>b__62_1(ItemData p)
			{
				return p;
			}

			internal int <CountItemByData>b__62_2(ItemData p)
			{
				return p.m_stack;
			}

			internal void <GetTempItemTooltip>b__74_0(ItemData item)
			{
				JC_API_Class.JC_Api_Tooltip(item, (currentMarketMode == Marketplace_DataTypes.MarketMode.BUY) ? JC_Api[1] : JC_Api[0]);
			}

			internal void <OnClickBUYItem>b__76_0(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			}

			internal void <OnClickBUYItem>b__76_1(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			}

			internal void <OnClickBUYItem>b__76_2(Scrollbar scroll)
			{
				scroll.value = 1f;
			}

			internal void <OnClickSELLItem>b__77_0(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			}

			internal void <OnClickSELLItem>b__77_1(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			}

			internal void <OnClickSELLItem>b__77_2(Scrollbar scroll)
			{
				scroll.value = 1f;
			}

			internal bool <SortValueList>b__80_0(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.SellerUserID == Global_Configs._localUserID;
			}

			internal uint <SortValueList>b__80_1(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.TimeStamp;
			}

			internal bool <SortValueList>b__80_3(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal bool <SortValueList>b__80_4(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal string <SortValueList>b__80_5(global::Marketplace.DB.DB.MarketSlot data)
			{
				return Localization.instance.Localize(data.ItemName);
			}

			internal bool <SortValueList>b__80_6(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal int <SortValueList>b__80_7(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.Count;
			}

			internal bool <SortValueList>b__80_8(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal int <SortValueList>b__80_9(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.Price;
			}

			internal bool <SortValueList>b__80_10(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal string <SortValueList>b__80_11(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.SellerName;
			}

			internal bool <SortValueList>b__80_12(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal bool <SortValueList>b__80_13(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal string <SortValueList>b__80_14(global::Marketplace.DB.DB.MarketSlot data)
			{
				return Localization.instance.Localize(data.ItemName);
			}

			internal bool <SortValueList>b__80_15(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal int <SortValueList>b__80_16(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.Count;
			}

			internal bool <SortValueList>b__80_17(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal int <SortValueList>b__80_18(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.Price;
			}

			internal bool <SortValueList>b__80_19(global::Marketplace.DB.DB.MarketSlot data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal string <SortValueList>b__80_20(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.SellerName;
			}

			internal bool <SortValueList>b__80_2(global::Marketplace.DB.DB.MarketSlot data)
			{
				return data.SellerUserID == Global_Configs._localUserID;
			}

			internal bool <SortValueList>b__80_21(Marketplace_DataTypes.ClientMarketSendData data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal bool <SortValueList>b__80_22(Marketplace_DataTypes.ClientMarketSendData data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal string <SortValueList>b__80_23(Marketplace_DataTypes.ClientMarketSendData data)
			{
				return Localization.instance.Localize(data.ItemName);
			}

			internal bool <SortValueList>b__80_24(Marketplace_DataTypes.ClientMarketSendData data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal int <SortValueList>b__80_25(Marketplace_DataTypes.ClientMarketSendData data)
			{
				return data.Count;
			}

			internal bool <SortValueList>b__80_26(Marketplace_DataTypes.ClientMarketSendData data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal bool <SortValueList>b__80_27(Marketplace_DataTypes.ClientMarketSendData data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal string <SortValueList>b__80_28(Marketplace_DataTypes.ClientMarketSendData data)
			{
				return Localization.instance.Localize(data.ItemName);
			}

			internal bool <SortValueList>b__80_29(Marketplace_DataTypes.ClientMarketSendData data)
			{
				if (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory)
				{
					return Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower());
				}
				return false;
			}

			internal int <SortValueList>b__80_30(Marketplace_DataTypes.ClientMarketSendData data)
			{
				return data.Count;
			}
		}

		private const int MAXITEMSPERPAGE = 14;

		private static GameObject UI = null;

		private static GameObject ElementBUY = null;

		private static GameObject ElementSELL = null;

		private static Action OnSort = null;

		private static readonly List<Marketplace_DataTypes.ClientMarketSendData> InventorySellData = new List<Marketplace_DataTypes.ClientMarketSendData>();

		private static List<Marketplace_DataTypes.ClientMarketSendData> InventorySellDataSORTED = new List<Marketplace_DataTypes.ClientMarketSendData>();

		private static List<global::Marketplace.DB.DB.MarketSlot> ServerMarketSendDataSORTED = new List<global::Marketplace.DB.DB.MarketSlot>();

		private static readonly List<GameObject> CurrentGameObjects = new List<GameObject>();

		private static Marketplace_DataTypes.ItemData_ItemCategory currentCategory;

		public static Marketplace_DataTypes.MarketMode currentMarketMode;

		private static Marketplace_DataTypes.SortBy currentSortMode;

		private static Marketplace_DataTypes.SortType currentSortType;

		private static readonly Button[] CategoryButtons = (Button[])(object)new Button[6];

		private static Button BuyButtonCategory = null;

		private static Button SellButtonCategory = null;

		private static readonly Color DefaultCategoryColorNotActive = new Color(1f, 0.6941177f, 0f);

		private static readonly Color DefaultCategoryColorActive = new Color(0.08995318f, 1f, 0f);

		private static string SEARCHVALUE = "";

		private static int CurrentPage;

		private static int CurrentMaxPage;

		private static Marketplace_DataTypes.ClientMarketSendData CurrentSendData;

		private static global::Marketplace.DB.DB.MarketSlot CurrentBuyData;

		private static int CurrentPrice;

		private static int CurrentQuantity;

		private static int CurrentBUYQuantity;

		private static bool IsAnon;

		private static bool MySalesOnly;

		private static Text PageNumber = null;

		private static Transform BUYTAB = null;

		private static Transform SELLTAB = null;

		private static Text GoldCount = null;

		private static Text MySalesText = null;

		private static List<ContentSizeFitter> ALLFILTERS = null;

		private static List<Scrollbar> ALLSCROLLS = null;

		private static List<GameObject> JC_Api = null;

		private static TMP_Dropdown CurrencyDropdown = null;

		private static GameObject LOADING = null;

		private static List<string> CurrencyMapper = new List<string>();

		private static ConfigEntry<MarketSize> _marketSize = null;

		private const int maxprice = 9999999;

		private static bool SkipQuantityCheck;

		private static bool SkipNextSound;

		private static string GetCurrentCurrencyName_Sell
		{
			get
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(CurrencyMapper[CurrencyDropdown.value]);
				return ((prefab == null) ? null : prefab.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_name.Localize()) ?? "<color=red>Error</color>";
			}
		}

		private static string GetCurrentCurrencyName_Buy
		{
			get
			{
				if (CurrentBuyData == null)
				{
					return "<color=red>Error</color>";
				}
				GameObject prefab = ZNetScene.instance.GetPrefab(CurrentBuyData.Currency);
				if (prefab == null)
				{
					return null;
				}
				return prefab.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_name.Localize();
			}
		}

		private static void ERRORBLOCKED()
		{
			Hide();
			MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_youareblocked") + "</color>", 0, (Sprite)null, false);
		}

		private static void ERRORLIMIT()
		{
			Hide();
			MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_limitmarket") + "</color>", 0, (Sprite)null, false);
		}

		private static void ERROR()
		{
			Hide();
			MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_error") + "</color>", 0, (Sprite)null, false);
		}

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0176: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Expected O, but got Unknown
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Expected O, but got Unknown
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Expected O, but got Unknown
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Expected O, but got Unknown
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Expected O, but got Unknown
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Expected O, but got Unknown
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Expected O, but got Unknown
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Expected O, but got Unknown
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Expected O, but got Unknown
			//IL_06af: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Expected O, but got Unknown
			//IL_06ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f8: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceUI"));
			ALLFILTERS = UI.GetComponentsInChildren<ContentSizeFitter>(true).ToList();
			ALLSCROLLS = UI.GetComponentsInChildren<Scrollbar>(true).ToList();
			ElementBUY = AssetStorage.asset.LoadAsset<GameObject>("BuyTabGO");
			ElementSELL = AssetStorage.asset.LoadAsset<GameObject>("SellTabGO");
			OnSort = (Action)Delegate.Combine(OnSort, new Action(SortValueList));
			Object.DontDestroyOnLoad((Object)(object)UI);
			string[] names = Enum.GetNames(typeof(Marketplace_DataTypes.ItemData_ItemCategory));
			for (int i = 0; i < names.Length; i++)
			{
				int test = i;
				Button[] categoryButtons = CategoryButtons;
				int num = i;
				Transform transform = UI.transform;
				Marketplace_DataTypes.ItemData_ItemCategory itemData_ItemCategory = (Marketplace_DataTypes.ItemData_ItemCategory)i;
				categoryButtons[num] = ((Component)transform.Find("Canvas/BACKGROUND/CATEGORIES/" + itemData_ItemCategory)).GetComponent<Button>();
				((UnityEvent)CategoryButtons[i].onClick).AddListener((UnityAction)delegate
				{
					SetCategory(test);
				});
			}
			BuyButtonCategory = ((Component)UI.transform.Find("Canvas/BACKGROUND/BUYSELL/BUY")).GetComponent<Button>();
			SellButtonCategory = ((Component)UI.transform.Find("Canvas/BACKGROUND/BUYSELL/SELL")).GetComponent<Button>();
			ButtonClickedEvent onClick = BuyButtonCategory.onClick;
			object obj = <>O.<1>__ClickBUYcategoryButton;
			if (obj == null)
			{
				UnityAction val = ClickBUYcategoryButton;
				<>O.<1>__ClickBUYcategoryButton = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = SellButtonCategory.onClick;
			object obj2 = <>O.<2>__ClickSELLcategoryButton;
			if (obj2 == null)
			{
				UnityAction val2 = ClickSELLcategoryButton;
				<>O.<2>__ClickSELLcategoryButton = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			BUYTAB = UI.transform.Find("Canvas/BACKGROUND/BUYTAB");
			SELLTAB = UI.transform.Find("Canvas/BACKGROUND/SELLTAB");
			PageNumber = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Page/Text")).GetComponent<Text>();
			ButtonClickedEvent onClick3 = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/PageRight")).GetComponent<Button>().onClick;
			object obj3 = <>c.<>9__43_0;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					PageIncrementor(1);
				};
				<>c.<>9__43_0 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/PageLeft")).GetComponent<Button>().onClick;
			object obj4 = <>c.<>9__43_1;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					PageIncrementor(-1);
				};
				<>c.<>9__43_1 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			((UnityEvent<string>)(object)((Component)UI.transform.Find("Canvas/BACKGROUND/SEARCH/Input")).GetComponent<InputField>().onValueChanged).AddListener((UnityAction<string>)SearchTabValue);
			((UnityEvent<string>)(object)((Component)SELLTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().onValueChanged).AddListener((UnityAction<string>)SetQuantityValueChange);
			((UnityEvent<string>)(object)((Component)SELLTAB.Find("AFTERPRESS/SetPrice")).GetComponent<InputField>().onValueChanged).AddListener((UnityAction<string>)SetPriceValueChange);
			((UnityEvent<string>)(object)((Component)BUYTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().onValueChanged).AddListener((UnityAction<string>)SetBuyQuantityChange);
			ButtonClickedEvent onClick5 = ((Component)((Component)SELLTAB).transform.Find("itemname")).GetComponent<Button>().onClick;
			object obj5 = <>c.<>9__43_2;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					ChangeSortBy(1);
				};
				<>c.<>9__43_2 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			ButtonClickedEvent onClick6 = ((Component)((Component)SELLTAB).transform.Find("count")).GetComponent<Button>().onClick;
			object obj6 = <>c.<>9__43_3;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					ChangeSortBy(2);
				};
				<>c.<>9__43_3 = val6;
				obj6 = (object)val6;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			ButtonClickedEvent onClick7 = ((Component)((Component)BUYTAB).transform.Find("itemname")).GetComponent<Button>().onClick;
			object obj7 = <>c.<>9__43_4;
			if (obj7 == null)
			{
				UnityAction val7 = delegate
				{
					ChangeSortBy(1);
				};
				<>c.<>9__43_4 = val7;
				obj7 = (object)val7;
			}
			((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			ButtonClickedEvent onClick8 = ((Component)((Component)BUYTAB).transform.Find("count")).GetComponent<Button>().onClick;
			object obj8 = <>c.<>9__43_5;
			if (obj8 == null)
			{
				UnityAction val8 = delegate
				{
					ChangeSortBy(2);
				};
				<>c.<>9__43_5 = val8;
				obj8 = (object)val8;
			}
			((UnityEvent)onClick8).AddListener((UnityAction)obj8);
			ButtonClickedEvent onClick9 = ((Component)((Component)BUYTAB).transform.Find("price")).GetComponent<Button>().onClick;
			object obj9 = <>c.<>9__43_6;
			if (obj9 == null)
			{
				UnityAction val9 = delegate
				{
					ChangeSortBy(3);
				};
				<>c.<>9__43_6 = val9;
				obj9 = (object)val9;
			}
			((UnityEvent)onClick9).AddListener((UnityAction)obj9);
			ButtonClickedEvent onClick10 = ((Component)((Component)BUYTAB).transform.Find("seller")).GetComponent<Button>().onClick;
			object obj10 = <>c.<>9__43_7;
			if (obj10 == null)
			{
				UnityAction val10 = delegate
				{
					ChangeSortBy(4);
				};
				<>c.<>9__43_7 = val10;
				obj10 = (object)val10;
			}
			((UnityEvent)onClick10).AddListener((UnityAction)obj10);
			ButtonClickedEvent onClick11 = ((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/BUTTON")).GetComponent<Button>().onClick;
			object obj11 = <>O.<7>__SELLITEMCLICK;
			if (obj11 == null)
			{
				UnityAction val11 = SELLITEMCLICK;
				<>O.<7>__SELLITEMCLICK = val11;
				obj11 = (object)val11;
			}
			((UnityEvent)onClick11).AddListener((UnityAction)obj11);
			ButtonClickedEvent onClick12 = ((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/BUTTON")).GetComponent<Button>().onClick;
			object obj12 = <>O.<8>__BUYITEMCLICK;
			if (obj12 == null)
			{
				UnityAction val12 = BUYITEMCLICK;
				<>O.<8>__BUYITEMCLICK = val12;
				obj12 = (object)val12;
			}
			((UnityEvent)onClick12).AddListener((UnityAction)obj12);
			GoldCount = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Gold/Text")).GetComponent<Text>();
			ButtonClickedEvent onClick13 = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/MySales")).GetComponent<Button>().onClick;
			object obj13 = <>O.<9>__MySalesClick;
			if (obj13 == null)
			{
				UnityAction val13 = MySalesClick;
				<>O.<9>__MySalesClick = val13;
				obj13 = (object)val13;
			}
			((UnityEvent)onClick13).AddListener((UnityAction)obj13);
			MySalesText = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/MySales/Text")).GetComponent<Text>();
			CurrencyDropdown = ((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/Currency")).GetComponent<TMP_Dropdown>();
			((UnityEvent<int>)(object)CurrencyDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				OnCurrencyChange();
			});
			ButtonClickedEvent onClick14 = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Close")).GetComponent<Button>().onClick;
			object obj14 = <>c.<>9__43_9;
			if (obj14 == null)
			{
				UnityAction val14 = delegate
				{
					Hide();
					AssetStorage.AUsrc.Play();
				};
				<>c.<>9__43_9 = val14;
				obj14 = (object)val14;
			}
			((UnityEvent)onClick14).AddListener((UnityAction)obj14);
			ButtonClickedEvent onClick15 = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Size")).GetComponent<Button>().onClick;
			object obj15 = <>c.<>9__43_10;
			if (obj15 == null)
			{
				UnityAction val15 = delegate
				{
					ChangeSize(increase: true);
				};
				<>c.<>9__43_10 = val15;
				obj15 = (object)val15;
			}
			((UnityEvent)onClick15).AddListener((UnityAction)obj15);
			ButtonClickedEvent onClick16 = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Anon/click")).GetComponent<Button>().onClick;
			object obj16 = <>O.<10>__ClickAnonButton;
			if (obj16 == null)
			{
				UnityAction val16 = ClickAnonButton;
				<>O.<10>__ClickAnonButton = val16;
				obj16 = (object)val16;
			}
			((UnityEvent)onClick16).AddListener((UnityAction)obj16);
			UI.SetActive(false);
			JC_Api = new List<GameObject>(2)
			{
				((Component)Utils.FindChild(SELLTAB, "TrannyHoles", (IterativeSearchType)0)).gameObject,
				((Component)Utils.FindChild(BUYTAB, "TrannyHoles", (IterativeSearchType)0)).gameObject
			};
			Localization.instance.Localize(UI.transform);
			_marketSize = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<MarketSize>("Marketplace", "Market Size", MarketSize.Large, "Market size");
			ChangeSize(increase: false);
			LOADING = ((Component)Utils.FindChild(UI.transform, "LOADING", (IterativeSearchType)0)).gameObject;
			ReloadCurrency();
		}

		private static void OnCurrencyChange()
		{
			((Component)SELLTAB.Find("AFTERPRESS/BUTTON/Text")).GetComponent<Text>().text = string.Format("<size=42>{0}</size>\n<color=#FF00FF>{1}: {2}</color> x <color=yellow>{3}</color>\n<color=#00FFFF>{4}:</color> <color=yellow>{5} {6}</color>", Localization.instance.Localize("$mpasn_sellmarketplace"), Localization.instance.Localize("$mpasn_quantitymarketplace"), CurrentQuantity, CurrentPrice, Localization.instance.Localize("$mpasn_youget"), CurrentQuantity * CurrentPrice, GetCurrentCurrencyName_Sell);
		}

		public static void ReloadCurrency()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			CurrencyMapper.Clear();
			CurrencyDropdown.ClearOptions();
			if (Global_Configs.SyncedGlobalOptions.Value._possibleCurrencies == null)
			{
				return;
			}
			string[] possibleCurrencies = Global_Configs.SyncedGlobalOptions.Value._possibleCurrencies;
			for (int i = 0; i < possibleCurrencies.Length; i++)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(possibleCurrencies[i]);
				ItemDrop val = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
				if (!((Object)(object)val == (Object)null))
				{
					CurrencyDropdown.options.Add(new OptionData
					{
						text = val.m_itemData.m_shared.m_name.Localize(),
						image = val.m_itemData.GetIcon()
					});
					CurrencyMapper.Add(possibleCurrencies[i]);
				}
			}
			CurrencyDropdown.value = 0;
			((Selectable)CurrencyDropdown).interactable = CurrencyMapper.Count > 1;
			CurrencyDropdown.RefreshShownValue();
		}

		private static Marketplace_DataTypes.ItemData_ItemCategory ChooseBestCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0055: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_005c: 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)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Invalid comparison between Unknown and I4
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType <= 9)
			{
				if (itemType - 3 <= 1 || (int)itemType == 9)
				{
					goto IL_002a;
				}
			}
			else if (itemType - 14 <= 1 || (int)itemType == 22)
			{
				goto IL_002a;
			}
			bool flag = false;
			goto IL_0030;
			IL_0030:
			if (flag)
			{
				return Marketplace_DataTypes.ItemData_ItemCategory.WEAPONS;
			}
			if ((int)item.m_shared.m_itemType == 2)
			{
				return Marketplace_DataTypes.ItemData_ItemCategory.CONSUMABLE;
			}
			itemType = item.m_shared.m_itemType;
			if ((itemType - 5 <= 2 || (int)itemType == 11 || itemType - 17 <= 1) ? true : false)
			{
				return Marketplace_DataTypes.ItemData_ItemCategory.ARMOR;
			}
			if ((int)item.m_shared.m_itemType == 19)
			{
				return Marketplace_DataTypes.ItemData_ItemCategory.TOOLS;
			}
			if ((int)item.m_shared.m_itemType == 1)
			{
				return Marketplace_DataTypes.ItemData_ItemCategory.RESOURCES;
			}
			return Marketplace_DataTypes.ItemData_ItemCategory.ALL;
			IL_002a:
			flag = true;
			goto IL_0030;
		}

		private static List<Marketplace_DataTypes.ClientMarketSendData> CollectInventoryPlayerData()
		{
			List<Marketplace_DataTypes.ClientMarketSendData> list = new List<Marketplace_DataTypes.ClientMarketSendData>();
			Player localPlayer = Player.m_localPlayer;
			object obj;
			if (localPlayer == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = ((Humanoid)localPlayer).m_inventory;
				obj = ((inventory != null) ? inventory.GetAllItems() : null);
			}
			List<ItemData> list2 = (List<ItemData>)obj;
			if (list2 == null || list2.Count == 0)
			{
				return list;
			}
			foreach (ItemData item in list2)
			{
				if (!Global_Configs.SyncedGlobalOptions.Value._blockedPrefabsServer.Replace(" ", "").Split(new char[1] { ',' }).Contains(((Object)item.m_dropPrefab).name))
				{
					Marketplace_DataTypes.ItemData_ItemCategory itemCategory = ChooseBestCategory(item);
					string displayName = item.m_shared.m_name;
					byte durabilityPercent = (byte)(item.GetDurabilityPercentage() * 100f);
					string customDataJSON = JSON.ToJSON(item.m_customData);
					Marketplace_DataTypes.ClientMarketSendData clientMarketSendData = list.Find(delegate(Marketplace_DataTypes.ClientMarketSendData x)
					{
						string itemPrefab = x.ItemPrefab;
						GameObject dropPrefab = item.m_dropPrefab;
						return itemPrefab == ((dropPrefab != null) ? ((Object)dropPrefab).name : null) && x.Quality == item.m_quality && x.Variant == item.m_variant && x.CUSTOMdata == customDataJSON && x.CrafterID == item.m_crafterID && x.CrafterName == item.m_crafterName && x.ItemName == displayName && x.DurabilityPercent == durabilityPercent;
					});
					if (clientMarketSendData != null && item.m_shared.m_maxQuality <= 1)
					{
						clientMarketSendData.Count += item.m_stack;
						continue;
					}
					Marketplace_DataTypes.ClientMarketSendData item2 = new Marketplace_DataTypes.ClientMarketSendData
					{
						ItemPrefab = ((Object)item.m_dropPrefab).name,
						Count = item.m_stack,
						ItemCategory = itemCategory,
						SellerName = "",
						Quality = item.m_quality,
						Variant = item.m_variant,
						CUSTOMdata = customDataJSON,
						CrafterID = item.m_crafterID,
						CrafterName = item.m_crafterName,
						DurabilityPercent = durabilityPercent
					};
					list.Add(item2);
				}
			}
			return list;
		}

		private static void ChangeSize(bool increase)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (increase)
			{
				AssetStorage.AUsrc.Play();
				ConfigEntry<MarketSize> marketSize = _marketSize;
				marketSize.Value = _marketSize.Value switch
				{
					MarketSize.Small => MarketSize.Medium, 
					MarketSize.Medium => MarketSize.Large, 
					MarketSize.Large => MarketSize.Small, 
					_ => MarketSize.Large, 
				};
				((BaseUnityPlugin)Marketplace._thistype).Config.Save();
			}
			Transform val = UI.transform.Find("Canvas/BACKGROUND");
			val.localScale = (Vector3)(_marketSize.Value switch
			{
				MarketSize.Small => new Vector3(0.65f, 0.65f, 1f), 
				MarketSize.Medium => new Vector3(0.85f, 0.85f, 1f), 
				MarketSize.Large => new Vector3(1f, 1f, 1f), 
				_ => new Vector3(1f, 1f, 1f), 
			});
			Text component = ((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Size/Text")).GetComponent<Text>();
			component.text = _marketSize.Value switch
			{
				MarketSize.Small => "S", 
				MarketSize.Medium => "M", 
				MarketSize.Large => "L", 
				_ => "L", 
			};
		}

		private static void ClickAnonButton()
		{
			AssetStorage.AUsrc.Play();
			IsAnon = !IsAnon;
			UpdateAnnonIcon();
		}

		private static void UpdateAnnonIcon()
		{
			((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Anon/click/Image")).gameObject.SetActive(IsAnon);
			((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Anon/click/Image2")).gameObject.SetActive(!IsAnon);
		}

		private static void MySalesClick()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			bool mySalesOnly = MySalesOnly;
			DefaultBUY();
			MySalesOnly = !mySalesOnly;
			((Graphic)MySalesText).color = (MySalesOnly ? Color.green : Color.red);
			OnSort();
		}

		private static void BUYITEMCLICK()
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			if (Global_Configs.SyncedGlobalOptions.Value._blockedPlayerList.Contains(Global_Configs._localUserID))
			{
				ERRORBLOCKED();
				return;
			}
			if (CurrentBuyData == null)
			{
				ERROR();
				return;
			}
			AssetStorage.AUsrc.Play();
			int num = 0;
			if (CurrentBUYQuantity > CurrentBuyData.Count)
			{
				CurrentBUYQuantity = CurrentBuyData.Count;
			}
			if (Global_Configs._localUserID != CurrentBuyData.SellerUserID)
			{
				num = CurrentBUYQuantity * CurrentBuyData.Price;
				int num2 = Utils.CustomCountItemsNoLevel(CurrentBuyData.Currency);
				if (num2 < num)
				{
					return;
				}
				Utils.CustomRemoveItems(CurrentBuyData.Currency, num, 1);
			}
			ZPackage val = new ZPackage();
			val.Write(CurrentBuyData._id);
			val.Write(num);
			val.Write(CurrentBUYQuantity);
			val.Write(CurrentBuyData.Currency);
			LOADING.SetActive(true);
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS")).gameObject.SetActive(false);
			CurrentBuyData = null;
			ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket RequestBuyItem", new object[1] { val });
		}

		private static void SELLITEMCLICK()
		{
			if (Global_Configs.SyncedGlobalOptions.Value._blockedPlayerList.Contains(Global_Configs._localUserID))
			{
				ERRORBLOCKED();
				return;
			}
			if (Marketplace_Main_Client.MarketData.Count((global::Marketplace.DB.DB.MarketSlot data) => data.SellerUserID == Global_Configs._localUserID) >= Global_Configs.SyncedGlobalOptions.Value._itemMarketLimit)
			{
				ERRORLIMIT();
				return;
			}
			if (CurrentSendData == null)
			{
				ERROR();
				return;
			}
			AssetStorage.AUsrc.Play();
			GameObject prefab = ZNetScene.instance.GetPrefab(CurrentSendData.ItemPrefab);
			ItemDrop val = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null)
			{
				ERROR();
				return;
			}
			if (CurrentQuantity > CurrentSendData.Count)
			{
				CurrentQuantity = CurrentSendData.Count;
			}
			if (!CountItemByData(CurrentSendData, CurrentQuantity))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_noitems") + "</color>", 0, (Sprite)null, false);
				Hide();
				return;
			}
			string text = CurrencyMapper[CurrencyDropdown.value];
			if (string.IsNullOrWhiteSpace(text) || !Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(text)) || Global_Configs.SyncedGlobalOptions.Value._possibleCurrencies == null || !Global_Configs.SyncedGlobalOptions.Value._possibleCurrencies.Contains(text))
			{
				Hide();
				return;
			}
			string sellerName = (IsAnon ? "**************" : Player.m_localPlayer.GetPlayerName());
			Marketplace_DataTypes.ClientMarketSendData obj = new Marketplace_DataTypes.ClientMarketSendData
			{
				Count = CurrentQuantity,
				ItemCategory = CurrentSendData.ItemCategory,
				ItemPrefab = CurrentSendData.ItemPrefab,
				Price = CurrentPrice,
				Quality = CurrentSendData.Quality,
				SellerName = sellerName,
				Variant = CurrentSendData.Variant,
				CUSTOMdata = CurrentSendData.CUSTOMdata,
				CrafterName = CurrentSendData.CrafterName,
				CrafterID = CurrentSendData.CrafterID,
				DurabilityPercent = CurrentSendData.DurabilityPercent,
				Currency = text
			};
			string text2 = JSON.ToJSON(obj);
			ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket ReceiveItem", new object[1] { text2 });
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS")).gameObject.SetActive(false);
			ResetPage();
		}

		private static bool CountItemByData(Marketplace_DataTypes.ClientMarketSendData send, int cQuantity)
		{
			Marketplace_DataTypes.ClientMarketSendData send2 = send;
			List<ItemData> list = new List<ItemData>();
			((Humanoid)Player.m_localPlayer).m_inventory.GetAllItems(send2.ItemName, list);
			IEnumerable<ItemData> enumerable = from p in list
				where p.m_variant == send2.Variant && p.m_quality == send2.Quality && JSON.ToJSON(p.m_customData) == send2.CUSTOMdata && p.m_crafterID == send2.CrafterID && p.m_crafterName == send2.CrafterName
				select (p);
			ItemData[] array = (enumerable as ItemData[]) ?? enumerable.ToArray();
			int num = array.Sum((ItemData p) => p.m_stack);
			if (num < cQuantity)
			{
				return false;
			}
			while (cQuantity > 0)
			{
				ItemData[] array2 = array;
				foreach (ItemData val in array2)
				{
					if (cQuantity <= 0)
					{
						break;
					}
					if (val.m_stack <= cQuantity)
					{
						cQuantity -= val.m_stack;
						((Humanoid)Player.m_localPlayer).m_inventory.RemoveItem(val);
					}
					else
					{
						val.m_stack -= cQuantity;
						cQuantity = 0;
					}
				}
			}
			return true;
		}

		private static void ChangeSortBy(int whichOne)
		{
			AssetStorage.AUsrc.Play();
			((Component)((Component)SELLTAB).transform.Find("itemname/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemnamemarket");
			((Component)((Component)SELLTAB).transform.Find("count/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_quantitymarketplace");
			((Component)((Component)BUYTAB).transform.Find("itemname/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemnamemarket");
			((Component)((Component)BUYTAB).transform.Find("count/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_quantitymarketplace");
			((Component)((Component)BUYTAB).transform.Find("price/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_pricemarketplace") + " <color=grey>x1</color>";
			((Component)((Component)BUYTAB).transform.Find("seller/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_sellernamemarket");
			if (currentSortMode == (Marketplace_DataTypes.SortBy)whichOne)
			{
				currentSortType = ((currentSortType != Marketplace_DataTypes.SortType.DOWN) ? Marketplace_DataTypes.SortType.DOWN : Marketplace_DataTypes.SortType.UP);
			}
			else
			{
				currentSortMode = (Marketplace_DataTypes.SortBy)whichOne;
				currentSortType = Marketplace_DataTypes.SortType.UP;
			}
			string text = ((currentSortType == Marketplace_DataTypes.SortType.DOWN) ? "⇩" : "⇧");
			if (whichOne == 1)
			{
				((Component)((Component)BUYTAB).transform.Find("itemname/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemnamemarket") + text;
				((Component)((Component)SELLTAB).transform.Find("itemname/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemnamemarket") + text;
			}
			if (whichOne == 2)
			{
				((Component)((Component)BUYTAB).transform.Find("count/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_quantitymarketplace") + text;
				((Component)((Component)SELLTAB).transform.Find("count/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_quantitymarketplace") + text;
			}
			if (whichOne == 3)
			{
				((Component)((Component)BUYTAB).transform.Find("price/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_pricemarketplace") + " <color=grey>x1</color>" + text;
			}
			if (whichOne == 4)
			{
				((Component)((Component)BUYTAB).transform.Find("seller/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_sellernamemarket") + text;
			}
			OnSort();
		}

		private static void SetPriceValueChange(string value)
		{
			if (value != "0" && !string.IsNullOrWhiteSpace(value))
			{
				AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
			}
			if (string.IsNullOrWhiteSpace(value))
			{
				CurrentPrice = 0;
			}
			else
			{
				if (int.TryParse(value, out var result))
				{
					CurrentPrice = result;
				}
				else
				{
					((Component)SELLTAB.Find("AFTERPRESS/SetPrice")).GetComponent<InputField>().text = CurrentPrice.ToString();
				}
				if (CurrentPrice > 9999999)
				{
					CurrentPrice = 9999999;
					((Component)SELLTAB.Find("AFTERPRESS/SetPrice")).GetComponent<InputField>().text = CurrentPrice.ToString();
				}
			}
			((Component)SELLTAB.Find("AFTERPRESS/BUTTON/Text")).GetComponent<Text>().text = string.Format("<size=42>{0}</size>\n<color=#FF00FF>{1}: {2}</color> x <color=yellow>{3}</color>\n<color=#00FFFF>{4}:</color> <color=yellow>{5} {6}</color>", Localization.instance.Localize("$mpasn_sellmarketplace"), Localization.instance.Localize("$mpasn_quantitymarketplace"), CurrentQuantity, CurrentPrice, Localization.instance.Localize("$mpasn_youget"), (long)CurrentQuantity * (long)CurrentPrice, GetCurrentCurrencyName_Sell);
		}

		private static void SetBuyQuantityChange(string value)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentBuyData == null || SkipQuantityCheck)
			{
				return;
			}
			if (!SkipNextSound)
			{
				AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
			}
			SkipNextSound = false;
			int result;
			if (string.IsNullOrWhiteSpace(value))
			{
				CurrentBUYQuantity = 1;
			}
			else if (int.TryParse(value, out result))
			{
				CurrentBUYQuantity = ((result > CurrentBuyData.Count) ? CurrentBuyData.Count : result);
				if (CurrentBUYQuantity < 1)
				{
					CurrentBUYQuantity = 1;
				}
			}
			SkipQuantityCheck = true;
			((Component)BUYTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentBUYQuantity.ToString();
			SkipQuantityCheck = false;
			int num = Utils.CustomCountItemsNoLevel(CurrentBuyData.Currency);
			string text = "white";
			((Graphic)((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/BUTTON")).GetComponent<Image>()).color = Color.red;
			if (num >= CurrentBuyData.Price * CurrentBUYQuantity)
			{
				((Graphic)((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/BUTTON")).GetComponent<Image>()).color = Color.white;
				text = "lime";
			}
			string text2 = string.Format("<size=42><color={0}>{1}</color></size>\n<color=#FF00FF>{2}: {3}</color> x <color=yellow>{4}</color>\n<color=#00FFFF>{5}:</color> <color=yellow>{6} {7}</color>", text, Localization.instance.Localize("$mpasn_buymarketplace"), Localization.instance.Localize("$mpasn_quantitymarketplace"), CurrentBUYQuantity, CurrentBuyData.Price, Localization.instance.Localize("$mpasn_youneed"), CurrentBUYQuantity * CurrentBuyData.Price, GetCurrentCurrencyName_Buy);
			if (CurrentBuyData.SellerUserID == Global_Configs._localUserID)
			{
				((Graphic)((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/BUTTON")).GetComponent<Image>()).color = Color.red;
				text2 = "<size=100>" + Localization.instance.Localize("$mpasn_cancel") + "</size>";
			}
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/BUTTON/Text")).GetComponent<Text>().text = text2;
		}

		private static void SetQuantityValueChange(string value)
		{
			if (CurrentSendData == null)
			{
				return;
			}
			if (value != "1" && !string.IsNullOrWhiteSpace(value))
			{
				AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
			}
			int result;
			if (string.IsNullOrWhiteSpace(value))
			{
				CurrentQuantity = 1;
			}
			else if (int.TryParse(value, out result))
			{
				if (result > CurrentSendData.Count)
				{
					CurrentQuantity = CurrentSendData.Count;
					((Component)SELLTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentQuantity.ToString();
				}
				else
				{
					CurrentQuantity = result;
				}
				if (CurrentQuantity <= 0)
				{
					CurrentQuantity = 1;
					((Component)SELLTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentQuantity.ToString();
				}
				if (CurrentQuantity > 999)
				{
					CurrentQuantity = 999;
					((Component)SELLTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentQuantity.ToString();
				}
			}
			else
			{
				((Component)SELLTAB.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentQuantity.ToString();
			}
			((Component)SELLTAB.Find("AFTERPRESS/BUTTON/Text")).GetComponent<Text>().text = string.Format("<size=42>{0}</size>\n<color=#FF00FF>{1}: {2}</color> x <color=yellow>{3}</color>\n<color=#00FFFF>{4}:</color> <color=yellow>{5} {6}</color>", Localization.instance.Localize("$mpasn_sellmarketplace"), Localization.instance.Localize("$mpasn_quantitymarketplace"), CurrentQuantity, CurrentPrice, Localization.instance.Localize("$mpasn_youget"), CurrentQuantity * CurrentPrice, GetCurrentCurrencyName_Sell);
		}

		private static void SearchTabValue(string data)
		{
			if (!string.IsNullOrWhiteSpace(data))
			{
				AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
			}
			SEARCHVALUE = data;
			OnSort();
		}

		public static void OnMarketplaceDataUpdate()
		{
			int currentPage = CurrentPage;
			int? prevData = CurrentBuyData?._id;
			OnSort();
			CurrentPage = currentPage;
			CreateBuyGameObjects(prevData);
			LOADING.SetActive(false);
		}

		private static void ClearMarketplaceData()
		{
			Marketplace_Main_Client.MarketData.Clear();
		}

		private static void ResetPage()
		{
			if (IsPanelVisible())
			{
				if (currentMarketMode == Marketplace_DataTypes.MarketMode.BUY)
				{
					int currentPage = CurrentPage;
					OnSort();
					CurrentPage = currentPage;
					CreateBuyGameObjects();
				}
				else
				{
					int currentPage2 = CurrentPage;
					InventorySellData.Clear();
					InventorySellData.AddRange(CollectInventoryPlayerData());
					OnSort();
					CurrentPage = currentPage2;
					CreateSellGameObjects();
				}
				PageNumber.text = $"{CurrentPage + 1} / {CurrentMaxPage}";
			}
		}

		private static string GetTempItemTooltip(string prefab, int level, int stack, int variant, long crafterID, string crafterName, string CustomData)
		{
			return Utils.GetItemForTooltip(prefab, stack, level, variant, crafterID, crafterName, CustomData, 1, delegate(ItemData item)
			{
				JC_API_Class.JC_Api_Tooltip(item, (currentMarketMode == Marketplace_DataTypes.MarketMode.BUY) ? JC_Api[1] : JC_Api[0]);
			});
		}

		private static void PageIncrementor(int value)
		{
			AssetStorage.AUsrc.Play();
			((Component)SELLTAB.Find("AFTERPRESS")).gameObject.SetActive(false);
			((Component)BUYTAB.Find("AFTERPRESS")).gameObject.SetActive(false);
			int currentPage = CurrentPage;
			currentPage += value;
			if (currentPage >= 0 && currentPage < CurrentMaxPage)
			{
				CurrentPage = currentPage;
			}
			PageNumber.text = $"{CurrentPage + 1} / {CurrentMaxPage}";
			((Component)UI.transform.Find("Canvas/BACKGROUND/SEARCH/Input")).GetComponent<InputField>().text = SEARCHVALUE;
			ResetPage();
		}

		private static void OnClickBUYItem(int value)
		{
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			CurrentPrice = 0;
			CurrentQuantity = 1;
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS")).gameObject.SetActive(true);
			CurrentBuyData = ServerMarketSendDataSORTED[value];
			SharedData shared = ZNetScene.instance.GetPrefab(CurrentBuyData.ItemPrefab).GetComponent<ItemDrop>().m_itemData.m_shared;
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/icon")).GetComponent<Image>().sprite = ((shared.m_icons.Length > CurrentBuyData.Variant) ? shared.m_icons[CurrentBuyData.Variant] : shared.m_icons[0]);
			string tempItemTooltip = GetTempItemTooltip(CurrentBuyData.ItemPrefab, CurrentBuyData.Quality, CurrentBuyData.Count, CurrentBuyData.Variant, CurrentBuyData.CrafterID, CurrentBuyData.CrafterName, CurrentBuyData.CUSTOMdata);
			string text = Localization.instance.Localize(CurrentBuyData.ItemName);
			string text2 = string.Format("{0}\n<color=#00ff00>{1}: {2}</color>\n<color=#FF00FF>{3}: {4}</color>\n<color=yellow>{5}: {6}</color>\n<color=#00FFFF>{7}: {8}</color>", text, Localization.instance.Localize("$mpasn_quality"), CurrentBuyData.Quality, Localization.instance.Localize("$mpasn_quantitymarketplace"), CurrentBuyData.Count, Localization.instance.Localize("$mpasn_pricemarketplace"), CurrentBuyData.Price, Localization.instance.Localize("$mpasn_sellernamemarket"), CurrentBuyData.SellerName);
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/Text")).GetComponent<Text>().text = text2;
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/TooltipView/Viewport/Content/Tooltip")).GetComponent<Text>().text = tempItemTooltip;
			SkipQuantityCheck = true;
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = "-999";
			SkipQuantityCheck = false;
			SkipNextSound = true;
			((Component)((Component)BUYTAB).transform.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentBuyData.Count.ToString();
			foreach (GameObject currentGameObject in CurrentGameObjects)
			{
				((Graphic)currentGameObject.GetComponent<Image>()).color = new Color(0.3f, 0.3f, 0.3f, 0.7803922f);
			}
			((Graphic)CurrentGameObjects[value - 14 * CurrentPage].GetComponent<Image>()).color = Color.red;
			Canvas.ForceUpdateCanvases();
			ALLFILTERS.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			ALLFILTERS.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
			ALLSCROLLS.ForEach(delegate(Scrollbar scroll)
			{
				scroll.value = 1f;
			});
		}

		private static void OnClickSELLItem(int value)
		{
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			CurrentPrice = 0;
			CurrentQuantity = 1;
			CurrencyDropdown.value = 0;
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS")).gameObject.SetActive(true);
			CurrentSendData = InventorySellDataSORTED[value];
			SharedData shared = ZNetScene.instance.GetPrefab(CurrentSendData.ItemPrefab).GetComponent<ItemDrop>().m_itemData.m_shared;
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/icon")).GetComponent<Image>().sprite = ((shared.m_icons.Length > CurrentSendData.Variant) ? shared.m_icons[CurrentSendData.Variant] : shared.m_icons[0]);
			string tempItemTooltip = GetTempItemTooltip(CurrentSendData.ItemPrefab, CurrentSendData.Quality, CurrentSendData.Count, CurrentSendData.Variant, CurrentSendData.CrafterID, CurrentSendData.CrafterName, CurrentSendData.CUSTOMdata);
			string text = Localization.instance.Localize(CurrentSendData.ItemName);
			string text2 = string.Format("{0}\n<color=#00ff00>{1}: {2}</color>\n<color=#FF00FF>{3}: {4}</color>", text, Localization.instance.Localize("$mpasn_quality"), CurrentSendData.Quality, Localization.instance.Localize("$mpasn_quantitymarketplace"), CurrentSendData.Count);
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/Text")).GetComponent<Text>().text = text2;
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/TooltipView/Viewport/Content/Tooltip")).GetComponent<Text>().text = tempItemTooltip;
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/SetQuantity")).GetComponent<InputField>().text = CurrentQuantity.ToString();
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/SetPrice")).GetComponent<InputField>().text = CurrentPrice.ToString();
			string text3 = "<size=42>" + Localization.instance.Localize("$mpasn_sellmarketplace") + "</size>\n<color=#FF00FF>" + Localization.instance.Localize("$mpasn_quantitymarketplace") + ": 1</color> x <color=yellow>0</color>\n<color=#00FFFF>" + Localization.instance.Localize("$mpasn_youget") + ":</color> <color=yellow>0 " + GetCurrentCurrencyName_Sell + "</color>";
			((Component)((Component)SELLTAB).transform.Find("AFTERPRESS/BUTTON/Text")).GetComponent<Text>().text = text3;
			foreach (GameObject currentGameObject in CurrentGameObjects)
			{
				((Graphic)currentGameObject.GetComponent<Image>()).color = new Color(0.3f, 0.3f, 0.3f, 0.7803922f);
			}
			((Graphic)CurrentGameObjects[value - 14 * CurrentPage].GetComponent<Image>()).color = Color.red;
			Canvas.ForceUpdateCanvases();
			ALLFILTERS.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			ALLFILTERS.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
			ALLSCROLLS.ForEach(delegate(Scrollbar scroll)
			{
				scroll.value = 1f;
			});
		}

		private static void CreateBuyGameObjects(int? prevData = null)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			CurrentGameObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentGameObjects.Clear();
			if (Marketplace_Main_Client.MarketData.Count == 0)
			{
				return;
			}
			int num = CurrentPage * 14;
			Transform val = ((Component)BUYTAB).transform.Find("Content");
			for (int i = num; i < Mathf.Min(ServerMarketSendDataSORTED.Count, 14 + num); i++)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(ServerMarketSendDataSORTED[i].ItemPrefab);
				ItemDrop val2 = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
				GameObject val3 = Object.Instantiate<GameObject>(ElementBUY, val);
				CurrentGameObjects.Add(val3);
				if (Utils.IsDebug_Marketplace)
				{
					((Component)val3.transform.Find("AdminRemove")).gameObject.SetActive(true);
					int id = ServerMarketSendDataSORTED[i]._id;
					((UnityEvent)((Component)val3.transform.Find("AdminRemove")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						AssetStorage.AUsrc.Play();
						ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket RemoveItemAdmin", new object[1] { id });
					});
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Text[] componentsInChildren = val3.GetComponentsInChildren<Text>();
					foreach (Text val4 in componentsInChildren)
					{
						val4.text = "";
					}
					((Component)val3.transform.Find("itemname")).GetComponent<Text>().text = "<color=red>INVALID PREFAB (" + ServerMarketSendDataSORTED[i].ItemPrefab + ")</color>";
					continue;
				}
				int data = i;
				((UnityEvent)val3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					OnClickBUYItem(data);
				});
				string text = Localization.instance.Localize(ServerMarketSendDataSORTED[i].ItemName);
				((Component)val3.transform.Find("itemname")).GetComponent<Text>().text = text;
				((Component)val3.transform.Find("count")).GetComponent<Text>().text = ServerMarketSendDataSORTED[i].Count.ToString();
				((Component)val3.transform.Find("price")).GetComponent<Text>().text = ServerMarketSendDataSORTED[i].Price.ToString();
				((Component)val3.transform.Find("seller")).GetComponent<Text>().text = ServerMarketSendDataSORTED[i].SellerName;
				((Component)val3.transform.Find("currency")).GetComponent<Image>().sprite = Utils.TryFindIcon(ServerMarketSendDataSORTED[i].Currency);
				((Component)val3.transform.Find("itemicon")).GetComponent<Image>().sprite = ((val2.m_itemData.m_shared.m_icons.Length > ServerMarketSendDataSORTED[i].Variant) ? val2.m_itemData.m_shared.m_icons[ServerMarketSendDataSORTED[i].Variant] : val2.m_itemData.m_shared.m_icons[0]);
				if (prevData.HasValue && prevData == ServerMarketSendDataSORTED[i]._id)
				{
					((Graphic)val3.GetComponent<Image>()).color = Color.red;
					CurrentBuyData = ServerMarketSendDataSORTED[i];
				}
			}
			if (prevData.HasValue && CurrentBuyData == null)
			{
				((Component)((Component)BUYTAB).transform.Find("AFTERPRESS")).gameObject.SetActive(false);
			}
		}

		private static void CreateSellGameObjects()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			CurrentGameObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentGameObjects.Clear();
			if (InventorySellDataSORTED.Count == 0)
			{
				return;
			}
			int num = CurrentPage * 14;
			Transform val = ((Component)SELLTAB).transform.Find("Content");
			int num2 = 0;
			int num3 = num;
			while (num3 < Mathf.Min(InventorySellDataSORTED.Count, 14 + num))
			{
				ItemDrop component = ZNetScene.instance.GetPrefab(InventorySellDataSORTED[num3].ItemPrefab).GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null))
				{
					GameObject val2 = Object.Instantiate<GameObject>(ElementSELL, val);
					int data = num3;
					((UnityEvent)val2.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						OnClickSELLItem(data);
					});
					val2.transform.SetSiblingIndex(num2);
					string text = Localization.instance.Localize(InventorySellDataSORTED[num3].ItemName);
					((Component)val2.transform.Find("itemname")).GetComponent<Text>().text = text;
					((Component)val2.transform.Find("count")).GetComponent<Text>().text = InventorySellDataSORTED[num3].Count.ToString();
					((Component)val2.transform.Find("itemicon")).GetComponent<Image>().sprite = ((component.m_itemData.m_shared.m_icons.Length > InventorySellDataSORTED[num3].Variant) ? component.m_itemData.m_shared.m_icons[InventorySellDataSORTED[num3].Variant] : component.m_itemData.m_shared.m_icons[0]);
					CurrentGameObjects.Add(val2);
				}
				num3++;
				num2++;
			}
		}

		private static void SortValueList()
		{
			MySalesText.text = string.Format("{0} (<color=#00ff00>{1}</color>)", Localization.instance.Localize("$mpasn_mysales"), Marketplace_Main_Client.MarketData.Count((global::Marketplace.DB.DB.MarketSlot data) => data.SellerUserID == Global_Configs._localUserID));
			CurrentSendData = null;
			CurrentBuyData = null;
			ServerMarketSendDataSORTED.Clear();
			InventorySellDataSORTED.Clear();
			if (currentMarketMode == Marketplace_DataTypes.MarketMode.BUY)
			{
				if (Marketplace_Main_Client.MarketData.Count == 0)
				{
					return;
				}
				ServerMarketSendDataSORTED = Marketplace_Main_Client.MarketData.OrderByDescending((global::Marketplace.DB.DB.MarketSlot data) => data.TimeStamp).ToList();
				if (currentSortType == Marketplace_DataTypes.SortType.UP)
				{
					ServerMarketSendDataSORTED = currentSortMode switch
					{
						Marketplace_DataTypes.SortBy.None => ServerMarketSendDataSORTED.Where((global::Marketplace.DB.DB.MarketSlot data) => (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())).ToList(), 
						Marketplace_DataTypes.SortBy.ItemName => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby Localization.instance.Localize(data.ItemName)
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Count => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.Count
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Price => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.Price
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Seller => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.SellerName
							select data).ToList(), 
						_ => ServerMarketSendDataSORTED, 
					};
				}
				if (currentSortType == Marketplace_DataTypes.SortType.DOWN)
				{
					ServerMarketSendDataSORTED = currentSortMode switch
					{
						Marketplace_DataTypes.SortBy.None => ServerMarketSendDataSORTED.Where((global::Marketplace.DB.DB.MarketSlot data) => (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())).ToList(), 
						Marketplace_DataTypes.SortBy.ItemName => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby Localization.instance.Localize(data.ItemName) descending
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Count => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.Count descending
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Price => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.Price descending
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Seller => (from data in ServerMarketSendDataSORTED
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.SellerName descending
							select data).ToList(), 
						_ => ServerMarketSendDataSORTED, 
					};
				}
				if (MySalesOnly)
				{
					ServerMarketSendDataSORTED = ServerMarketSendDataSORTED.Where((global::Marketplace.DB.DB.MarketSlot data) => data.SellerUserID == Global_Configs._localUserID).ToList();
				}
				CurrentMaxPage = (ServerMarketSendDataSORTED.Count - 1) / 14 + 1;
				PageNumber.text = $"1 / {CurrentMaxPage}";
				CurrentPage = 0;
				CreateBuyGameObjects();
			}
			if (currentMarketMode == Marketplace_DataTypes.MarketMode.SELL && InventorySellData.Count != 0)
			{
				if (currentSortType == Marketplace_DataTypes.SortType.UP)
				{
					InventorySellDataSORTED = currentSortMode switch
					{
						Marketplace_DataTypes.SortBy.None => InventorySellData.Where((Marketplace_DataTypes.ClientMarketSendData data) => (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())).ToList(), 
						Marketplace_DataTypes.SortBy.ItemName => (from data in InventorySellData
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby Localization.instance.Localize(data.ItemName)
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Count => (from data in InventorySellData
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.Count
							select data).ToList(), 
						_ => InventorySellData, 
					};
				}
				if (currentSortType == Marketplace_DataTypes.SortType.DOWN)
				{
					InventorySellDataSORTED = currentSortMode switch
					{
						Marketplace_DataTypes.SortBy.None => InventorySellData.Where((Marketplace_DataTypes.ClientMarketSendData data) => (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())).ToList(), 
						Marketplace_DataTypes.SortBy.ItemName => (from data in InventorySellData
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby Localization.instance.Localize(data.ItemName) descending
							select data).ToList(), 
						Marketplace_DataTypes.SortBy.Count => (from data in InventorySellData
							where (currentCategory == Marketplace_DataTypes.ItemData_ItemCategory.ALL || data.ItemCategory == currentCategory) && Localization.instance.Localize(data.ItemName).ToLower().Contains(SEARCHVALUE.ToLower())
							orderby data.Count descending
							select data).ToList(), 
						_ => InventorySellData, 
					};
				}
				CurrentMaxPage = (InventorySellDataSORTED.Count - 1) / 14 + 1;
				PageNumber.text = $"1 / {CurrentMaxPage}";
				CurrentPage = 0;
				CreateSellGameObjects();
			}
		}

		private static void ClickBUYcategoryButton()
		{
			AssetStorage.AUsrc.Play();
			DefaultBUY();
			LOADING.SetActive(true);
			Marketplace_Main_Client.RequestData();
		}

		private static void ClickSELLcategoryButton()
		{
			AssetStorage.AUsrc.Play();
			DefaultSELL();
		}

		private static void DefaultBUY()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			MySalesOnly = false;
			((Graphic)MySalesText).color = Color.red;
			currentMarketMode = Marketplace_DataTypes.MarketMode.BUY;
			((Component)((Component)BUYTAB).transform).gameObject.SetActive(true);
			((Component)((Component)SELLTAB).transform).gameObject.SetActive(false);
			Button[] categoryButtons = CategoryButtons;
			foreach (Button val in categoryButtons)
			{
				((Graphic)((Component)((Component)val).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorNotActive;
			}
			currentCategory = Marketplace_DataTypes.ItemData_ItemCategory.ALL;
			((Graphic)((Component)((Component)CategoryButtons[(int)currentCategory]).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorActive;
			((Graphic)((Component)((Component)BuyButtonCategory).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorActive;
			((Graphic)((Component)((Component)SellButtonCategory).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorNotActive;
			Transform val2 = BUYTAB.Find("AFTERPRESS");
			((Component)val2).gameObject.SetActive(false);
			((Component)((Component)val2).transform.Find("icon")).GetComponent<Image>().sprite = AssetStorage.NullSprite;
			((Component)((Component)val2).transform.Find("Text")).GetComponent<Text>().text = "";
			((Component)((Component)val2).transform.Find("TooltipView/Viewport/Content/Tooltip")).GetComponent<Text>().text = "";
			((Component)((Component)val2).transform.Find("BUTTON/Text")).GetComponent<Text>().text = "";
			SEARCHVALUE = "";
			((Component)UI.transform.Find("Canvas/BACKGROUND/SEARCH/Input")).GetComponent<InputField>().text = SEARCHVALUE;
			currentSortType = Marketplace_DataTypes.SortType.UP;
			currentSortMode = Marketplace_DataTypes.SortBy.None;
			CurrentPage = 0;
			CurrentMaxPage = 1;
			PageNumber.text = $"1 / {CurrentMaxPage}";
			((Component)((Component)BUYTAB).transform.Find("itemname/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemnamemarket");
			((Component)((Component)BUYTAB).transform.Find("count/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_quantitymarketplace");
			((Component)((Component)BUYTAB).transform.Find("price/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_pricemarketplace") + " <color=grey>x1</color>";
			((Component)((Component)BUYTAB).transform.Find("seller/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_sellernamemarket");
		}

		private static void DefaultSELL()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			MySalesOnly = false;
			((Graphic)MySalesText).color = Color.red;
			InventorySellData.Clear();
			InventorySellData.AddRange(CollectInventoryPlayerData());
			currentMarketMode = Marketplace_DataTypes.MarketMode.SELL;
			((Component)((Component)BUYTAB).transform).gameObject.SetActive(false);
			((Component)((Component)SELLTAB).transform).gameObject.SetActive(true);
			Button[] categoryButtons = CategoryButtons;
			foreach (Button val in categoryButtons)
			{
				((Graphic)((Component)((Component)val).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorNotActive;
			}
			currentCategory = Marketplace_DataTypes.ItemData_ItemCategory.ALL;
			((Graphic)((Component)((Component)CategoryButtons[(int)currentCategory]).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorActive;
			((Graphic)((Component)((Component)BuyButtonCategory).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorNotActive;
			((Graphic)((Component)((Component)SellButtonCategory).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorActive;
			Transform val2 = SELLTAB.Find("AFTERPRESS");
			((Component)val2).gameObject.SetActive(false);
			((Component)((Component)val2).transform.Find("icon")).GetComponent<Image>().sprite = AssetStorage.NullSprite;
			((Component)((Component)val2).transform.Find("Text")).GetComponent<Text>().text = "";
			((Component)((Component)val2).transform.Find("TooltipView/Viewport/Content/Tooltip")).GetComponent<Text>().text = "";
			((Component)((Component)val2).transform.Find("BUTTON/Text")).GetComponent<Text>().text = "";
			((Component)((Component)val2).transform.Find("SetQuantity")).GetComponent<InputField>().text = "";
			((Component)((Component)val2).transform.Find("SetPrice")).GetComponent<InputField>().text = "";
			SEARCHVALUE = "";
			((Component)UI.transform.Find("Canvas/BACKGROUND/SEARCH/Input")).GetComponent<InputField>().text = SEARCHVALUE;
			currentSortType = Marketplace_DataTypes.SortType.UP;
			currentSortMode = Marketplace_DataTypes.SortBy.None;
			CurrentPage = 0;
			CurrentSendData = null;
			CurrentPrice = 0;
			CurrentQuantity = 1;
			CurrentMaxPage = 1;
			PageNumber.text = $"1 / {CurrentMaxPage}";
			((Component)((Component)SELLTAB).transform.Find("itemname/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemnamemarket");
			((Component)((Component)SELLTAB).transform.Find("count/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_quantitymarketplace");
			OnSort();
		}

		private static void SetCategory(int whichOne)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			currentCategory = (Marketplace_DataTypes.ItemData_ItemCategory)whichOne;
			Button[] categoryButtons = CategoryButtons;
			foreach (Button val in categoryButtons)
			{
				((Graphic)((Component)((Component)val).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorNotActive;
			}
			((Graphic)((Component)((Component)CategoryButtons[whichOne]).transform.Find("Text")).GetComponent<Text>()).color = DefaultCategoryColorActive;
			OnSort();
			((Component)SELLTAB.Find("AFTERPRESS")).gameObject.SetActive(false);
			((Component)BUYTAB.Find("AFTERPRESS")).gameObject.SetActive(false);
		}

		public static void Hide()
		{
			UI.SetActive(false);
			CurrentGameObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentGameObjects.Clear();
			ClearMarketplaceData();
		}

		public static void Show()
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			ClearMarketplaceData();
			UI.SetActive(true);
			DefaultBUY();
			LOADING.SetActive(true);
			Marketplace_Main_Client.RequestData();
			if (!Global_Configs.SyncedGlobalOptions.Value._blockedPlayerList.Contains(Global_Configs._localUserID))
			{
				if (Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(Global_Configs._localUserID))
				{
					((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Steam/Text")).GetComponent<Text>().text = Global_Configs._localUserID + "\n\t    <size=35>(VIP)</size>";
					((Graphic)((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Steam/Text")).GetComponent<Text>()).color = new Color(0f, 1f, 0f);
				}
				else
				{
					((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Steam/Text")).GetComponent<Text>().text = Global_Configs._localUserID + "\n\t    <size=35>(" + Localization.instance.Localize("$mpasn_allowed") + ")</size>";
					((Graphic)((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Steam/Text")).GetComponent<Text>()).color = new Color(0.8352942f, 0.8196079f, 37f / 51f);
				}
			}
			else
			{
				((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/MarketLimit/Text")).GetComponent<Text>().text = (Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(Global_Configs._localUserID) ? string.Format("{0}\n{1}\n<color=#00ff00>{2}:\n{3}%</color>", Localization.instance.Localize("$mpasn_slotlimit"), Global_Configs.SyncedGlobalOptions.Value._itemMarketLimit, Localization.instance.Localize("$mpasn_taxes"), Global_Configs.SyncedGlobalOptions.Value._vipmarketTaxes) : string.Format("{0}\n{1}\n{2}:\n{3}%", Localization.instance.Localize("$mpasn_slotlimit"), Global_Configs.SyncedGlobalOptions.Value._itemMarketLimit, Localization.instance.Localize("$mpasn_taxes"), Global_Configs.SyncedGlobalOptions.Value._marketTaxes));
				((Graphic)((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/Steam/Text")).GetComponent<Text>()).color = Color.red;
			}
			((Component)UI.transform.Find("Canvas/BACKGROUND/MainButtonsTab/MarketLimit/Text")).GetComponent<Text>().text = $"$mpasn_slotlimit\n{Global_Configs.SyncedGlobalOptions.Value._itemMarketLimit}\n$mpasn_taxes\n{(Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(Global_Configs._localUserID) ? $"<color=#00ff00>{Global_Configs.SyncedGlobalOptions.Value._vipmarketTaxes}%</color>" : $"{Global_Configs.SyncedGlobalOptions.Value._marketTaxes}%")}".Localize();
			UpdateAnnonIcon();
		}
	}
}
namespace Marketplace.Modules.KG_Chat
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class KG_Chat
	{
		[Flags]
		public enum ChatFilter
		{
			None = 0,
			Normal = 1,
			Shout = 2,
			Whisper = 4,
			All = 7
		}

		public class ResizeUI : MonoBehaviour, IDragHandler, IEventSystemHandler, IEndDragHandler
		{
			private static RectTransform dragRect;

			private static TextMeshProUGUI text;

			private static ConfigEntry<float> UI_X;

			private static ConfigEntry<float> UI_Y;

			public Vector3 Scale => new Vector3(((Transform)dragRect).localScale.x, ((Transform)dragRect).localScale.y, 1f);

			public static void Default()
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)dragRect))
				{
					UI_X.Value = (float)((ConfigEntryBase)UI_X).DefaultValue;
					UI_Y.Value = (float)((ConfigEntryBase)UI_Y).DefaultValue;
					((BaseUnityPlugin)Marketplace._thistype).Config.Save();
					((Transform)dragRect).localScale = new Vector3(UI_X.Value, UI_Y.Value, 1f);
					((TMP_Text)text).fontSize = kgchat_Fontsize.Value;
				}
			}

			public void Setup()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				Transform parent = ((Component)this).transform.parent.parent;
				text = ((Component)parent.Find("Tabs Content/MainTab/Scroll Rect/Viewport/Content/Text")).GetComponent<TextMeshProUGUI>();
				dragRect = ((Component)parent.parent).GetComponent<RectTransform>();
				UI_X = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<float>("KG Chat", "UI_sizeX", 1f, "UI X size");
				UI_Y = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<float>("KG Chat", "UI_sizeY", 1f, "UI Y size");
				((Transform)dragRect).localScale = new Vector3(UI_X.Value, UI_Y.Value, 1f);
				((TMP_Text)text).fontSize = (int)((float)kgchat_Fontsize.Value + (float)kgchat_Fontsize.Value * (1f - UI_X.Value));
			}

			public void OnDrag(PointerEventData eventData)
			{
				//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_000b: 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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: 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_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = -eventData.delta;
				Vector3 localScale = ((Transform)dragRect).localScale;
				Vector2 val2 = dragRect.sizeDelta + new Vector2(34f * localScale.x, 0f);
				val.x /= val2.x;
				Vector3 val3 = localScale + new Vector3(val.x, val.x, 0f);
				val3.x = Mathf.Clamp(val3.x, 0.5f, 1.5f);
				val3.y = Mathf.Clamp(val3.y, 0.5f, 1.5f);
				val3.z = 1f;
				localScale = val3;
				((Transform)dragRect).localScale = localScale;
				((TMP_Text)text).fontSize = (int)((float)kgchat_Fontsize.Value + 16f * Mathf.Abs(1f - val3.x));
			}

			public void OnEndDrag(PointerEventData data)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Vector3 localScale = ((Transform)dragRect).localScale;
				UI_X.Value = localScale.x;
				UI_Y.Value = localScale.y;
				((BaseUnityPlugin)Marketplace._thistype).Config.Save();
				((TMP_InputField)((Terminal)Chat.instance).m_input).MoveTextEnd(false);
			}
		}

		public class DragUI : MonoBehaviour, IDragHandler, IEventSystemHandler, IEndDragHandler
		{
			private static RectTransform dragRect;

			private static ConfigEntry<float> UI_X;

			private static ConfigEntry<float> UI_Y;

			private readonly Transform[] Markers = (Transform[])(object)new Transform[4];

			public static void Default()
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)dragRect))
				{
					UI_X.Value = (float)((ConfigEntryBase)UI_X).DefaultValue;
					UI_Y.Value = (float)((ConfigEntryBase)UI_Y).DefaultValue;
					((BaseUnityPlugin)Marketplace._thistype).Config.Save();
					dragRect.anchoredPosition = new Vector2(UI_X.Value, UI_Y.Value);
				}
			}

			public void Setup()
			{
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				UI_X = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<float>("KG Chat", "UI_posX", -15f, "UI X position");
				UI_Y = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<float>("KG Chat", "UI_posY", 60f, "UI Y position");
				dragRect = ((Component)((Component)this).transform.parent.parent.parent).GetComponent<RectTransform>();
				Vector2 anchoredPosition = default(Vector2);
				((Vector2)(ref anchoredPosition))..ctor(UI_X.Value, UI_Y.Value);
				dragRect.anchoredPosition = anchoredPosition;
				Markers[0] = ((Component)dragRect).transform.Find("LeftTop");
				Markers[1] = ((Component)dragRect).transform.Find("RightTop");
				Markers[2] = ((Component)dragRect).transform.Find("LeftBottom");
				Markers[3] = ((Component)dragRect).transform.Find("RightBottom");
				if (CheckMarkersOutsideScreen(new Vector2((float)Screen.width, (float)Screen.height)))
				{
					Default();
				}
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: 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_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: 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_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				Vector2 anchoredPosition = dragRect.anchoredPosition;
				Vector2 val = anchoredPosition + eventData.delta / Vector2.op_Implicit(((Transform)dragRect).lossyScale) * Vector2.op_Implicit(((Transform)dragRect).localScale);
				Vector2 anchoredPosition2 = anchoredPosition;
				anchoredPosition = val;
				dragRect.anchoredPosition = anchoredPosition;
				if (CheckMarkersOutsideScreen(new Vector2((float)Screen.width, (float)Screen.height)))
				{
					dragRect.anchoredPosition = anchoredPosition2;
				}
			}

			private bool CheckMarkersOutsideScreen(Vector2 screen)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				Transform[] markers = Markers;
				foreach (Transform val in markers)
				{
					Vector3 position = val.position;
					float x = position.x;
					float y = position.y;
					if (x < 0f || x > screen.x || y < 0f || y > screen.y)
					{
						return true;
					}
				}
				return false;
			}

			public void OnEndDrag(PointerEventData data)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Vector2 anchoredPosition = dragRect.anchoredPosition;
				UI_X.Value = anchoredPosition.x;
				UI_Y.Value = anchoredPosition.y;
				((BaseUnityPlugin)Marketplace._thistype).Config.Save();
				((TMP_InputField)((Terminal)Chat.instance).m_input).MoveTextEnd(false);
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				ApplyKGChat();
			}
		}

		[HarmonyPatch(typeof(Chat), "Awake")]
		[ClientOnlyPatch]
		private static class Chat_Awake_Patch
		{
			private static bool isKGChat(GameObject go)
			{
				return ((Object)go).name == "KGChat";
			}

			[UsedImplicitly]
			private static void Prefix(Chat __instance)
			{
				Chat __instance2 = __instance;
				if (!isKGChat(((Component)__instance2).gameObject))
				{
					origStuff[0] = __instance2.m_worldTextBase;
					origStuff[1] = __instance2.m_npcTextBase;
					origStuff[2] = __instance2.m_npcTextBaseLarge;
					origFont = ((TMP_Text)((Terminal)__instance2).m_output).font;
					origFont2 = ((TMP_InputField)((Terminal)__instance2).m_input).textComponent.font;
					return;
				}
				__instance2.m_worldTextBase = origStuff[0];
				__instance2.m_npcTextBase = origStuff[1];
				__instance2.m_npcTextBaseLarge = origStuff[2];
				((TMP_Text)((Terminal)__instance2).m_output).font = origFont;
				((Component)((TMP_InputField)((Terminal)__instance2).m_input).placeholder).GetComponent<TMP_Text>().font = origFont2;
				((TMP_InputField)((Terminal)__instance2).m_input).textComponent.font = origFont2;
				((TMP_InputField)((Terminal)__instance2).m_input).fontAsset = origFont2;
				((Component)((Terminal)__instance2).m_input).gameObject.SetActive(false);
				((UnityEvent<string>)(object)((Terminal)__instance2).m_input.OnInputSubmit).AddListener((UnityAction<string>)delegate
				{
					__instance2.SendInput();
				});
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class Menu_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (Object.op_Implicit((Object)(object)kgChat))
				{
					__result |= ((Component)((Terminal)Chat.instance).m_input).gameObject.activeInHierarchy;
				}
			}
		}

		[HarmonyPatch(typeof(Chat), "Update")]
		[ClientOnlyPatch]
		private static class Chat_Patches3
		{
			[HarmonyTranspiler]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Code(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> list = new List<CodeInstruction>(instructions);
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].opcode == OpCodes.Ldc_I4 && ((int)list[i].operand == 323 || (int)list[i].operand == 324))
					{
						list[i].opcode = OpCodes.Nop;
						list[i + 1].opcode = OpCodes.Nop;
						list[i + 2].opcode = OpCodes.Nop;
						list[i + 3].opcode = OpCodes.Nop;
					}
				}
				return list;
			}
		}

		[HarmonyPatch(typeof(Terminal), "AddString", new Type[]
		{
			typeof(PlatformUserID),
			typeof(string),
			typeof(Type),
			typeof(bool)
		})]
		[ClientOnlyPatch]
		private static class Chat_Patches2
		{
			[HarmonyTranspiler]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Code(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> list = new List<CodeInstruction>(instructions);
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(string), "ToUpper", Type.EmptyTypes, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.DeclaredMethod(typeof(string), "ToLowerInvariant", Type.EmptyTypes, (Type[])null);
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].opcode == OpCodes.Callvirt && (list[i].operand == methodInfo || list[i].operand == methodInfo2))
					{
						list[i - 1].opcode = OpCodes.Nop;
						list[i].opcode = OpCodes.Nop;
						list[i + 1].opcode = OpCodes.Nop;
					}
				}
				return list;
			}
		}

		[HarmonyPatch(typeof(Terminal), "UpdateChat")]
		[ClientOnlyPatch]
		private static class Terminal_UpdateChat_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Terminal __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)kgChat))
				{
					__instance.m_scrollHeight = 0;
					__instance.m_maxVisibleBufferLength = 45;
				}
			}

			[UsedImplicitly]
			private static void Postfix(Terminal __instance)
			{
				if ((Object)(object)__instance == (Object)(object)kgChat && !((TMP_InputField)__instance.m_input).isFocused)
				{
					ResetScroll();
				}
			}
		}

		public class ChatController : MonoBehaviour
		{
			public enum Transparency
			{
				None,
				One,
				Two,
				Three,
				Four,
				Five
			}

			public enum SendMode
			{
				Say,
				Shout,
				Whisper,
				Group,
				Faction
			}

			public static ChatController Instance = null;

			public SendMode mode;

			private Transform Emojis_Tab;

			private static readonly Dictionary<Transparency, float> Transparency_Map = new Dictionary<Transparency, float>
			{
				{
					Transparency.None,
					0f
				},
				{
					Transparency.One,
					0.2f
				},
				{
					Transparency.Two,
					0.4f
				},
				{
					Transparency.Three,
					0.6f
				},
				{
					Transparency.Four,
					0.8f
				},
				{
					Transparency.Five,
					0.95f
				}
			};

			private Image SayImage;

			private Image ShoutImage;

			private Image WhisperImage;

			private Image GroupImage;

			private Image FactionImage;

			public void Setup()
			{
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected O, but got Unknown
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Expected O, but got Unknown
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Expected O, but got Unknown
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Expected O, but got Unknown
				//IL_0280: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Expected O, but got Unknown
				//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_031c: Unknown result type (might be due to invalid IL or missing references)
				//IL_034b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0355: Expected O, but got Unknown
				Instance = this;
				mode = SendMode.Say;
				Button component = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Say")).GetComponent<Button>();
				Button component2 = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Shout")).GetComponent<Button>();
				Button component3 = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Whisper")).GetComponent<Button>();
				Button component4 = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Groups")).GetComponent<Button>();
				Button component5 = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Factions")).GetComponent<Button>();
				Button _muteSoundsButton = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/MuteSounds")).GetComponent<Button>();
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					ButtonClick(SendMode.Say);
				});
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					ButtonClick(SendMode.Shout);
				});
				((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
				{
					ButtonClick(SendMode.Whisper);
				});
				((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
				{
					ButtonClick(SendMode.Group);
				});
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					ButtonClick(SendMode.Faction);
				});
				SayImage = ((Component)((Component)component).gameObject.transform.GetChild(0)).GetComponent<Image>();
				ShoutImage = ((Component)((Component)component2).gameObject.transform.GetChild(0)).GetComponent<Image>();
				WhisperImage = ((Component)((Component)component3).gameObject.transform.GetChild(0)).GetComponent<Image>();
				GroupImage = ((Component)((Component)component4).gameObject.transform.GetChild(0)).GetComponent<Image>();
				FactionImage = ((Component)((Component)component5).gameObject.transform.GetChild(0)).GetComponent<Image>();
				((Graphic)SayImage).color = Color.green;
				if (!Groups.API.IsLoaded())
				{
					((Component)component4).gameObject.SetActive(false);
				}
				Emojis_Tab = ((Component)this).transform.Find("CHATWINDOW/Input Field/Emoji_Tab");
				? val = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field")).GetComponent<TMP_InputField>();
				Transform obj = ((Component)this).transform.Find("CHATWINDOW/Input Field");
				((TMP_InputField)val).textViewport = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				FillEmojis();
				((UnityEvent)((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Emojis")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					((Component)Emojis_Tab).gameObject.SetActive(!((Component)Emojis_Tab).gameObject.activeSelf);
					AssetStorage.AUsrc.Play();
				});
				((Component)((Component)_muteSoundsButton).transform.Find("TF")).gameObject.SetActive(!useTypeSound.Value);
				((UnityEvent)_muteSoundsButton.onClick).AddListener((UnityAction)delegate
				{
					AssetStorage.AUsrc.Play();
					useTypeSound.Value = !useTypeSound.Value;
					((BaseUnityPlugin)Marketplace._thistype).Config.Save();
					((Component)((Component)_muteSoundsButton).transform.Find("TF")).gameObject.SetActive(!useTypeSound.Value);
				});
				Transform bgone = ((Component)this).transform.Find("CHATWINDOW/Background/Upper Background");
				Transform bgtwo = ((Component)this).transform.Find("CHATWINDOW/Input Field/Lower Background");
				((Graphic)((Component)bgone).GetComponent<Image>()).color = new Color(0f, 0f, 0f, Transparency_Map[kgchat_Transparency.Value]);
				((Graphic)((Component)bgtwo).GetComponent<Image>()).color = new Color(0f, 0f, 0f, Transparency_Map[kgchat_Transparency.Value]);
				Button component6 = ((Component)((Component)this).transform.Find("CHATWINDOW/Input Field/Transparency")).GetComponent<Button>();
				((UnityEvent)component6.onClick).AddListener((UnityAction)delegate
				{
					//IL_0050: Unknown result type (might be due to invalid IL or missing references)
					//IL_0088: Unknown result type (might be due to invalid IL or missing references)
					AssetStorage.AUsrc.Play();
					kgchat_Transparency.Value = (Transparency)((int)(kgchat_Transparency.Value + 1) % 6);
					((Graphic)((Component)bgone).GetComponent<Image>()).color = new Color(0f, 0f, 0f, Transparency_Map[kgchat_Transparency.Value]);
					((Graphic)((Component)bgtwo).GetComponent<Image>()).color = new Color(0f, 0f, 0f, Transparency_Map[kgchat_Transparency.Value]);
					MessageHud.instance.ShowMessage((MessageType)2, $"<color=green>{Transparency_Map[kgchat_Transparency.Value] * 100f}%</color>", 0, (Sprite)null, false);
					((BaseUnityPlugin)Marketplace._thistype).Config.Save();
				});
			}

			private void FillEmojis()
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				Transform val = Emojis_Tab.Find("Emoji");
				foreach (KeyValuePair<string, string> em in Emoji_Map)
				{
					Button component = ((Component)Object.Instantiate<Transform>(val, Emojis_Tab)).GetComponent<Button>();
					((Component)component).gameObject.SetActive(true);
					((TMP_Text)((Component)((Component)component).transform.Find("text")).GetComponent<TextMeshProUGUI>()).text = em.Value;
					((UnityEvent)component.onClick).AddListener((UnityAction)delegate
					{
						EmojiClick(em.Key);
					});
				}
			}

			private void EmojiClick(string key)
			{
				if (Object.op_Implicit((Object)(object)Chat.instance))
				{
					AssetStorage.AUsrc.Play();
					GuiInputField input = ((Terminal)Chat.instance).m_input;
					((TMP_InputField)input).text = ((TMP_InputField)input).text + key + " ";
					((TMP_InputField)((Terminal)Chat.instance).m_input).MoveTextEnd(false);
				}
			}

			public void ButtonClick(SendMode newMode)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: 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_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: 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_0095: Unknown result type (might be due to invalid IL or missing references)
				mode = newMode;
				((Graphic)SayImage).color = ((mode == SendMode.Say) ? Color.green : Color.white);
				((Graphic)ShoutImage).color = ((mode == SendMode.Shout) ? Color.green : Color.white);
				((Graphic)WhisperImage).color = ((mode == SendMode.Whisper) ? Color.green : Color.white);
				((Graphic)GroupImage).color = ((mode == SendMode.Group) ? Color.green : Color.white);
				((Graphic)FactionImage).color = ((mode == SendMode.Faction) ? Color.green : Color.white);
				AssetStorage.AUsrc.Play();
			}
		}

		[HarmonyPatch(typeof(Chat), "InputText")]
		[ClientOnlyPatch]
		private static class Chat_InputText_Patch
		{
			[CompilerGenerated]
			private sealed class <Code>d__3 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private bool <isdone>5__2;

				private IEnumerator<CodeInstruction> <>7__wrap2;

				private CodeInstruction <instruction>5__4;

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

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

				[DebuggerHidden]
				public <Code>d__3(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__wrap2 = null;
					<instruction>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f8: Expected O, but got Unknown
					//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bf: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<isdone>5__2 = false;
							<>7__wrap2 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							if (<instruction>5__4.opcode == OpCodes.Stloc_0 && !<isdone>5__2)
							{
								<isdone>5__2 = true;
								<>2__current = new CodeInstruction(OpCodes.Ldloca_S, (object)0);
								<>1__state = 2;
								return true;
							}
							goto IL_010b;
						case 2:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Chat_InputText_Patch), "ModifyInput", (Type[])null, (Type[])null));
							<>1__state = 3;
							return true;
						case 3:
							{
								<>1__state = -3;
								goto IL_010b;
							}
							IL_010b:
							<instruction>5__4 = null;
							break;
						}
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							<>2__current = <instruction>5__4;
							<>1__state = 1;
							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()
				{
					<Code>d__3 <Code>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Code>d__ = this;
					}
					else
					{
						<Code>d__ = new <Code>d__3(0);
					}
					<Code>d__.instructions = <>3__instructions;
					return <Code>d__;
				}

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

			private static void ModifyInput(ref string text)
			{
				if (Object.op_Implicit((Object)(object)kgChat) && text.Length != 0 && text[0] != '/')
				{
					text = ChatController.Instance.mode switch
					{
						ChatController.SendMode.Say => "/say " + text, 
						ChatController.SendMode.Shout => "/s " + text, 
						ChatController.SendMode.Whisper => "/w " + text, 
						ChatController.SendMode.Group => "/p " + text, 
						ChatController.SendMode.Faction => "/f " + text, 
						_ => "/say " + text, 
					};
				}
			}

			[UsedImplicitly]
			private static void Postfix()
			{
				ResetScroll();
			}

			[UsedImplicitly]
			private static bool Prefix()
			{
				return !Global_Configs.SyncedGlobalOptions.Value._blockedChatUsers.Contains(Global_Configs._localUserID);
			}

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

		[HarmonyPatch(typeof(Terminal), "AddString", new Type[] { typeof(string) })]
		[ClientOnlyPatch]
		private static class EmojiPatchV2
		{
			private static void Prefix(ref string text)
			{
				if (Object.op_Implicit((Object)(object)kgChat))
				{
					text = ReplaceEmojisToSprites(text);
				}
			}
		}

		[HarmonyPatch(typeof(Chat), "AddInworldText")]
		[ClientOnlyPatch]
		private static class Chat_AddInworldText_Patch
		{
			[UsedImplicitly]
			private static bool Prefix(ref string text, Type type)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Invalid comparison between Unknown and I4
				if (!Object.op_Implicit((Object)(object)kgChat))
				{
					return true;
				}
				if (Object.op_Implicit((Object)(object)kgChat) && HideFloatingText.Value && (int)type != 3)
				{
					return false;
				}
				text = RemoveEmojis(text);
				return true;
			}
		}

		[HarmonyPatch(typeof(Chat), "OnNewChatMessage")]
		[ClientOnlyPatch]
		private static class Chat_OnNewChatMessage_Patch
		{
			[UsedImplicitly]
			private static bool Prefix(Chat __instance, Type type)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected I4, but got Unknown
				if (!Object.op_Implicit((Object)(object)kgChat))
				{
					return true;
				}
				switch ((int)type)
				{
				case 1:
					if (ChatFilterMode.Value.HasFlagFast(ChatFilter.Normal))
					{
						break;
					}
					goto IL_005e;
				case 2:
					if (ChatFilterMode.Value.HasFlagFast(ChatFilter.Shout))
					{
						break;
					}
					goto IL_005e;
				case 0:
					{
						if (ChatFilterMode.Value.HasFlagFast(ChatFilter.Whisper))
						{
							break;
						}
						goto IL_005e;
					}
					IL_005e:
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Chat), "isAllowedCommand")]
		[ClientOnlyPatch]
		private static class Chat_isAllowedCommand_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= Object.op_Implicit((Object)(object)kgChat) && Utils.IsDebug_Strict;
			}
		}

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

				public static ConsoleEvent <>9__0_0;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					string value = args.Args[1];
					if (Enum.TryParse<ChatFilter>(value, ignoreCase: true, out var result))
					{
						ConfigEntry<ChatFilter> chatFilterMode = ChatFilterMode;
						chatFilterMode.Value ^= result;
						((BaseUnityPlugin)Marketplace._thistype).Config.Save();
						Chat.instance.m_hideTimer = 0f;
						args.Context.AddString($"<color=green>Chat Filter: {ChatFilterMode.Value}</color>");
					}
				}
			}

			[UsedImplicitly]
			private static void Postfix(Terminal __instance)
			{
				//IL_0032: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						string value = args.Args[1];
						if (Enum.TryParse<ChatFilter>(value, ignoreCase: true, out var result))
						{
							ConfigEntry<ChatFilter> chatFilterMode = ChatFilterMode;
							chatFilterMode.Value ^= result;
							((BaseUnityPlugin)Marketplace._thistype).Config.Save();
							Chat.instance.m_hideTimer = 0f;
							args.Context.AddString($"<color=green>Chat Filter: {ChatFilterMode.Value}</color>");
						}
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("chatfilter", "Add / Remove chat filter", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__21_0;

			public static MatchEvaluator <>9__31_0;

			internal void <ApplyKGChat>b__21_0()
			{
				ResizeUI.Default();
				DragUI.Default();
				AssetStorage.AUsrc.Play();
			}

			internal string <ReplaceEmojisToSprites>b__31_0(Match match)
			{
				return Emoji_Map[match.Value];
			}
		}

		[CompilerGenerated]
		private sealed class <corout_ResetScroll>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (Object.op_Implicit((Object)(object)kgChat_Scrollbar))
					{
						kgChat_Scrollbar.value = 0f;
					}
					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();
			}
		}

		private static GameObject original_KG_Chat = null;

		private static readonly GameObject[] origStuff = (GameObject[])(object)new GameObject[3];

		private static TMP_FontAsset origFont = null;

		private static TMP_FontAsset origFont2 = null;

		private static ConfigEntry<int> kgchat_Fontsize = null;

		private static ConfigEntry<bool> useTypeSound = null;

		private static ConfigEntry<ChatController.Transparency> kgchat_Transparency = null;

		private static Chat kgChat = null;

		private static Scrollbar kgChat_Scrollbar = null;

		private static readonly List<ContentSizeFitter> fitters = new List<ContentSizeFitter>();

		private static ConfigEntry<bool> HideFloatingText = null;

		private static ConfigEntry<ChatFilter> ChatFilterMode = null;

		private static Coroutine _corout;

		private static readonly Dictionary<string, string> Emoji_Map = new Dictionary<string, string>
		{
			{ ":moji0:", "<sprite=0>" },
			{ ":moji1:", "<sprite=1>" },
			{ ":moji2:", "<sprite=2>" },
			{ ":moji3:", "<sprite=3>" },
			{ ":moji4:", "<sprite=4>" },
			{ ":moji5:", "<sprite=5>" },
			{ ":moji6:", "<sprite=6>" },
			{ ":moji7:", "<sprite=7>" },
			{ ":moji8:", "<sprite=8>" },
			{ ":moji9:", "<sprite=9>" },
			{ ":moji10:", "<sprite=10>" },
			{ ":moji11:", "<sprite=11>" },
			{ ":moji12:", "<sprite=12>" },
			{ ":moji13:", "<sprite=13>" },
			{ ":moji14:", "<sprite=14>" },
			{ ":moji15:", "<sprite=15>" },
			{ ":moji16:", "<sprite=16>" },
			{ ":moji17:", "<sprite=17>" },
			{ ":moji18:", "<sprite=18>" },
			{ ":moji19:", "<sprite=19>" },
			{ ":moji20:", "<sprite=20>" },
			{ ":moji21:", "<sprite=21>" },
			{ ":moji22:", "<sprite=22>" },
			{ ":moji23:", "<sprite=23>" },
			{ ":moji24:", "<sprite=24>" }
		};

		private static readonly Regex EmojiRegex = new Regex(string.Join("|", Emoji_Map.Keys.Select(Regex.Escape)), RegexOptions.Compiled);

		public static bool HasFlagFast(this ChatFilter flags, ChatFilter flag)
		{
			return (flags & flag) != 0;
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			kgchat_Fontsize = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<int>("KG Chat", "Font Size", 18, "KG Chat Font Size");
			useTypeSound = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("KG Chat", "Use Type Sound", false, "Use KG Chat Type Sound");
			HideFloatingText = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("KG Chat", "Hide Floating Text", true, "Hide Floating Text");
			ChatFilterMode = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<ChatFilter>("KG Chat", "Chat Filter", ChatFilter.All, "Chat Filter");
			kgchat_Transparency = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<ChatController.Transparency>("KG Chat", "Transparency", ChatController.Transparency.Two, "KG Chat Transparency");
			original_KG_Chat = AssetStorage.asset.LoadAsset<GameObject>("Marketplace_KGChat_SelfCanvas");
			original_KG_Chat.GetComponent<Canvas>().sortingOrder = 599;
			Global_Configs.SyncedGlobalOptions.ValueChanged += ApplyKGChat;
			string path = Path.Combine(Paths.ConfigPath, "Marketplace_KGChat_Emojis", "spritesheet_original.png");
			string path2 = Path.Combine(Paths.ConfigPath, "Marketplace_KGChat_Emojis", "spritesheet.png");
			if (!Directory.Exists(Path.GetDirectoryName(path)))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(path));
			}
			if (!File.Exists(path))
			{
				Texture2D val = (Texture2D)((TMP_Text)original_KG_Chat.GetComponentInChildren<TextMeshProUGUI>(true)).spriteAsset.spriteSheet;
				byte[] bytes = ImageConversion.EncodeToPNG(val);
				File.WriteAllBytes(path, bytes);
			}
			if (File.Exists(path2))
			{
				Texture2D val2 = new Texture2D(2, 2);
				ImageConversion.LoadImage(val2, File.ReadAllBytes(path2));
				TextMeshProUGUI[] componentsInChildren = original_KG_Chat.GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI val3 in componentsInChildren)
				{
					((TMP_Text)val3).spriteAsset.spriteSheet = (Texture)(object)val2;
					((TMP_Asset)((TMP_Text)val3).spriteAsset).material.SetTexture(ShaderUtilities.ID_MainTex, (Texture)(object)val2);
				}
			}
			Marketplace.Global_FixedUpdator = (Action<float>)Delegate.Combine(Marketplace.Global_FixedUpdator, new Action<float>(KGChat_Update));
		}

		private static void ResetScroll()
		{
			if (_corout != null)
			{
				((MonoBehaviour)Marketplace._thistype).StopCoroutine(_corout);
			}
			_corout = ((MonoBehaviour)Marketplace._thistype).StartCoroutine(corout_ResetScroll());
		}

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

		private static void ApplyKGChat()
		{
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			if (!Global_Configs.SyncedGlobalOptions.Value._enableKGChat || Object.op_Implicit((Object)(object)kgChat) || !Object.op_Implicit((Object)(object)Chat.instance))
			{
				return;
			}
			Utils.print("Switching to KG Chat", ConsoleColor.Cyan);
			ZRoutedRpc.instance.m_functions.Remove(StringExtensionMethods.GetStableHashCode("ChatMessage"));
			ZRoutedRpc.instance.m_functions.Remove(StringExtensionMethods.GetStableHashCode("RPC_TeleportPlayer"));
			Transform parent = ((Component)Chat.instance).transform.parent;
			((Component)((Terminal)Chat.instance).m_chatWindow).gameObject.SetActive(false);
			((Component)((Terminal)Chat.instance).m_input).gameObject.SetActive(false);
			((Component)((Terminal)Chat.instance).m_output).gameObject.SetActive(false);
			Object.DestroyImmediate((Object)(object)Chat.instance);
			kgChat = ((Component)Object.Instantiate<GameObject>(original_KG_Chat, parent).transform.Find("KGChat")).GetComponent<Chat>();
			fitters.Clear();
			fitters.AddRange(((Component)kgChat).GetComponentsInChildren<ContentSizeFitter>(true));
			((Component)kgChat).gameObject.AddComponent<ChatController>().Setup();
			((Component)((Component)kgChat).transform.Find("CHATWINDOW/Input Field/Resize")).gameObject.AddComponent<ResizeUI>().Setup();
			((Component)((Component)kgChat).transform.Find("CHATWINDOW/Input Field/Move")).gameObject.AddComponent<DragUI>().Setup();
			ButtonClickedEvent onClick = ((Component)((Component)kgChat).transform.Find("CHATWINDOW/Input Field/Reset")).gameObject.GetComponent<Button>().onClick;
			object obj = <>c.<>9__21_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					ResizeUI.Default();
					DragUI.Default();
					AssetStorage.AUsrc.Play();
				};
				<>c.<>9__21_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			((UnityEvent<string>)(object)((TMP_InputField)((Component)kgChat).GetComponentInChildren<GuiInputField>(true)).onValueChanged).AddListener((UnityAction<string>)IF_OnValueChanged);
			kgChat_Scrollbar = ((Component)kgChat).GetComponentInChildren<Scrollbar>(true);
			((Terminal)Chat.instance).AddString("<color=green>KG Chat Loaded</color>");
			((Terminal)Chat.instance).AddString("<color=green>/say | /shout | /whisper | /faction to switch chat mode</color>");
			if (Groups.API.IsLoaded())
			{
				((Terminal)Chat.instance).AddString("<color=green>/group | /party to switch to groups chat mode</color>");
			}
			((TMP_InputField)((Terminal)Chat.instance).m_input).characterLimit = 128;
		}

		private static void KGChat_Update(float dt)
		{
			if (Object.op_Implicit((Object)(object)kgChat) && ((UIBehaviour)((Terminal)Chat.instance).m_input).IsActive())
			{
				((Terminal)Chat.instance).m_input.ActivateInputField();
			}
		}

		private static void IF_OnValueChanged(string value)
		{
			if (useTypeSound.Value && !string.IsNullOrEmpty(value))
			{
				AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, Random.Range(0.65f, 0.75f));
			}
			switch (value)
			{
			case "/shout":
				((TMP_InputField)((Terminal)kgChat).m_input).text = "";
				ChatController.Instance.ButtonClick(ChatController.SendMode.Shout);
				break;
			case "/say":
				((TMP_InputField)((Terminal)kgChat).m_input).text = "";
				ChatController.Instance.ButtonClick(ChatController.SendMode.Say);
				break;
			case "/group":
			case "/party":
				if (Groups.API.IsLoaded())
				{
					((TMP_InputField)((Terminal)kgChat).m_input).text = "";
					ChatController.Instance.ButtonClick(ChatController.SendMode.Group);
				}
				break;
			case "/whisper":
				((TMP_InputField)((Terminal)kgChat).m_input).text = "";
				ChatController.Instance.ButtonClick(ChatController.SendMode.Whisper);
				break;
			case "/faction":
				((TMP_InputField)((Terminal)kgChat).m_input).text = "";
				ChatController.Instance.ButtonClick(ChatController.SendMode.Faction);
				break;
			}
		}

		private static string ReplaceEmojisToSprites(string text)
		{
			return EmojiRegex.Replace(text, (Match match) => Emoji_Map[match.Value]);
		}

		private static string RemoveEmojis(string text)
		{
			return EmojiRegex.Replace(text, "");
		}
	}
}
namespace Marketplace.Modules.Global_Options
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.First, "OnInit", new string[] { "MarketPlace.cfg" }, new string[] { "OnChange" })]
	public static class Global_Configs
	{
		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class Game_Awake_Patch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodInfo>, IEnumerable, IEnumerator<MethodInfo>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodInfo <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZNet), "Start", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						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]
				IEnumerator<MethodInfo> IEnumerable<MethodInfo>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

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

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			[UsedImplicitly]
			public static IEnumerable<MethodInfo> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			[UsedImplicitly]
			private static void Postfix()
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Utils.print("Searching User ID...", ConsoleColor.Cyan);
				_localUserID = ((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID.m_userID;
				if (string.IsNullOrWhiteSpace(_localUserID))
				{
					_localUserID = "ERROR";
				}
				Utils.print("User ID found: " + _localUserID, ConsoleColor.Cyan);
			}
		}

		public class Container : ISerializableParameter
		{
			public string _blockedPrefabsServer = "";

			public string _blockedPlayerList = "";

			public int _itemMarketLimit;

			public int _marketTaxes;

			public bool _canTeleportWithOre;

			public bool _gamblerEnableNotifications;

			public bool _allowMultipleQuestScore;

			public int _maxAcceptedQuests;

			public bool _hideOtherQuestRequirementQuests;

			public bool _allowKillQuestsInParty;

			public bool _enableKGChat;

			public string _mailPostRecipe = "";

			public int _mailPostWaitTime;

			public string _mailPostExcludeItems = "";

			public string _pieceSaverRecipe = "";

			public bool _useLeaderboard;

			public string _vipPlayerList = "";

			public int _vipmarketTaxes;

			public string[] _possibleCurrencies;

			public HashSet<string> _overrideDebug = new HashSet<string>();

			public HashSet<string> _blockedChatUsers = new HashSet<string>();

			public bool _canLeaveGuild = true;

			public Vector2 _factionNameplateOffset = Vector2.zero;

			public void Serialize(ref ZPackage pkg)
			{
				//IL_01ed: 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)
				pkg.Write(_blockedPrefabsServer);
				pkg.Write(_blockedPlayerList);
				pkg.Write(_itemMarketLimit);
				pkg.Write(_marketTaxes);
				pkg.Write(_canTeleportWithOre);
				pkg.Write(_gamblerEnableNotifications);
				pkg.Write(_allowMultipleQuestScore);
				pkg.Write(_maxAcceptedQuests);
				pkg.Write(_hideOtherQuestRequirementQuests);
				pkg.Write(_allowKillQuestsInParty);
				pkg.Write(_enableKGChat);
				pkg.Write(_mailPostRecipe);
				pkg.Write(_mailPostWaitTime);
				pkg.Write(_mailPostExcludeItems);
				pkg.Write(_pieceSaverRecipe);
				pkg.Write(_useLeaderboard);
				pkg.Write(_overrideDebug.Count);
				foreach (string item in _overrideDebug)
				{
					pkg.Write(item);
				}
				pkg.Write(_blockedChatUsers.Count);
				foreach (string blockedChatUser in _blockedChatUsers)
				{
					pkg.Write(blockedChatUser);
				}
				pkg.Write(_vipmarketTaxes);
				pkg.Write(_vipPlayerList);
				if (_possibleCurrencies == null || _possibleCurrencies.Length == 0)
				{
					pkg.Write(1);
					pkg.Write("Coins");
				}
				else
				{
					pkg.Write(_possibleCurrencies.Length);
					string[] possibleCurrencies = _possibleCurrencies;
					foreach (string text in possibleCurrencies)
					{
						pkg.Write(text);
					}
				}
				pkg.Write(_canLeaveGuild);
				pkg.Write(Vector2.op_Implicit(_factionNameplateOffset));
			}

			public void Deserialize(ref ZPackage pkg)
			{
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				_blockedPrefabsServer = pkg.ReadString();
				_blockedPlayerList = pkg.ReadString();
				_itemMarketLimit = pkg.ReadInt();
				_marketTaxes = pkg.ReadInt();
				_canTeleportWithOre = pkg.ReadBool();
				_gamblerEnableNotifications = pkg.ReadBool();
				_allowMultipleQuestScore = pkg.ReadBool();
				_maxAcceptedQuests = pkg.ReadInt();
				_hideOtherQuestRequirementQuests = pkg.ReadBool();
				_allowKillQuestsInParty = pkg.ReadBool();
				_enableKGChat = pkg.ReadBool();
				_mailPostRecipe = pkg.ReadString();
				_mailPostWaitTime = pkg.ReadInt();
				_mailPostExcludeItems = pkg.ReadString();
				_pieceSaverRecipe = pkg.ReadString();
				_useLeaderboard = pkg.ReadBool();
				int num = pkg.ReadInt();
				_overrideDebug.Clear();
				for (int i = 0; i < num; i++)
				{
					_overrideDebug.Add(pkg.ReadString());
				}
				_blockedChatUsers.Clear();
				num = pkg.ReadInt();
				for (int j = 0; j < num; j++)
				{
					_blockedChatUsers.Add(pkg.ReadString());
				}
				_vipmarketTaxes = pkg.ReadInt();
				_vipPlayerList = pkg.ReadString();
				num = pkg.ReadInt();
				_possibleCurrencies = new string[num];
				for (int k = 0; k < num; k++)
				{
					_possibleCurrencies[k] = pkg.ReadString();
				}
				_canLeaveGuild = pkg.ReadBool();
				_factionNameplateOffset = Vector2.op_Implicit(pkg.ReadVector3());
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ServerOnlyPatch]
		private static class OBJECTPATCH
		{
			private static void Postfix()
			{
				if (!ZNet.instance.IsServer())
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>();
				string[] possibleCurrencies = SyncedGlobalOptions.Value._possibleCurrencies;
				foreach (string text in possibleCurrencies)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(text);
					if (prefab != null)
					{
						hashSet.Add(((Object)prefab).name);
					}
					else
					{
						Utils.print("Currency prefab not found: " + text, ConsoleColor.Red);
					}
				}
				SyncedGlobalOptions.Value._possibleCurrencies = hashSet.ToArray();
				SyncedGlobalOptions.Update();
			}
		}

		public static string _localUserID;

		internal static readonly CustomSyncedValue<Container> SyncedGlobalOptions;

		public static string WebHookLink;

		public static int BankerIncomeTime;

		public static float BankerIncomeMultiplier;

		public static bool EnableTraderLog;

		public static bool EnableTransmogLog;

		public static string BankerInterestItems;

		public static float BankerVIPIncomeMultiplier;

		public static string OrConditionSeparator;

		public static ConfigFile _config;

		static Global_Configs()
		{
			_localUserID = "NONE";
			SyncedGlobalOptions = new CustomSyncedValue<Container>(Marketplace.configSync, "Global_Values", new Container());
			WebHookLink = "webhook link";
			BankerInterestItems = "All";
			OrConditionSeparator = "||";
			_config = null;
			Guilds.API.RegisterOnGuildLeft(delegate(Guild g, Guilds.PlayerReference pr)
			{
				if (!SyncedGlobalOptions.Value._canLeaveGuild)
				{
					Guilds.API.AddPlayerToGuild(pr, g);
					Guilds.API.SaveGuild(g);
					MessageHud.instance.ShowMessage((MessageType)2, "$marketplace_cannotleaveguild", 0, (Sprite)null, false);
				}
			});
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_config = new ConfigFile(Market_Paths.MainConfig, true);
			ReadConfigValues();
		}

		[UsedImplicitly]
		private static void OnChange()
		{
			Utils.DelayReloadConfig(_config, ReadConfigValues);
			Utils.print("Main Configs Changed. Sending new info to all clients");
		}

		private static T SearchOption<T>(string option, T defaultValue, string description)
		{
			return _config.Bind<T>("Main", option, defaultValue, description).Value;
		}

		private static void ReadConfigValues()
		{
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			EnableTransmogLog = SearchOption("EnableTransmogLog", defaultValue: false, "Enable/Disable Transmog Log");
			EnableTraderLog = SearchOption("EnableTraderLog", defaultValue: false, "Enable/Disable Trader Log");
			BankerIncomeTime = SearchOption("BankerIncomeTime", 1, "Banker Income Time (hours)");
			BankerIncomeMultiplier = SearchOption("BankerIncomeMultiplier", 0f, "Banker Income Multiplier (per time)");
			WebHookLink = SearchOption("FeedbackWebhookLink", "webhook link", "Feedback Webhook Link");
			BankerInterestItems = SearchOption("BankerInterestItems", "All", "Banker Interest Items").Replace(" ", "");
			BankerVIPIncomeMultiplier = SearchOption("BankerVIPIncomeMultiplier", 0f, "VIP Banker Income Multiplier");
			OrConditionSeparator = SearchOption("OrConditionSeparator", "||", "Or Condition Separator In Dialogues");
			SyncedGlobalOptions.Value._itemMarketLimit = SearchOption("ItemMarketLimit", 15, "Limit amount of slots player can sell in marketpalce");
			SyncedGlobalOptions.Value._blockedPlayerList = SearchOption("BlockedPlayers", "User IDs", "Marketplace Blocked Players");
			SyncedGlobalOptions.Value._marketTaxes = SearchOption("MarketTaxes", 0, "Market Taxes From Each Sell");
			SyncedGlobalOptions.Value._marketTaxes = Mathf.Clamp(SyncedGlobalOptions.Value._marketTaxes, 0, 100);
			SyncedGlobalOptions.Value._canTeleportWithOre = SearchOption("CanTeleportWithOre", defaultValue: true, "Enable/Disable players teleporter with ore");
			SyncedGlobalOptions.Value._blockedPrefabsServer = SearchOption("MarketSellBlockedPrefabs", "Coins, SwordCheat", "Marketplace Blocked Prefabs For Selling");
			SyncedGlobalOptions.Value._gamblerEnableNotifications = SearchOption("GamblerEnableWinNotifications", defaultValue: false, "Enable Gambler Win Notification");
			SyncedGlobalOptions.Value._allowMultipleQuestScore = SearchOption("AllowMultipleQuestsScore", defaultValue: false, "Enable Kill / Harvest Craft Same Target Quests Get + Score In Same Time");
			SyncedGlobalOptions.Value._maxAcceptedQuests = SearchOption("MaxAcceptedQuests", 7, "Max Amount Of Accpeted Quests");
			SyncedGlobalOptions.Value._hideOtherQuestRequirementQuests = SearchOption("HideOtherQuestRequirementQuests", defaultValue: false, "Hide Quest in UI if they have OtherQuest as requirement");
			SyncedGlobalOptions.Value._allowKillQuestsInParty = SearchOption("AllowKillQuestsInParty", defaultValue: true, "Allow Kill Quests In Party");
			SyncedGlobalOptions.Value._enableKGChat = SearchOption("EnableKGChat", defaultValue: true, "Enable KGChat");
			SyncedGlobalOptions.Value._mailPostRecipe = SearchOption("MailPostRecipe", "SwordCheat,1", "Recipe for Mailpost creation");
			SyncedGlobalOptions.Value._mailPostWaitTime = SearchOption("MailPostWaitTime", 5, "Mailpost wait time (minutes)");
			SyncedGlobalOptions.Value._mailPostExcludeItems = SearchOption("MailPostExcludeItems", "Items Here", "Mailpost exclude items (with coma)");
			SyncedGlobalOptions.Value._pieceSaverRecipe = SearchOption("PieceSaverRecipe", "SwordCheat,1", "Recipe for Piece Saver Crystal creation");
			SyncedGlobalOptions.Value._useLeaderboard = SearchOption("UseLeaderboard", defaultValue: false, "Use Leaderboard");
			SyncedGlobalOptions.Value._overrideDebug = new HashSet<string>((from s in SearchOption("OverrideDebug", "Steam IDs here", "Admin Steam IDs").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				where long.TryParse(s, out var _)
				select s.Trim()).ToList());
			SyncedGlobalOptions.Value._blockedChatUsers = new HashSet<string>((from s in SearchOption("BlockedChatUsers", "Steam IDs here", "Blocked Chat Users").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				where long.TryParse(s, out var _)
				select s.Trim()).ToList());
			SyncedGlobalOptions.Value._vipmarketTaxes = SearchOption("VIPplayersTaxes", 0, "VIP Player Market Taxes");
			SyncedGlobalOptions.Value._vipmarketTaxes = Mathf.Clamp(SyncedGlobalOptions.Value._vipmarketTaxes, 0, 100);
			SyncedGlobalOptions.Value._vipPlayerList = SearchOption("VIPplayersList", "User IDs", "Marketplace VIP Players List ");
			SyncedGlobalOptions.Value._possibleCurrencies = (from s in SearchOption("PossibleCurrencies", "Coins", "Possible Currencies").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToArray();
			SyncedGlobalOptions.Value._canLeaveGuild = SearchOption("CanLeaveGuild", defaultValue: true, "Allow/Disallow players to leave guilds (Blaxxun Guilds Mod)");
			SyncedGlobalOptions.Value._factionNameplateOffset = SearchOption<Vector2>("FactionNameplateOffset", Vector2.zero, "Faction Nameplate Offset (X = Horizontal, Y = Vertical)");
			SyncedGlobalOptions.Update();
		}
	}
}
namespace Marketplace.Modules.Gambler
{
	public static class Gambler_DataTypes
	{
		public class BigData : ISerializableParameter
		{
			public Item RequiredItem = new Item();

			public List<Item> Data = new List<Item>();

			public int MAXROLLS;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(MAXROLLS);
				pkg.Write(Data.Count);
				foreach (Item datum in Data)
				{
					pkg.Write(datum.Prefab ?? "");
					pkg.Write(datum.Min);
					pkg.Write(datum.Max);
				}
				pkg.Write(RequiredItem.Prefab ?? "");
				pkg.Write(RequiredItem.Min);
				pkg.Write(RequiredItem.Max);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				MAXROLLS = pkg.ReadInt();
				int num = pkg.ReadInt();
				for (int i = 0; i < num; i++)
				{
					Data.Add(new Item
					{
						Prefab = pkg.ReadString(),
						Min = pkg.ReadInt(),
						Max = pkg.ReadInt()
					});
				}
				RequiredItem = new Item
				{
					Prefab = pkg.ReadString(),
					Min = pkg.ReadInt(),
					Max = pkg.ReadInt()
				};
			}
		}

		public class Item
		{
			public string Prefab;

			public int Min;

			public int Max;

			private Sprite icon;

			private string LocalizedName;

			private string rawName;

			public Sprite Sprite => icon;

			public string Name => LocalizedName;

			public string RawName => rawName;

			public void SetData(string RAWNAME, Sprite s)
			{
				rawName = RAWNAME;
				LocalizedName = Localization.instance.Localize(rawName);
				icon = s;
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, BigData>> SyncedGamblerData = new CustomSyncedValue<Dictionary<string, BigData>>(Marketplace.configSync, "gamblerData", new Dictionary<string, BigData>());
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Gambler_Main_Client
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		[HarmonyPriority(-10000)]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				GamblerInit();
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			Gambler_UI.Init();
			Gambler_DataTypes.SyncedGamblerData.ValueChanged += OnGamblerUpdate;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void OnGamblerUpdate()
		{
			GamblerInit();
			if (Gambler_UI.IsPanelVisible() && Gambler_UI.CurrentStatus == Gambler_UI.Status.Idle)
			{
				Gambler_UI.Reload();
			}
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Gambler_UI.IsPanelVisible())
			{
				Gambler_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		public static void GamblerInit()
		{
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			foreach (KeyValuePair<string, Gambler_DataTypes.BigData> item in Gambler_DataTypes.SyncedGamblerData.Value)
			{
				foreach (Gambler_DataTypes.Item datum in item.Value.Data)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(datum.Prefab);
					if (!Object.op_Implicit((Object)(object)prefab))
					{
						datum.SetData(datum.Prefab, AssetStorage.PlaceholderGamblerIcon);
						continue;
					}
					ItemDrop component = prefab.GetComponent<ItemDrop>();
					Sprite s = ((component != null) ? component.m_itemData.GetIcon() : null);
					string name = prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
					datum.SetData(name, s);
				}
				GameObject prefab2 = ZNetScene.instance.GetPrefab(item.Value.RequiredItem.Prefab);
				if (!Object.op_Implicit((Object)(object)prefab2))
				{
					item.Value.RequiredItem.SetData(item.Value.RequiredItem.Prefab, AssetStorage.PlaceholderGamblerIcon);
					continue;
				}
				ItemDrop component2 = prefab2.GetComponent<ItemDrop>();
				Sprite s2 = ((component2 != null) ? component2.m_itemData.GetIcon() : null);
				string name2 = prefab2.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				item.Value.RequiredItem.SetData(name2, s2);
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "GP" }, new string[] { "OnGamblerProfilesFileChange" })]
	public static class Gambler_Main_Server
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			ReadGamblerProfiles();
		}

		[UsedImplicitly]
		private static void OnGamblerProfilesFileChange()
		{
			ReadGamblerProfiles();
			Utils.print("Gambler Changed. Sending new info to all clients");
		}

		private static void ReadGamblerProfiles()
		{
			Gambler_DataTypes.SyncedGamblerData.Value.Clear();
			string gamblerProfilesFolder = Market_Paths.GamblerProfilesFolder;
			string[] files = Directory.GetFiles(gamblerProfilesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ReadGamblerProfiles(text, profiles);
			}
			ClientClearData();
			Gambler_DataTypes.SyncedGamblerData.Update();
		}

		private static void ClientClearData()
		{
			foreach (KeyValuePair<string, Gambler_DataTypes.BigData> item in Gambler_DataTypes.SyncedGamblerData.Value)
			{
				if (item.Value.Data.Count() > 19)
				{
					item.Value.Data.RemoveRange(19, item.Value.Data.Count() - 19);
				}
			}
		}

		private static void ReadGamblerProfiles(string fPath, IReadOnlyList<string> profiles)
		{
			string text = "default";
			int mAXROLLS = 1;
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					text = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					string[] array = text.Split(new char[1] { '=' });
					if (array.Length > 1)
					{
						text = array[0];
						mAXROLLS = int.Parse(array[1]);
					}
					else
					{
						mAXROLLS = 1;
					}
					continue;
				}
				string[] array2 = profiles[i].Replace(" ", "").Split(new char[1] { ',' });
				if (array2.Length % 2 != 0)
				{
					Utils.print($"Gambler {fPath} line {i + 1} has error, number of data is wrong", ConsoleColor.Red);
					continue;
				}
				List<Gambler_DataTypes.Item> list = new List<Gambler_DataTypes.Item>();
				for (int j = 0; j < array2.Length; j += 2)
				{
					Gambler_DataTypes.Item item = new Gambler_DataTypes.Item
					{
						Prefab = array2[j]
					};
					string[] array3 = array2[j + 1].Split(new char[1] { '-' });
					if (array3.Length == 1)
					{
						item.Min = int.Parse(array3[0]);
						item.Max = item.Min;
					}
					else
					{
						item.Min = int.Parse(array3[0]);
						item.Max = int.Parse(array3[1]);
					}
					list.Add(item);
				}
				Gambler_DataTypes.Item requiredItem = list[0];
				list.RemoveAt(0);
				Gambler_DataTypes.SyncedGamblerData.Value[text] = new Gambler_DataTypes.BigData
				{
					MAXROLLS = mAXROLLS,
					Data = list,
					RequiredItem = requiredItem
				};
			}
		}
	}
	public static class Gambler_UI
	{
		public enum Status
		{
			Idle,
			Shuffling,
			Done,
			Revealed
		}

		private class OnHoverGambler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
		{
			[CompilerGenerated]
			private sealed class <AddRemoveAlpha>d__5 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				public OnHoverGambler <>4__this;

				public bool add;

				private float <dt>5__2;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_010e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0095: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					OnHoverGambler onHoverGambler = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<dt>5__2 = ((Graphic)onHoverGambler.img).color.a;
						if (add)
						{
							goto IL_00b6;
						}
						goto IL_012f;
					case 1:
						<>1__state = -1;
						goto IL_00b6;
					case 2:
						{
							<>1__state = -1;
							goto IL_012f;
						}
						IL_00b6:
						if (<dt>5__2 < 0.3f)
						{
							<dt>5__2 += Time.deltaTime / 2f;
							<dt>5__2 = Mathf.Min(<dt>5__2, 0.3f);
							((Graphic)onHoverGambler.img).color = new Color(0.4464217f, 0.8f, 0.1179245f, <dt>5__2);
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
						break;
						IL_012f:
						if (<dt>5__2 > 0f)
						{
							<dt>5__2 -= Time.deltaTime / 2f;
							<dt>5__2 = Mathf.Max(<dt>5__2, 0f);
							((Graphic)onHoverGambler.img).color = new Color(0.4464217f, 0.8f, 0.1179245f, <dt>5__2);
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						break;
					}
					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();
				}
			}

			private Transform t;

			private Image img;

			private void Start()
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				t = ((Component)this).transform.Find("Choose");
				img = ((Component)t).GetComponent<Image>();
				((Component)t).gameObject.SetActive(true);
				((Graphic)img).color = new Color(1f, 1f, 1f, 0f);
			}

			public void OnPointerEnter(PointerEventData eventData)
			{
				((MonoBehaviour)this).StopAllCoroutines();
				if (CurrentStatus == Status.Done)
				{
					((MonoBehaviour)this).StartCoroutine(AddRemoveAlpha(add: true));
				}
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				((MonoBehaviour)this).StopAllCoroutines();
				((MonoBehaviour)this).StartCoroutine(AddRemoveAlpha(add: false));
			}

			[IteratorStateMachine(typeof(<AddRemoveAlpha>d__5))]
			private IEnumerator AddRemoveAlpha(bool add)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <AddRemoveAlpha>d__5(0)
				{
					<>4__this = this,
					add = add
				};
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class INPUTPATCHforGambler
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsPanelVisible())
				{
					__result = true;
				}
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__StartShuffle;

			public static Action<GameObject> <1>__Destroy;
		}

		[CompilerGenerated]
		private sealed class <CannonBall>d__42 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Transform t;

			public int index;

			public Vector3 targetPos;

			public float mod;

			private Vector3 <initialScale>5__2;

			private Vector3 <newScale>5__3;

			private Vector3 <startPos>5__4;

			private float <count>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: 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_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: 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_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<initialScale>5__2 = t.localScale;
					<newScale>5__3 = <initialScale>5__2;
					Shuffling[index] = true;
					<startPos>5__4 = t.position;
					<count>5__5 = 0f;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (<count>5__5 <= 1f)
				{
					float num = Time.deltaTime * 5f;
					<count>5__5 += num;
					if (<count>5__5 <= 0.5f)
					{
						<newScale>5__3 -= new Vector3(num, num, num);
					}
					else
					{
						<newScale>5__3 += new Vector3(num, num, num);
					}
					<newScale>5__3 = Vector3.Min(<initialScale>5__2, <newScale>5__3);
					t.localScale = <newScale>5__3;
					Vector3 val = <startPos>5__4 + (targetPos - <startPos>5__4) / 2f + Vector3.up * mod;
					Vector3 val2 = Vector3.Lerp(<startPos>5__4, val, <count>5__5);
					Vector3 val3 = Vector3.Lerp(val, targetPos, <count>5__5);
					t.position = Vector3.Lerp(val2, val3, <count>5__5);
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				t.localScale = <initialScale>5__2;
				t.position = targetPos;
				Shuffling[index] = false;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <ClickOnElement>d__36 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int whichOne;

			private bool <CONTINUE>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Expected O, but got Unknown
				//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ab: Expected O, but got Unknown
				//IL_0316: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (CurrentStatus != Status.Done || CurrentRollMAX <= 0 || AlreadyClicked.Contains(whichOne) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
					{
						return false;
					}
					AlreadyClicked.Add(whichOne);
					CurrentRollMAX--;
					<CONTINUE>5__2 = CurrentRollMAX <= 0;
					Object.Instantiate<GameObject>(ClickEffect, ((Component)Elements[whichOne]).transform);
					PlaySound(SOUNDEFFECT3, 1f);
					<>2__current = (object)new WaitForSecondsRealtime(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					PlaySound(SOUNDEFFECT2, 1f);
					Object.Instantiate<GameObject>(SmokeEffect, ((Component)Elements[whichOne]).transform);
					CurrentCircleEffects.Add(Object.Instantiate<GameObject>(CircleEffect, ((Component)Elements[whichOne]).transform));
					<>2__current = (object)new WaitForSecondsRealtime(0.8f);
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					((Component)((Component)Elements[whichOne]).transform.GetChild(2)).GetComponent<Image>().sprite = tempDictionary[Elements[whichOne]].Sprite;
					int num2 = Random.Range(tempDictionary[Elements[whichOne]].Min, tempDictionary[Elements[whichOne]].Max + 1);
					InstantiateItem(ZNetScene.instance.GetPrefab(tempDictionary[Elements[whichOne]].Prefab), num2);
					if (!Description.text.Contains("You Won"))
					{
						Description.text = $"<size=30>You Won:</size>\n<size=20><color=#00ff00>{tempDictionary[Elements[whichOne]].Name} x{num2}</color></size>";
					}
					else
					{
						Text description = Description;
						description.text += $"<size=20> , <color=#00ff00>{tempDictionary[Elements[whichOne]].Name} x{num2}</color></size>";
					}
					if (!<CONTINUE>5__2)
					{
						return false;
					}
					CurrentStatus = Status.Revealed;
					int num = 0;
					PlaySound(SOUNDEFFECT2, 1f);
					foreach (Transform element in Elements)
					{
						if (!AlreadyClicked.Contains(num))
						{
							Object.Instantiate<GameObject>(SmokeEffect, ((Component)element).transform);
						}
						num++;
					}
					<>2__current = (object)new WaitForSecondsRealtime(0.8f);
					<>1__state = 3;
					return true;
				}
				case 3:
				{
					<>1__state = -1;
					int num = 0;
					foreach (Transform element2 in Elements)
					{
						if (!AlreadyClicked.Contains(num))
						{
							((Component)((Component)element2).transform.GetChild(2)).GetComponent<Image>().sprite = tempDictionary[element2].Sprite;
						}
						num++;
					}
					<>2__current = (object)new WaitForSecondsRealtime(1f);
					<>1__state = 4;
					return true;
				}
				case 4:
					<>1__state = -1;
					CurrentStatus = Status.Idle;
					((Component)Button).gameObject.SetActive(true);
					((Component)RequiredTab).gameObject.SetActive(true);
					RollString();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <ShuffleMaster>d__39 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float time;

			private float <dt>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Expected O, but got Unknown
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Expected O, but got Unknown
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Expected O, but got Unknown
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<dt>5__2 = 0f;
					goto IL_00e3;
				case 1:
					<>1__state = -1;
					goto IL_00e3;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					Shuffle();
					goto IL_0172;
				case 5:
					{
						<>1__state = -1;
						goto IL_0189;
					}
					IL_00e3:
					if (<dt>5__2 < 2f)
					{
						<dt>5__2 += Time.deltaTime;
						<dt>5__2 = Mathf.Min(2f, <dt>5__2);
						foreach (Image item in ElementsAlpha)
						{
							((Graphic)item).color = new Color(((Graphic)item).color.r, ((Graphic)item).color.g, ((Graphic)item).color.b, <dt>5__2 / 2f);
						}
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<dt>5__2 = 0f;
					goto IL_0189;
					IL_0172:
					<>2__current = null;
					<>1__state = 5;
					return true;
					IL_0189:
					if (<dt>5__2 <= time)
					{
						<dt>5__2 += Time.deltaTime;
						if (!IsShuffling())
						{
							<>2__current = (object)new WaitForFixedUpdate();
							<>1__state = 2;
							return true;
						}
						goto IL_0172;
					}
					((Component)Description).gameObject.SetActive(true);
					CurrentStatus = Status.Done;
					Description.text = "\n<color=#00ff00>Choose Reward</color>";
					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();
			}
		}

		private static GameObject UI = null;

		private static Transform MainTransform = null;

		private static string CurrentProfile = "";

		private static readonly List<Transform> Elements = new List<Transform>();

		private static readonly HashSet<int> Exclude = new HashSet<int>();

		private static readonly Dictionary<Transform, Gambler_DataTypes.Item> tempDictionary = new Dictionary<Transform, Gambler_DataTypes.Item>();

		private static Transform Button = null;

		private static List<int> currentShuffle = new List<int>();

		private static readonly bool[] Shuffling = new bool[2];

		private static readonly List<Image> ElementsAlpha = new List<Image>();

		private static readonly List<Transform> ALLELEMENTS = new List<Transform>();

		private static readonly List<Image> ALLIMAGES = new List<Image>();

		public static Status CurrentStatus;

		private static readonly List<GameObject> CurrentCircleEffects = new List<GameObject>();

		private static Text Description = null;

		private static Text NeededItemText = null;

		private static Transform RequiredTab = null;

		private static int CurrentRollMAX = 1;

		private static readonly HashSet<int> AlreadyClicked = new HashSet<int>();

		private static bool DisableSound;

		private static readonly List<Vector3> InitialPositions = new List<Vector3>();

		private static GameObject ClickEffect = null;

		private static GameObject SmokeEffect = null;

		private static Sprite QuestionMarkIcon = null;

		private static GameObject CircleEffect = null;

		private static AudioClip SOUNDEFFECT = null;

		private static AudioClip SOUNDEFFECT2 = null;

		public static AudioClip SOUNDEFFECT3 = null;

		public static void Reload()
		{
			Hide();
			Show(CurrentProfile);
		}

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		private static void PlaySound(AudioClip clip, float volume)
		{
			if (!DisableSound)
			{
				AssetStorage.AUsrc.PlayOneShot(clip, volume);
			}
		}

		public static void Init()
		{
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_0224: 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 (Object.op_Implicit((Object)(object)UI))
			{
				Object.Destroy((Object)(object)UI);
			}
			DisableSound = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("General", "Mute Gambler Sounds", false, (ConfigDescription)null).Value;
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceGamblerNewUI"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			ClickEffect = AssetStorage.asset.LoadAsset<GameObject>("RINGEFFECT");
			CircleEffect = AssetStorage.asset.LoadAsset<GameObject>("CircleEffect");
			SmokeEffect = AssetStorage.asset.LoadAsset<GameObject>("SMOKEEFFECT");
			SOUNDEFFECT = AssetStorage.asset.LoadAsset<AudioClip>("GAMBLERSOUND2");
			SOUNDEFFECT2 = AssetStorage.asset.LoadAsset<AudioClip>("BURSTGAMBLE");
			SOUNDEFFECT3 = AssetStorage.asset.LoadAsset<AudioClip>("GAMBLERDONE");
			QuestionMarkIcon = AssetStorage.asset.LoadAsset<Sprite>("qCS 2");
			CurrentStatus = Status.Idle;
			Shuffling[0] = false;
			Shuffling[1] = false;
			ALLELEMENTS.Clear();
			InitialPositions.Clear();
			ALLIMAGES.Clear();
			MainTransform = UI.transform.Find("Canvas/GambleElements");
			Transform parent = MainTransform.parent;
			Button = parent.Find("Start");
			ButtonClickedEvent onClick = ((Component)Button).GetComponent<Button>().onClick;
			object obj = <>O.<0>__StartShuffle;
			if (obj == null)
			{
				UnityAction val = StartShuffle;
				<>O.<0>__StartShuffle = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Description = ((Component)parent.Find("Description")).GetComponent<Text>();
			NeededItemText = ((Component)parent.Find("Required/Text")).GetComponent<Text>();
			RequiredTab = parent.Find("Required");
			int num = 0;
			for (int i = 0; i < 18; i++)
			{
				int deleg = num;
				Transform child = MainTransform.GetChild(i);
				((UnityEvent)((Component)child).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					((MonoBehaviour)Marketplace._thistype).StartCoroutine(ClickOnElement(deleg));
				});
				num++;
				((Component)child).gameObject.AddComponent<OnHoverGambler>();
				ALLELEMENTS.Add(child);
				InitialPositions.Add(Vector2.op_Implicit(((Component)child).GetComponent<RectTransform>().anchoredPosition));
				Image[] componentsInChildren = ((Component)MainTransform.GetChild(i)).GetComponentsInChildren<Image>();
				foreach (Image item in componentsInChildren)
				{
					ALLIMAGES.Add(item);
				}
			}
			UI.SetActive(false);
			Localization.instance.Localize(UI.transform);
		}

		private static void ResetDefault()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			Shuffling[0] = false;
			Shuffling[1] = false;
			int num = 0;
			foreach (Transform aLLELEMENT in ALLELEMENTS)
			{
				((Component)aLLELEMENT).gameObject.SetActive(false);
				((Component)aLLELEMENT).GetComponent<RectTransform>().anchoredPosition = Vector2.op_Implicit(InitialPositions[num]);
				num++;
			}
			AlreadyClicked.Clear();
			CurrentRollMAX = 1;
			foreach (Image aLLIMAGE in ALLIMAGES)
			{
				((Graphic)aLLIMAGE).color = ((Graphic)aLLIMAGE).color * new Color(1f, 1f, 1f, 0f);
			}
			CurrentCircleEffects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentCircleEffects.Clear();
			CurrentStatus = Status.Idle;
			((Component)Description).gameObject.SetActive(true);
			((Component)Button).gameObject.SetActive(true);
			((Component)RequiredTab).gameObject.SetActive(true);
			Elements.Clear();
			ElementsAlpha.Clear();
			for (int i = 0; i < Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].Data.Count(); i++)
			{
				Transform child = MainTransform.GetChild(i);
				((Component)child).gameObject.SetActive(true);
				Elements.Add(child);
				ElementsAlpha.AddRange(from img in ((Component)child).GetComponentsInChildren<Image>()
					where ((Object)((Component)img).transform).name != "Choose"
					select img);
				((Component)child.GetChild(2)).GetComponent<Image>().sprite = QuestionMarkIcon;
			}
			currentShuffle = Enumerable.Range(0, Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].Data.Count()).ToList();
			Exclude.Clear();
			string text = "<size=60>" + Localization.instance.Localize("$mpasn_gambleryouhaveachance") + ":</size><size=20>\n";
			foreach (Gambler_DataTypes.Item datum in Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].Data)
			{
				text = ((datum.Min != datum.Max) ? (text + datum.Name + $" <color=#00ff00>x{datum.Min}-{datum.Max}</color>\n") : (text + datum.Name + $" <color=#00ff00>x{datum.Min}</color>\n"));
			}
			Description.text = text + "</size>";
		}

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

		private static void InstantiateItem(GameObject main, int count)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: 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)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || (Object)(object)main == (Object)null)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)main.GetComponent<ItemDrop>()))
			{
				Transform transform = ((Component)localPlayer).transform;
				GameObject val = Object.Instantiate<GameObject>(main, transform.position + transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
				ItemDrop component = val.GetComponent<ItemDrop>();
				component.m_itemData.m_stack = count;
				component.m_itemData.m_durability = component.m_itemData.GetMaxDurability(1);
				component.Save();
				if (((Humanoid)localPlayer).m_inventory.CanAddItem(val, -1))
				{
					((Humanoid)localPlayer).m_inventory.AddItem(component.m_itemData);
					ZNetScene.instance.Destroy(val);
				}
				if (ZNet.instance.GetServerPeer() != null)
				{
					ZPackage val2 = new ZPackage();
					val2.Write(1);
					val2.Write(Player.m_localPlayer.GetPlayerName());
					val2.Write(count);
					val2.Write(component.m_itemData.m_shared.m_name);
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "KGmarket CustomWebhooks", new object[1] { val2 });
				}
				if (Global_Configs.SyncedGlobalOptions.Value._gamblerEnableNotifications)
				{
					string text = $"{Player.m_localPlayer.GetPlayerName()} just won {Localization.instance.Localize(component.m_itemData.m_shared.m_name)} x{count}";
					UserInfo localUser = UserInfo.GetLocalUser();
					localUser.Name = "<color=#FF00FF>[GAMBLER]</color>";
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ChatMessage", new object[5]
					{
						((Character)Player.m_localPlayer).GetHeadPoint(),
						2,
						localUser,
						text,
						"Steam_0"
					});
				}
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)main.GetComponent<Character>()))
				{
					return;
				}
				for (int i = 0; i < count; i++)
				{
					Transform transform2 = ((Component)localPlayer).transform;
					GameObject val3 = Object.Instantiate<GameObject>(main, transform2.position + transform2.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					if (Object.op_Implicit((Object)(object)val3.GetComponent<Tameable>()))
					{
						val3.GetComponent<Tameable>().Tame();
					}
				}
			}
		}

		private static void StartShuffle()
		{
			AssetStorage.AUsrc.Play();
			if (CurrentStatus != 0 || !CanRoll() || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			ResetDefault();
			CurrentRollMAX = Mathf.Max(1, Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].MAXROLLS);
			CurrentRollMAX = Mathf.Min(Elements.Count, CurrentRollMAX);
			((Humanoid)Player.m_localPlayer).m_inventory.RemoveItem(Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.RawName, Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.Min, -1, true);
			tempDictionary.Clear();
			List<int> source = Enumerable.Range(0, Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].Data.Count()).ToList();
			HashSet<int> tempExclude = new HashSet<int>();
			foreach (Transform element in Elements)
			{
				int index = Random.Range(0, source.Count());
				int num = source.ElementAt(index);
				tempDictionary[element] = Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].Data[num];
				tempExclude.Add(num);
				source = source.Where((int val) => !tempExclude.Contains(val)).ToList();
			}
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(ShuffleMaster(5f));
			((Component)Button).gameObject.SetActive(false);
			((Component)RequiredTab).gameObject.SetActive(false);
			((Component)Description).gameObject.SetActive(false);
			CurrentStatus = Status.Shuffling;
		}

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

		private static bool IsShuffling()
		{
			if (!Shuffling[0])
			{
				return Shuffling[1];
			}
			return true;
		}

		private static void Shuffle()
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			if (currentShuffle.Count() <= 1)
			{
				currentShuffle = Enumerable.Range(0, Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].Data.Count()).ToList();
				Exclude.Clear();
			}
			int index = Random.Range(0, currentShuffle.Count());
			Transform val = Elements[currentShuffle.ElementAt(index)];
			Exclude.Add(currentShuffle.ElementAt(index));
			currentShuffle = currentShuffle.Where((int value) => !Exclude.Contains(value)).ToList();
			int index2 = Random.Range(0, currentShuffle.Count());
			Transform val2 = Elements[currentShuffle.ElementAt(index2)];
			Exclude.Add(currentShuffle.ElementAt(index2));
			currentShuffle = currentShuffle.Where((int value) => !Exclude.Contains(value)).ToList();
			if (Random.value > 0.5f)
			{
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(CannonBall(val, val2.position, 350f, 0));
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(CannonBall(val2, val.position, -350f, 1));
				PlaySound(SOUNDEFFECT, 0.4f);
			}
			else
			{
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(CannonBall(val, val2.position, -350f, 0));
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(CannonBall(val2, val.position, 350f, 1));
				PlaySound(SOUNDEFFECT, 0.4f);
			}
		}

		[IteratorStateMachine(typeof(<CannonBall>d__42))]
		private static IEnumerator CannonBall(Transform t, Vector3 targetPos, float mod, int index)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CannonBall>d__42(0)
			{
				t = t,
				targetPos = targetPos,
				mod = mod,
				index = index
			};
		}

		private static bool CanRoll()
		{
			return ((Humanoid)Player.m_localPlayer).m_inventory.CountItems(Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.RawName, -1, true) >= Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.Min;
		}

		private static void RollString()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			int num = ((Humanoid)Player.m_localPlayer).m_inventory.CountItems(Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.RawName, -1, true);
			int min = Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.Min;
			NeededItemText.text = num + " / " + min;
			((Component)((Component)NeededItemText).transform.parent.Find("Image")).GetComponent<Image>().sprite = Gambler_DataTypes.SyncedGamblerData.Value[CurrentProfile].RequiredItem.Sprite;
			((Graphic)((Component)((Component)NeededItemText).transform.parent.Find("Background")).GetComponent<Image>()).color = ((num >= min) ? Color.green : Color.red);
			((Graphic)NeededItemText).color = ((num >= min) ? Color.green : Color.red);
		}

		public static void Hide()
		{
			UI.SetActive(false);
		}

		public static void Show(string profile)
		{
			if (Gambler_DataTypes.SyncedGamblerData.Value.ContainsKey(profile) && Gambler_DataTypes.SyncedGamblerData.Value[profile].Data.Count >= 2)
			{
				CurrentProfile = profile;
				if (CurrentStatus == Status.Idle)
				{
					ResetDefault();
				}
				RollString();
				((Component)UI.transform.Find("Canvas/Header/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_itemsperroll") + ":\n<color=#00ff00>" + Gambler_DataTypes.SyncedGamblerData.Value[profile].MAXROLLS + "</color>";
				UI.SetActive(true);
			}
		}
	}
}
namespace Marketplace.Modules.Feedback
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Feedback_Main_Client
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			Feedback_UI.Init();
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Feedback_UI.IsPanelVisible())
			{
				Feedback_UI.Hide();
				Menu.instance.OnClose();
			}
		}
	}
	public static class Feedback_Main_Server
	{
		[MarketplaceRPC("KGmarket ReceiveFeedback", Market_Autoload.Type.Server)]
		private static void ReceiveFeedback(long sender, ZPackage pkg)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string PlayerInfo = pkg.ReadString() + " (" + peer.m_socket.GetHostName() + ")";
				Utils.print("Got feedback from " + PlayerInfo);
				string Subject = pkg.ReadString();
				string Message = pkg.ReadString();
				Task.Run(delegate
				{
					string message = "{\"username\":\"FeedbackNPC\",\"embeds\":[{\"author\":{\"name\":\"Player: " + PlayerInfo + "\"},\"title\":\"Subject\",\"description\":\"" + Subject + "\",\"color\":15258703,\"fields\":[{\"name\":\"Message\",\"value\":\"" + Message + "\",\"inline\":true}]}]}";
					SendMSG(Global_Configs.WebHookLink, message);
				});
			}
		}

		private static void SendMSG(string link, string message)
		{
			if (Uri.TryCreate(link, UriKind.Absolute, out Uri result) && (result.Scheme == Uri.UriSchemeHttp || result.Scheme == Uri.UriSchemeHttps))
			{
				HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(link);
				httpWebRequest.ContentType = "application/json";
				httpWebRequest.Method = "POST";
				using (StreamWriter streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
				{
					streamWriter.Write(message);
				}
				httpWebRequest.GetResponseAsync();
			}
		}
	}
	public static class Feedback_UI
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class INPUTPATCHforFeedback
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsPanelVisible())
				{
					__result = true;
				}
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction<string> <0>__PlayTypeSound;

			public static UnityAction <1>__CancelClick;

			public static UnityAction <2>__SendClick;
		}

		private static GameObject UI;

		private static InputField Subject;

		private static InputField MSG;

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketFeedback"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			Subject = ((Component)UI.transform.Find("UI/panel/Subject")).GetComponent<InputField>();
			MSG = ((Component)UI.transform.Find("UI/panel/Text")).GetComponent<InputField>();
			((UnityEvent<string>)(object)MSG.onValueChanged).AddListener((UnityAction<string>)PlayTypeSound);
			((UnityEvent<string>)(object)Subject.onValueChanged).AddListener((UnityAction<string>)PlayTypeSound);
			ButtonClickedEvent onClick = ((Component)UI.transform.Find("UI/panel/Back")).GetComponent<Button>().onClick;
			object obj = <>O.<1>__CancelClick;
			if (obj == null)
			{
				UnityAction val = CancelClick;
				<>O.<1>__CancelClick = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("UI/panel/Send")).GetComponent<Button>().onClick;
			object obj2 = <>O.<2>__SendClick;
			if (obj2 == null)
			{
				UnityAction val2 = SendClick;
				<>O.<2>__SendClick = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			UI.SetActive(false);
		}

		private static void PlayTypeSound(string arg0)
		{
			AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
		}

		private static void SendClick()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			AssetStorage.AUsrc.Play();
			if (!string.IsNullOrWhiteSpace(MSG.text))
			{
				Player localPlayer = Player.m_localPlayer;
				string text = ((localPlayer != null) ? localPlayer.GetPlayerName() : null);
				ZPackage val = new ZPackage();
				val.Write(text);
				val.Write(Subject.text);
				val.Write(MSG.text);
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket ReceiveFeedback", new object[1] { val });
				Hide();
			}
		}

		private static void CancelClick()
		{
			AssetStorage.AUsrc.Play();
			Hide();
		}

		public static void Hide()
		{
			UI.SetActive(false);
		}

		public static void Show()
		{
			Subject.text = "";
			MSG.text = "";
			UI.SetActive(true);
		}
	}
}
namespace Marketplace.Modules.DistancedUI
{
	public static class DistancedUI_DataType
	{
		public class DistancedUIData : ISerializableParameter
		{
			public bool Enabled;

			public bool MarketplaceEnabled;

			public bool MailEnabled;

			public bool CanTakeMailAttachments;

			public List<string> TraderProfiles = new List<string>();

			public List<string> TeleporterProfiles = new List<string>();

			public List<string> GamblerProfiles = new List<string>();

			public List<string> BufferProfiles = new List<string>();

			public List<string> QuestProfiles = new List<string>();

			public List<string> InfoProfiles = new List<string>();

			public List<string> BankerProfiles = new List<string>();

			public List<string> TransmogrificationProfiles = new List<string>();

			public List<string> DialogueProfiles = new List<string>();

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(Enabled);
				pkg.Write(MarketplaceEnabled);
				pkg.Write(MailEnabled);
				pkg.Write(CanTakeMailAttachments);
				pkg.Write(TraderProfiles.Count);
				foreach (string traderProfile in TraderProfiles)
				{
					pkg.Write(traderProfile ?? "");
				}
				pkg.Write(TeleporterProfiles.Count);
				foreach (string teleporterProfile in TeleporterProfiles)
				{
					pkg.Write(teleporterProfile ?? "");
				}
				pkg.Write(GamblerProfiles.Count);
				foreach (string gamblerProfile in GamblerProfiles)
				{
					pkg.Write(gamblerProfile ?? "");
				}
				pkg.Write(BufferProfiles.Count);
				foreach (string bufferProfile in BufferProfiles)
				{
					pkg.Write(bufferProfile ?? "");
				}
				pkg.Write(QuestProfiles.Count);
				foreach (string questProfile in QuestProfiles)
				{
					pkg.Write(questProfile ?? "");
				}
				pkg.Write(InfoProfiles.Count);
				foreach (string infoProfile in InfoProfiles)
				{
					pkg.Write(infoProfile ?? "");
				}
				pkg.Write(BankerProfiles.Count);
				foreach (string bankerProfile in BankerProfiles)
				{
					pkg.Write(bankerProfile ?? "");
				}
				pkg.Write(TransmogrificationProfiles.Count);
				foreach (string transmogrificationProfile in TransmogrificationProfiles)
				{
					pkg.Write(transmogrificationProfile ?? "");
				}
				pkg.Write(DialogueProfiles.Count);
				foreach (string dialogueProfile in DialogueProfiles)
				{
					pkg.Write(dialogueProfile ?? "");
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Enabled = pkg.ReadBool();
				MarketplaceEnabled = pkg.ReadBool();
				MailEnabled = pkg.ReadBool();
				CanTakeMailAttachments = pkg.ReadBool();
				int num = pkg.ReadInt();
				for (int i = 0; i < num; i++)
				{
					TraderProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int j = 0; j < num; j++)
				{
					TeleporterProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int k = 0; k < num; k++)
				{
					GamblerProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int l = 0; l < num; l++)
				{
					BufferProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int m = 0; m < num; m++)
				{
					QuestProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int n = 0; n < num; n++)
				{
					InfoProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int num2 = 0; num2 < num; num2++)
				{
					BankerProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int num3 = 0; num3 < num; num3++)
				{
					TransmogrificationProfiles.Add(pkg.ReadString());
				}
				num = pkg.ReadInt();
				for (int num4 = 0; num4 < num; num4++)
				{
					DialogueProfiles.Add(pkg.ReadString());
				}
			}
		}

		internal static readonly CustomSyncedValue<DistancedUIData> SyncedDistancedUIData = new CustomSyncedValue<DistancedUIData>(Marketplace.configSync, "distancedUIData", new DistancedUIData());
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class DistancedUI_Main_Client
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				OnDistancedUIUpdate();
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			DistancedUI_UI.Init();
			DistancedUI_DataType.SyncedDistancedUIData.ValueChanged += OnDistancedUIUpdate;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void OnDistancedUIUpdate()
		{
			if (DistancedUI_DataType.SyncedDistancedUIData.Value.Enabled)
			{
				DistancedUI_UI.Show(DistancedUI_DataType.SyncedDistancedUIData.Value.MarketplaceEnabled, DistancedUI_DataType.SyncedDistancedUIData.Value.MailEnabled);
			}
			else
			{
				DistancedUI_UI.Hide();
			}
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && DistancedUI_UI.IsViewProfilesVisible())
			{
				DistancedUI_UI.HideViewProfiles();
				Menu.instance.OnClose();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Input.GetKey((KeyCode)308) && Input.GetKeyDown((KeyCode)96))
			{
				DistancedUI_UI.ClickView();
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "DistancedUI.cfg" }, new string[] { "OnConfigChange" })]
	public static class DistanceUI_Main_Server
	{
		private static ConfigFile DistancedUI_Config;

		private static ConfigEntry<bool> CanUseMarketplace_DistancedUI;

		private static ConfigEntry<bool> CanUseMail_DistancedUI;

		private static ConfigEntry<bool> CanTakeMailAttachments_DistancedUI;

		private static ConfigEntry<bool> Enabled;

		private static ConfigEntry<string> TraderProfiles_DistancedUI;

		private static ConfigEntry<string> BankerProfiles_DistancedUI;

		private static ConfigEntry<string> TeleporterProfiles_DistancedUI;

		private static ConfigEntry<string> GamblerProfiles_DistancedUI;

		private static ConfigEntry<string> BufferProfiles_DistancedUI;

		private static ConfigEntry<string> QuestProfiles_DistancedUI;

		private static ConfigEntry<string> InfoProfiles_DistancedUI;

		private static ConfigEntry<string> TransmogrificationProfiles_DistancedUI;

		private static ConfigEntry<string> Dialogues_DistancedUI;

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			DistancedUI_Config = new ConfigFile(Market_Paths.DistancedUIConfig, true);
			Enabled = DistancedUI_Config.Bind<bool>("DistancedUI", "Enabled", false, "Enable or disable dystem");
			CanUseMarketplace_DistancedUI = DistancedUI_Config.Bind<bool>("DistancedUI", "CanUseMarketplace", true, "Can use the marketplace?");
			CanUseMail_DistancedUI = DistancedUI_Config.Bind<bool>("DistancedUI", "CanUseMail", true, "Can use the mail system?");
			CanTakeMailAttachments_DistancedUI = DistancedUI_Config.Bind<bool>("DistancedUI", "CanTakeMailAttachments", false, "Can take mail attachments?");
			TraderProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "TraderProfiles", "Profiles here with ,", "Trader profiles");
			TeleporterProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "TeleporterProfiles", "Profiles here with ,", "Teleporter profiles");
			GamblerProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "GamblerProfiles", "Profiles here with ,", "Gambler profiles");
			BufferProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "BufferProfiles", "Profiles here with ,", "Buffer profiles");
			BankerProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "BankerProfiles", "Profiles here with ,", "Banker profiles");
			QuestProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "QuestProfiles", "Profiles here with ,", "Quest profiles");
			InfoProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "InfoProfiles", "Profiles here with ,", "Info profiles");
			TransmogrificationProfiles_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "TransmogrificationProfiles", "Profiles here with ,", "Transmogrification profiles");
			Dialogues_DistancedUI = DistancedUI_Config.Bind<string>("DistancedUI", "Dialogues", "Profiles here with ,", "Dialogues profiles");
			ReadDistancedUIData();
		}

		private static void ReadDistancedUIData()
		{
			DistancedUI_DataType.SyncedDistancedUIData.Value = new DistancedUI_DataType.DistancedUIData
			{
				Enabled = Enabled.Value,
				MarketplaceEnabled = CanUseMarketplace_DistancedUI.Value,
				MailEnabled = CanUseMail_DistancedUI.Value,
				CanTakeMailAttachments = CanTakeMailAttachments_DistancedUI.Value,
				TraderProfiles = (from d in TraderProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				BankerProfiles = (from d in BankerProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				TeleporterProfiles = (from d in TeleporterProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				GamblerProfiles = (from d in GamblerProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				BufferProfiles = (from d in BufferProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				QuestProfiles = (from d in QuestProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				InfoProfiles = (from d in InfoProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				TransmogrificationProfiles = (from d in TransmogrificationProfiles_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList(),
				DialogueProfiles = (from d in Dialogues_DistancedUI.Value.Split(new char[1] { ',' })
					select d.ToLower().Trim()).ToList()
			};
		}

		[UsedImplicitly]
		private static void OnConfigChange()
		{
			Utils.DelayReloadConfig(DistancedUI_Config, ReadDistancedUIData);
		}
	}
	public static class DistancedUI_UI
	{
		private enum NPCtype_Internal
		{
			Marketplace,
			Mail,
			Trader,
			Banker,
			Teleporter,
			Gambler,
			Buffer,
			Quests,
			Info,
			Transmogrification,
			Dialogues
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class Menu_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsViewProfilesVisible() || IsViewVisible())
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class Menu_OnLogoutYes_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				Hide();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ClickView;

			public static Action<GameObject> <1>__Destroy;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__14_0;

			public static UnityAction <>9__14_1;

			public static UnityAction <>9__14_2;

			public static UnityAction <>9__14_3;

			public static UnityAction <>9__14_4;

			public static UnityAction <>9__14_5;

			public static UnityAction <>9__14_6;

			public static UnityAction <>9__14_7;

			public static UnityAction <>9__14_8;

			public static UnityAction <>9__14_9;

			public static UnityAction <>9__14_10;

			public static Func<Dialogues_DataTypes.RawDialogue, string> <>9__16_0;

			public static Func<Dialogues_DataTypes.RawDialogue, string> <>9__17_0;

			internal void <Init>b__14_0()
			{
				ClickOpen(NPCtype_Internal.Marketplace);
			}

			internal void <Init>b__14_1()
			{
				ClickOpen(NPCtype_Internal.Mail);
			}

			internal void <Init>b__14_2()
			{
				ClickOpen(NPCtype_Internal.Trader);
			}

			internal void <Init>b__14_3()
			{
				ClickOpen(NPCtype_Internal.Banker);
			}

			internal void <Init>b__14_4()
			{
				ClickOpen(NPCtype_Internal.Teleporter);
			}

			internal void <Init>b__14_5()
			{
				ClickOpen(NPCtype_Internal.Gambler);
			}

			internal void <Init>b__14_6()
			{
				ClickOpen(NPCtype_Internal.Buffer);
			}

			internal void <Init>b__14_7()
			{
				ClickOpen(NPCtype_Internal.Quests);
			}

			internal void <Init>b__14_8()
			{
				ClickOpen(NPCtype_Internal.Info);
			}

			internal void <Init>b__14_9()
			{
				ClickOpen(NPCtype_Internal.Transmogrification);
			}

			internal void <Init>b__14_10()
			{
				ClickOpen(NPCtype_Internal.Dialogues);
			}

			internal string <HasAny>b__16_0(Dialogues_DataTypes.RawDialogue x)
			{
				return x.UID;
			}

			internal string <ClickOpen>b__17_0(Dialogues_DataTypes.RawDialogue x)
			{
				return x.UID;
			}
		}

		private static GameObject UI = null;

		private static GameObject Content_Element = null;

		private static Transform Viewport_Content = null;

		private static readonly List<GameObject> Elements = new List<GameObject>();

		private static GameObject View = null;

		private static GameObject View_Profiles = null;

		private static GameObject Left = null;

		private static GameObject Right = null;

		private static Image Profiles_Icon = null;

		private static Text Profiles_Text = null;

		private static readonly List<Image> Buttons_Images = new List<Image>();

		private static readonly Dictionary<NPCtype_Internal, Sprite> Icons = new Dictionary<NPCtype_Internal, Sprite>();

		private static readonly Dictionary<NPCtype_Internal, string> Texts = new Dictionary<NPCtype_Internal, string>
		{
			{
				NPCtype_Internal.Marketplace,
				"$mpasn_Marketplace"
			},
			{
				NPCtype_Internal.Mail,
				"$mpasn_Mail"
			},
			{
				NPCtype_Internal.Trader,
				"$mpasn_Trader"
			},
			{
				NPCtype_Internal.Banker,
				"$mpasn_Banker"
			},
			{
				NPCtype_Internal.Teleporter,
				"$mpasn_Teleporter"
			},
			{
				NPCtype_Internal.Gambler,
				"$mpasn_Gambler"
			},
			{
				NPCtype_Internal.Buffer,
				"$mpasn_Buffer"
			},
			{
				NPCtype_Internal.Quests,
				"$mpasn_Quests"
			},
			{
				NPCtype_Internal.Info,
				"$mpasn_Info"
			},
			{
				NPCtype_Internal.Transmogrification,
				"$mpasn_Transmog"
			},
			{
				NPCtype_Internal.Dialogues,
				"$mpasn_Dialogues"
			}
		};

		public static void Init()
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Expected O, but got Unknown
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Expected O, but got Unknown
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Expected O, but got Unknown
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Expected O, but got Unknown
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Expected O, but got Unknown
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Expected O, but got Unknown
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Expected O, but got Unknown
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Expected O, but got Unknown
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Expected O, but got Unknown
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceDistanedUI"));
			Viewport_Content = UI.transform.Find("Canvas/View_Profiles/CraftView/Scroll View/Viewport/Content");
			View = ((Component)UI.transform.Find("Canvas/Open/View")).gameObject;
			View_Profiles = ((Component)UI.transform.Find("Canvas/View_Profiles")).gameObject;
			Left = ((Component)UI.transform.Find("Canvas/Open/Left")).gameObject;
			Right = ((Component)UI.transform.Find("Canvas/Open/Right")).gameObject;
			Content_Element = AssetStorage.asset.LoadAsset<GameObject>("MarketplaceDistanedUI_Element");
			ButtonClickedEvent onClick = ((Component)UI.transform.Find("Canvas/Open")).GetComponent<Button>().onClick;
			object obj = <>O.<0>__ClickView;
			if (obj == null)
			{
				UnityAction val = ClickView;
				<>O.<0>__ClickView = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.SetActive(false);
			Profiles_Icon = ((Component)UI.transform.Find("Canvas/View_Profiles/Image")).GetComponent<Image>();
			Profiles_Text = ((Component)UI.transform.Find("Canvas/View_Profiles/Text")).GetComponent<Text>();
			Icons[NPCtype_Internal.Marketplace] = AssetStorage.asset.LoadAsset<Sprite>("marketicon_pm");
			Icons[NPCtype_Internal.Mail] = AssetStorage.asset.LoadAsset<Sprite>("mailicon_pm");
			Icons[NPCtype_Internal.Trader] = AssetStorage.asset.LoadAsset<Sprite>("trader_pm");
			Icons[NPCtype_Internal.Banker] = AssetStorage.asset.LoadAsset<Sprite>("banker_pm");
			Icons[NPCtype_Internal.Teleporter] = AssetStorage.asset.LoadAsset<Sprite>("teleporter_pm");
			Icons[NPCtype_Internal.Gambler] = AssetStorage.asset.LoadAsset<Sprite>("gamble_pm");
			Icons[NPCtype_Internal.Buffer] = AssetStorage.asset.LoadAsset<Sprite>("buffer_pm");
			Icons[NPCtype_Internal.Quests] = AssetStorage.asset.LoadAsset<Sprite>("quests_pm");
			Icons[NPCtype_Internal.Info] = AssetStorage.asset.LoadAsset<Sprite>("info_pm");
			Icons[NPCtype_Internal.Transmogrification] = AssetStorage.asset.LoadAsset<Sprite>("transmog_pm");
			Icons[NPCtype_Internal.Dialogues] = AssetStorage.asset.LoadAsset<Sprite>("dialogues_pm");
			ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("Canvas/Open/View/Marketplace")).GetComponent<Button>().onClick;
			object obj2 = <>c.<>9__14_0;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					ClickOpen(NPCtype_Internal.Marketplace);
				};
				<>c.<>9__14_0 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			ButtonClickedEvent onClick3 = ((Component)UI.transform.Find("Canvas/Open/View/Mail")).GetComponent<Button>().onClick;
			object obj3 = <>c.<>9__14_1;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					ClickOpen(NPCtype_Internal.Mail);
				};
				<>c.<>9__14_1 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = ((Component)UI.transform.Find("Canvas/Open/View/Trader")).GetComponent<Button>().onClick;
			object obj4 = <>c.<>9__14_2;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					ClickOpen(NPCtype_Internal.Trader);
				};
				<>c.<>9__14_2 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			ButtonClickedEvent onClick5 = ((Component)UI.transform.Find("Canvas/Open/View/Banker")).GetComponent<Button>().onClick;
			object obj5 = <>c.<>9__14_3;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					ClickOpen(NPCtype_Internal.Banker);
				};
				<>c.<>9__14_3 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			ButtonClickedEvent onClick6 = ((Component)UI.transform.Find("Canvas/Open/View/Teleporter")).GetComponent<Button>().onClick;
			object obj6 = <>c.<>9__14_4;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					ClickOpen(NPCtype_Internal.Teleporter);
				};
				<>c.<>9__14_4 = val6;
				obj6 = (object)val6;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			ButtonClickedEvent onClick7 = ((Component)UI.transform.Find("Canvas/Open/View/Gambler")).GetComponent<Button>().onClick;
			object obj7 = <>c.<>9__14_5;
			if (obj7 == null)
			{
				UnityAction val7 = delegate
				{
					ClickOpen(NPCtype_Internal.Gambler);
				};
				<>c.<>9__14_5 = val7;
				obj7 = (object)val7;
			}
			((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			ButtonClickedEvent onClick8 = ((Component)UI.transform.Find("Canvas/Open/View/Buffer")).GetComponent<Button>().onClick;
			object obj8 = <>c.<>9__14_6;
			if (obj8 == null)
			{
				UnityAction val8 = delegate
				{
					ClickOpen(NPCtype_Internal.Buffer);
				};
				<>c.<>9__14_6 = val8;
				obj8 = (object)val8;
			}
			((UnityEvent)onClick8).AddListener((UnityAction)obj8);
			ButtonClickedEvent onClick9 = ((Component)UI.transform.Find("Canvas/Open/View/Quests")).GetComponent<Button>().onClick;
			object obj9 = <>c.<>9__14_7;
			if (obj9 == null)
			{
				UnityAction val9 = delegate
				{
					ClickOpen(NPCtype_Internal.Quests);
				};
				<>c.<>9__14_7 = val9;
				obj9 = (object)val9;
			}
			((UnityEvent)onClick9).AddListener((UnityAction)obj9);
			ButtonClickedEvent onClick10 = ((Component)UI.transform.Find("Canvas/Open/View/Info")).GetComponent<Button>().onClick;
			object obj10 = <>c.<>9__14_8;
			if (obj10 == null)
			{
				UnityAction val10 = delegate
				{
					ClickOpen(NPCtype_Internal.Info);
				};
				<>c.<>9__14_8 = val10;
				obj10 = (object)val10;
			}
			((UnityEvent)onClick10).AddListener((UnityAction)obj10);
			ButtonClickedEvent onClick11 = ((Component)UI.transform.Find("Canvas/Open/View/Transmogrification")).GetComponent<Button>().onClick;
			object obj11 = <>c.<>9__14_9;
			if (obj11 == null)
			{
				UnityAction val11 = delegate
				{
					ClickOpen(NPCtype_Internal.Transmogrification);
				};
				<>c.<>9__14_9 = val11;
				obj11 = (object)val11;
			}
			((UnityEvent)onClick11).AddListener((UnityAction)obj11);
			ButtonClickedEvent onClick12 = ((Component)UI.transform.Find("Canvas/Open/View/Dialogues")).GetComponent<Button>().onClick;
			object obj12 = <>c.<>9__14_10;
			if (obj12 == null)
			{
				UnityAction val12 = delegate
				{
					ClickOpen(NPCtype_Internal.Dialogues);
				};
				<>c.<>9__14_10 = val12;
				obj12 = (object)val12;
			}
			((UnityEvent)onClick12).AddListener((UnityAction)obj12);
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Marketplace")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Mail")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Trader")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Banker")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Teleporter")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Gambler")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Buffer")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Quests")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Info")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Transmogrification")).GetComponent<Image>());
			Buttons_Images.Add(((Component)UI.transform.Find("Canvas/Open/View/Dialogues")).GetComponent<Image>());
			foreach (Image buttons_Image in Buttons_Images)
			{
				((Component)buttons_Image).gameObject.AddComponent<HoverOnButton>();
			}
			Default();
		}

		private static void ResetColors()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			foreach (Image buttons_Image in Buttons_Images)
			{
				((Graphic)buttons_Image).color = Color.white;
				((Component)buttons_Image).GetComponent<HoverOnButton>()._locked = false;
			}
		}

		private static bool HasAny(NPCtype_Internal type)
		{
			return (type switch
			{
				NPCtype_Internal.Trader => DistancedUI_DataType.SyncedDistancedUIData.Value.TraderProfiles, 
				NPCtype_Internal.Banker => DistancedUI_DataType.SyncedDistancedUIData.Value.BankerProfiles, 
				NPCtype_Internal.Teleporter => DistancedUI_DataType.SyncedDistancedUIData.Value.TeleporterProfiles, 
				NPCtype_Internal.Gambler => DistancedUI_DataType.SyncedDistancedUIData.Value.GamblerProfiles, 
				NPCtype_Internal.Buffer => DistancedUI_DataType.SyncedDistancedUIData.Value.BufferProfiles, 
				NPCtype_Internal.Quests => DistancedUI_DataType.SyncedDistancedUIData.Value.QuestProfiles, 
				NPCtype_Internal.Info => DistancedUI_DataType.SyncedDistancedUIData.Value.InfoProfiles, 
				NPCtype_Internal.Transmogrification => DistancedUI_DataType.SyncedDistancedUIData.Value.TransmogrificationProfiles, 
				NPCtype_Internal.Dialogues => DistancedUI_DataType.SyncedDistancedUIData.Value.DialogueProfiles, 
				_ => new List<string>(), 
			}).Any((type switch
			{
				NPCtype_Internal.Trader => Trader_DataTypes.ClientSideItemList.Keys.ToList(), 
				NPCtype_Internal.Banker => Banker_DataTypes.SyncedBankerProfiles.Value.Keys.ToList(), 
				NPCtype_Internal.Teleporter => Teleporter_DataTypes.SyncedTeleporterData.Value.Keys.ToList(), 
				NPCtype_Internal.Gambler => Gambler_DataTypes.SyncedGamblerData.Value.Keys.ToList(), 
				NPCtype_Internal.Buffer => Buffer_DataTypes.ClientSideBufferProfiles.Keys.ToList(), 
				NPCtype_Internal.Quests => Quests_DataTypes.SyncedQuestProfiles.Value.Keys.ToList(), 
				NPCtype_Internal.Info => ServerInfo_DataTypes.SyncedServerInfoData.Value.Keys.ToList(), 
				NPCtype_Internal.Transmogrification => Transmogrification_DataTypes.SyncedTransmogData.Value.Keys.ToList(), 
				NPCtype_Internal.Dialogues => Dialogues_DataTypes.SyncedDialoguesData.Value.Select((Dialogues_DataTypes.RawDialogue x) => x.UID).ToList(), 
				_ => new List<string>(), 
			}).Contains);
		}

		private static void ClickOpen(NPCtype_Internal type)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Expected O, but got Unknown
			if (!DistancedUI_DataType.SyncedDistancedUIData.Value.Enabled || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			HideViewProfiles();
			NPCtype_Internal nPCtype_Internal = type;
			if ((uint)nPCtype_Internal > 1u)
			{
				((Graphic)Buttons_Images[(int)type]).color = Color.green;
				((Component)Buttons_Images[(int)type]).GetComponent<HoverOnButton>()._locked = true;
			}
			Menu.instance.OnClose();
			AssetStorage.AUsrc.Play();
			Profiles_Icon.sprite = Icons[type];
			Profiles_Text.text = Localization.instance.Localize(Texts[type]);
			if (type == NPCtype_Internal.Marketplace)
			{
				if (DistancedUI_DataType.SyncedDistancedUIData.Value.MarketplaceEnabled)
				{
					if (Marketplace_UI.IsPanelVisible())
					{
						Marketplace_UI.Hide();
					}
					else
					{
						Marketplace_UI.Show();
					}
				}
				return;
			}
			if (type == NPCtype_Internal.Mail)
			{
				if (DistancedUI_DataType.SyncedDistancedUIData.Value.MailEnabled)
				{
					if (CentralizedMailSystem_UI.IsMainVisible)
					{
						CentralizedMailSystem_UI.Hide();
					}
					else
					{
						CentralizedMailSystem_UI.Show(DistancedUI_DataType.SyncedDistancedUIData.Value.CanTakeMailAttachments);
					}
				}
				return;
			}
			View_Profiles.SetActive(true);
			List<string> list = type switch
			{
				NPCtype_Internal.Trader => DistancedUI_DataType.SyncedDistancedUIData.Value.TraderProfiles, 
				NPCtype_Internal.Banker => DistancedUI_DataType.SyncedDistancedUIData.Value.BankerProfiles, 
				NPCtype_Internal.Teleporter => DistancedUI_DataType.SyncedDistancedUIData.Value.TeleporterProfiles, 
				NPCtype_Internal.Gambler => DistancedUI_DataType.SyncedDistancedUIData.Value.GamblerProfiles, 
				NPCtype_Internal.Buffer => DistancedUI_DataType.SyncedDistancedUIData.Value.BufferProfiles, 
				NPCtype_Internal.Quests => DistancedUI_DataType.SyncedDistancedUIData.Value.QuestProfiles, 
				NPCtype_Internal.Info => DistancedUI_DataType.SyncedDistancedUIData.Value.InfoProfiles, 
				NPCtype_Internal.Transmogrification => DistancedUI_DataType.SyncedDistancedUIData.Value.TransmogrificationProfiles, 
				NPCtype_Internal.Dialogues => DistancedUI_DataType.SyncedDistancedUIData.Value.DialogueProfiles, 
				_ => new List<string>(), 
			};
			List<string> list2 = type switch
			{
				NPCtype_Internal.Trader => Trader_DataTypes.ClientSideItemList.Keys.ToList(), 
				NPCtype_Internal.Banker => Banker_DataTypes.SyncedBankerProfiles.Value.Keys.ToList(), 
				NPCtype_Internal.Teleporter => Teleporter_DataTypes.SyncedTeleporterData.Value.Keys.ToList(), 
				NPCtype_Internal.Gambler => Gambler_DataTypes.SyncedGamblerData.Value.Keys.ToList(), 
				NPCtype_Internal.Buffer => Buffer_DataTypes.ClientSideBufferProfiles.Keys.ToList(), 
				NPCtype_Internal.Quests => Quests_DataTypes.SyncedQuestProfiles.Value.Keys.ToList(), 
				NPCtype_Internal.Info => ServerInfo_DataTypes.SyncedServerInfoData.Value.Keys.ToList(), 
				NPCtype_Internal.Transmogrification => Transmogrification_DataTypes.SyncedTransmogData.Value.Keys.ToList(), 
				NPCtype_Internal.Dialogues => Dialogues_DataTypes.SyncedDialoguesData.Value.Select((Dialogues_DataTypes.RawDialogue x) => x.UID).ToList(), 
				_ => new List<string>(), 
			};
			foreach (string item in list)
			{
				if (!list2.Contains(item))
				{
					continue;
				}
				GameObject val = Object.Instantiate<GameObject>(Content_Element, Viewport_Content);
				val.AddComponent<HoverOnButton>();
				string toUppper = "";
				for (int i = 0; i < item.Length; i++)
				{
					if (i == 0 || item[i - 1] == '_')
					{
						toUppper += char.ToUpper(item[i]);
					}
					else
					{
						toUppper += ((item[i] == '_') ? ' ' : item[i]);
					}
				}
				((Component)val.transform.Find("Text")).GetComponent<Text>().text = toUppper;
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					ClickElement(item, type, toUppper);
				});
				Elements.Add(val);
			}
		}

		private static void ClickElement(string profile, NPCtype_Internal type, string _NPCname)
		{
			if (DistancedUI_DataType.SyncedDistancedUIData.Value.Enabled && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Menu.instance.OnClose();
				AssetStorage.AUsrc.Play();
				HideViewProfiles();
				HideView();
				switch (type)
				{
				case NPCtype_Internal.Trader:
					Trader_UI.Show(profile, _NPCname);
					break;
				case NPCtype_Internal.Banker:
					Banker_UI.Show(profile, _NPCname);
					break;
				case NPCtype_Internal.Teleporter:
					Teleporter_Main_Client.ShowTeleporterUI(profile);
					break;
				case NPCtype_Internal.Gambler:
					Gambler_UI.Show(profile);
					break;
				case NPCtype_Internal.Buffer:
					Buffer_UI.Show(profile, _NPCname);
					break;
				case NPCtype_Internal.Quests:
					Quests_UIs.QuestUI.Show(profile, _NPCname);
					break;
				case NPCtype_Internal.Info:
					ServerInfo_UI.Show(profile, _NPCname);
					break;
				case NPCtype_Internal.Transmogrification:
					Transmogrification_UI.Show(profile, _NPCname);
					break;
				case NPCtype_Internal.Dialogues:
					Dialogues_UI.LoadDialogue(null, profile);
					break;
				}
			}
		}

		private static bool IsViewVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return View.activeInHierarchy;
			}
			return false;
		}

		public static bool IsViewProfilesVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return View_Profiles.activeInHierarchy;
			}
			return false;
		}

		private static void Default()
		{
			View.SetActive(false);
			HideViewProfiles();
			Left.SetActive(true);
			Right.SetActive(false);
		}

		public static void ClickView()
		{
			ResetColors();
			if (DistancedUI_DataType.SyncedDistancedUIData.Value.Enabled && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Menu.instance.OnClose();
				AssetStorage.AUsrc.Play();
				View_Profiles.SetActive(false);
				bool activeSelf = View.activeSelf;
				View.SetActive(!activeSelf);
				if (activeSelf)
				{
					Left.SetActive(true);
					Right.SetActive(false);
					return;
				}
				Left.SetActive(false);
				Right.SetActive(true);
				((Component)Buttons_Images[2]).gameObject.SetActive(HasAny(NPCtype_Internal.Trader));
				((Component)Buttons_Images[3]).gameObject.SetActive(HasAny(NPCtype_Internal.Banker));
				((Component)Buttons_Images[4]).gameObject.SetActive(HasAny(NPCtype_Internal.Teleporter));
				((Component)Buttons_Images[5]).gameObject.SetActive(HasAny(NPCtype_Internal.Gambler));
				((Component)Buttons_Images[6]).gameObject.SetActive(HasAny(NPCtype_Internal.Buffer));
				((Component)Buttons_Images[7]).gameObject.SetActive(HasAny(NPCtype_Internal.Quests));
				((Component)Buttons_Images[8]).gameObject.SetActive(HasAny(NPCtype_Internal.Info));
				((Component)Buttons_Images[9]).gameObject.SetActive(HasAny(NPCtype_Internal.Transmogrification));
				((Component)Buttons_Images[10]).gameObject.SetActive(HasAny(NPCtype_Internal.Dialogues));
			}
		}

		public static void Show(bool allowMarket, bool allowMail)
		{
			if (Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				((Component)Buttons_Images[0]).gameObject.SetActive(allowMarket);
				((Component)Buttons_Images[1]).gameObject.SetActive(allowMail);
				Default();
				UI.SetActive(true);
			}
		}

		public static void Hide()
		{
			Default();
			UI.SetActive(false);
		}

		public static void HideViewProfiles()
		{
			Elements.ForEach((Action<GameObject>)Object.Destroy);
			Elements.Clear();
			View_Profiles.SetActive(false);
			ResetColors();
		}

		private static void HideView()
		{
			View.SetActive(false);
			Left.SetActive(true);
			Right.SetActive(false);
		}
	}
	public class HoverOnButton : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		private Image _image;

		public bool _locked;

		private void Awake()
		{
			_image = ((Component)this).GetComponent<Image>();
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!_locked)
			{
				((Graphic)_image).color = Color.green;
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!_locked)
			{
				((Graphic)_image).color = Color.white;
			}
		}
	}
}
namespace Marketplace.Modules.Buffer
{
	public static class Buffer_DataTypes
	{
		[Flags]
		public enum WhatToModify
		{
			None = 0,
			ModifyAttack = 1,
			ModifyHealthRegen = 2,
			ModifyStaminaRegen = 4,
			ModifyRaiseSkills = 8,
			ModifySpeed = 0x10,
			ModifyNoise = 0x20,
			ModifyMaxCarryWeight = 0x40,
			ModifyStealth = 0x80,
			RunStaminaDrain = 0x100,
			DamageReduction = 0x200
		}

		public class BufferBuffData : ISerializableParameter
		{
			public string UniqueName;

			public string Name;

			public int Duration;

			public Dictionary<WhatToModify, float> ModifyList = new Dictionary<WhatToModify, float>
			{
				{
					WhatToModify.ModifyAttack,
					1f
				},
				{
					WhatToModify.ModifyHealthRegen,
					1f
				},
				{
					WhatToModify.ModifyStaminaRegen,
					1f
				},
				{
					WhatToModify.ModifyRaiseSkills,
					1f
				},
				{
					WhatToModify.ModifySpeed,
					1f
				},
				{
					WhatToModify.ModifyNoise,
					1f
				},
				{
					WhatToModify.ModifyMaxCarryWeight,
					0f
				},
				{
					WhatToModify.ModifyStealth,
					1f
				},
				{
					WhatToModify.RunStaminaDrain,
					1f
				},
				{
					WhatToModify.DamageReduction,
					0f
				}
			};

			public string NeededPrefab;

			public int NeededPrefabCount;

			public WhatToModify Flags;

			public string SpritePrefab;

			public string StartEffectPrefab;

			public string BuffGroup;

			private BufferMain Main;

			private string NeededItemName;

			private Sprite Icon;

			private Sprite NeededItemIcon;

			private GameObject StartEffect;

			public bool? IsValid;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(UniqueName ?? "");
				pkg.Write(Name ?? "");
				pkg.Write(Duration);
				pkg.Write(ModifyList[WhatToModify.ModifyAttack]);
				pkg.Write(ModifyList[WhatToModify.ModifyHealthRegen]);
				pkg.Write(ModifyList[WhatToModify.ModifyStaminaRegen]);
				pkg.Write(ModifyList[WhatToModify.ModifyRaiseSkills]);
				pkg.Write(ModifyList[WhatToModify.ModifySpeed]);
				pkg.Write(ModifyList[WhatToModify.ModifyNoise]);
				pkg.Write(ModifyList[WhatToModify.ModifyMaxCarryWeight]);
				pkg.Write(ModifyList[WhatToModify.ModifyStealth]);
				pkg.Write(ModifyList[WhatToModify.RunStaminaDrain]);
				pkg.Write(ModifyList[WhatToModify.DamageReduction]);
				pkg.Write(NeededPrefab ?? "");
				pkg.Write(NeededPrefabCount);
				pkg.Write((int)Flags);
				pkg.Write(SpritePrefab ?? "");
				pkg.Write(StartEffectPrefab ?? "");
				pkg.Write(BuffGroup ?? "");
			}

			public void Deserialize(ref ZPackage pkg)
			{
				UniqueName = pkg.ReadString();
				Name = pkg.ReadString();
				Duration = pkg.ReadInt();
				ModifyList[WhatToModify.ModifyAttack] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifyHealthRegen] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifyStaminaRegen] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifyRaiseSkills] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifySpeed] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifyNoise] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifyMaxCarryWeight] = pkg.ReadSingle();
				ModifyList[WhatToModify.ModifyStealth] = pkg.ReadSingle();
				ModifyList[WhatToModify.RunStaminaDrain] = pkg.ReadSingle();
				ModifyList[WhatToModify.DamageReduction] = pkg.ReadSingle();
				NeededPrefab = pkg.ReadString();
				NeededPrefabCount = pkg.ReadInt();
				Flags = (WhatToModify)pkg.ReadInt();
				SpritePrefab = pkg.ReadString();
				StartEffectPrefab = pkg.ReadString();
				BuffGroup = pkg.ReadString();
			}

			public BufferMain GetMain()
			{
				return Main;
			}

			public string GetItemName()
			{
				return NeededItemName;
			}

			public void Init()
			{
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Expected O, but got Unknown
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Expected O, but got Unknown
				if (IsValid.HasValue)
				{
					return;
				}
				IsValid = false;
				GameObject prefab = ZNetScene.instance.GetPrefab(SpritePrefab);
				GameObject prefab2 = ZNetScene.instance.GetPrefab(NeededPrefab);
				if (!Object.op_Implicit((Object)(object)prefab2))
				{
					return;
				}
				NeededItemName = prefab2.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				Icon = AssetStorage.PlaceholderGamblerIcon;
				Sprite value;
				if (Object.op_Implicit((Object)(object)prefab))
				{
					if (Object.op_Implicit((Object)(object)prefab.GetComponent<Character>()))
					{
						PhotoManager.__instance.MakeSprite(prefab);
						Icon = PhotoManager.__instance.GetSprite(((Object)prefab).name, AssetStorage.PlaceholderMonsterIcon, 1);
					}
					else if (Object.op_Implicit((Object)(object)prefab.GetComponent<ItemDrop>()))
					{
						Icon = prefab.GetComponent<ItemDrop>().m_itemData.GetIcon();
					}
				}
				else if (AssetStorage.GlobalCachedSprites.TryGetValue(SpritePrefab, out value))
				{
					Icon = value;
				}
				NeededItemIcon = prefab2.GetComponent<ItemDrop>().m_itemData.GetIcon();
				StartEffect = ZNetScene.instance.GetPrefab(StartEffectPrefab);
				ObjectDB instance = ObjectDB.instance;
				instance.m_StatusEffects.RemoveAll((StatusEffect se) => ((Object)se).name == UniqueName);
				Main = ScriptableObject.CreateInstance<BufferMain>();
				((Object)Main).name = UniqueName;
				Main.Data = this;
				((StatusEffect)Main).m_icon = Icon;
				((StatusEffect)Main).m_name = Name;
				((StatusEffect)Main).m_ttl = Duration;
				((StatusEffect)Main).m_tooltip = Buffer_UI.GetFlagsText(this);
				if (Object.op_Implicit((Object)(object)StartEffect))
				{
					BufferMain main = Main;
					EffectList val = new EffectList();
					val.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
					{
						new EffectData
						{
							m_attach = true,
							m_enabled = true,
							m_inheritParentRotation = true,
							m_inheritParentScale = true,
							m_prefab = StartEffect,
							m_randomRotation = false,
							m_scale = true
						}
					};
					((StatusEffect)main).m_startEffects = val;
				}
				instance.m_StatusEffects.Add((StatusEffect)(object)Main);
				IsValid = true;
			}

			public Sprite GetIcon()
			{
				return Icon;
			}

			public Sprite GetIconNeeded()
			{
				return NeededItemIcon;
			}

			public bool CanTake()
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !string.IsNullOrEmpty(BuffGroup) && !((Character)Player.m_localPlayer).GetSEMan().m_statusEffects.Any((StatusEffect s) => s is BufferMain bufferMain && bufferMain.Data.BuffGroup == BuffGroup))
				{
					return EnoughMaterials();
				}
				return false;
			}

			private bool EnoughMaterials()
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return false;
				}
				return ((Humanoid)Player.m_localPlayer).m_inventory.CountItems(NeededItemName, -1, true) >= NeededPrefabCount;
			}
		}

		public class BufferMain : StatusEffect
		{
			public BufferBuffData Data;

			public override void ModifyAttack(SkillType skill, ref HitData hitData)
			{
				hitData.ApplyModifier(Data.ModifyList[WhatToModify.ModifyAttack]);
			}

			public override void ModifyHealthRegen(ref float regenMultiplier)
			{
				regenMultiplier *= Data.ModifyList[WhatToModify.ModifyHealthRegen];
			}

			public override void ModifyStaminaRegen(ref float staminaRegen)
			{
				staminaRegen *= Data.ModifyList[WhatToModify.ModifyStaminaRegen];
			}

			public override void ModifyRaiseSkill(SkillType skill, ref float value)
			{
				value *= Data.ModifyList[WhatToModify.ModifyRaiseSkills];
			}

			public override void ModifySpeed(float baseSpeed, ref float speed, Character character, Vector3 dir)
			{
				speed *= Data.ModifyList[WhatToModify.ModifySpeed];
			}

			public override void ModifyNoise(float baseNoise, ref float noise)
			{
				noise *= Data.ModifyList[WhatToModify.ModifyNoise];
			}

			public override void ModifyStealth(float baseStealth, ref float stealth)
			{
				stealth *= Data.ModifyList[WhatToModify.ModifyStealth];
			}

			public override void ModifyMaxCarryWeight(float baseLimit, ref float limit)
			{
				limit += Data.ModifyList[WhatToModify.ModifyMaxCarryWeight];
			}

			public override void ModifyRunStaminaDrain(float baseDrain, ref float drain, Vector3 dir)
			{
				drain *= Data.ModifyList[WhatToModify.RunStaminaDrain];
			}

			public override void ModifyJumpStaminaUsage(float baseStaminaUse, ref float staminaUse)
			{
				staminaUse *= Data.ModifyList[WhatToModify.RunStaminaDrain];
			}

			public override void OnDamaged(HitData hit, Character attacker)
			{
				float num = Mathf.Clamp01(1f - Data.ModifyList[WhatToModify.DamageReduction]);
				hit.ApplyModifier(num);
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, string>> SyncedBufferProfiles = new CustomSyncedValue<Dictionary<string, string>>(Marketplace.configSync, "bufferProfiles", new Dictionary<string, string>());

		internal static readonly CustomSyncedValue<List<BufferBuffData>> SyncedBufferBuffs = new CustomSyncedValue<List<BufferBuffData>>(Marketplace.configSync, "bufferBuffs", new List<BufferBuffData>());

		public static readonly Dictionary<string, List<BufferBuffData>> ClientSideBufferProfiles = new Dictionary<string, List<BufferBuffData>>();

		public static readonly WhatToModify[] BufferModifyList = (WhatToModify[])Enum.GetValues(typeof(WhatToModify));
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Buffer_Main_Client
	{
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		[ClientOnlyPatch]
		private static class ObjectDB_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				OnBufferUpdate();
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			Buffer_UI.Init();
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
			Buffer_DataTypes.SyncedBufferProfiles.ValueChanged += OnBufferUpdate;
			Buffer_DataTypes.SyncedBufferBuffs.ValueChanged += OnBufferUpdate;
		}

		private static void Update(float dt)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Input.GetKeyDown((KeyCode)27) && Buffer_UI.IsVisible())
			{
				Buffer_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		private static void OnBufferUpdate()
		{
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			Buffer_DataTypes.ClientSideBufferProfiles.Clear();
			ObjectDB.instance.m_StatusEffects.RemoveAll((StatusEffect x) => x is Buffer_DataTypes.BufferMain);
			try
			{
				foreach (Buffer_DataTypes.BufferBuffData item in Buffer_DataTypes.SyncedBufferBuffs.Value)
				{
					item.Init();
				}
				foreach (KeyValuePair<string, string> item2 in Buffer_DataTypes.SyncedBufferProfiles.Value)
				{
					Buffer_DataTypes.ClientSideBufferProfiles.Add(item2.Key, new List<Buffer_DataTypes.BufferBuffData>());
					string[] array = item2.Value.Split(new char[1] { ',' });
					foreach (string split in array)
					{
						if (!string.IsNullOrEmpty(split))
						{
							Buffer_DataTypes.BufferBuffData bufferBuffData = Buffer_DataTypes.SyncedBufferBuffs.Value.Find((Buffer_DataTypes.BufferBuffData d) => d.UniqueName == split);
							if (bufferBuffData != null && (bufferBuffData.IsValid ?? false))
							{
								Buffer_DataTypes.ClientSideBufferProfiles[item2.Key].Add(bufferBuffData);
							}
						}
					}
				}
				Buffer_UI.Reload();
			}
			catch (Exception arg)
			{
				Utils.print($"Error on trying to Init Buff:\n{arg}", ConsoleColor.Red);
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "BP", "BD" }, new string[] { "OnBufferProfilesFileChange", "OnBufferProfilesFileChange" })]
	public static class Buffer_Main_Server
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			ReadBufferConfigs();
		}

		private static void ReadBufferConfigs()
		{
			Buffer_DataTypes.SyncedBufferProfiles.Value.Clear();
			Buffer_DataTypes.SyncedBufferBuffs.Value.Clear();
			try
			{
				string bufferProfilesFolder = Market_Paths.BufferProfilesFolder;
				string[] files = Directory.GetFiles(bufferProfilesFolder, "*.cfg", SearchOption.AllDirectories);
				string[] array = files;
				foreach (string path in array)
				{
					IReadOnlyList<string> profiles = File.ReadAllLines(path).ToList();
					ReadBufferProfiles(profiles);
				}
				bufferProfilesFolder = Market_Paths.BufferDatabaseFolder;
				files = Directory.GetFiles(bufferProfilesFolder, "*.cfg", SearchOption.AllDirectories);
				string[] array2 = files;
				foreach (string text in array2)
				{
					IReadOnlyList<string> profiles2 = File.ReadAllLines(text).ToList();
					ReadBufferDatabase(text, profiles2);
				}
			}
			catch (Exception arg)
			{
				Utils.print($"Got exception on save buffer. Not sending data:{arg}", ConsoleColor.Red);
			}
			finally
			{
				Buffer_DataTypes.SyncedBufferProfiles.Update();
				Buffer_DataTypes.SyncedBufferBuffs.Update();
			}
		}

		[UsedImplicitly]
		private static void OnBufferProfilesFileChange()
		{
			ReadBufferConfigs();
			Utils.print("Buffer Profiles / Database Changed. Sending new info to all clients");
		}

		private static void ReadBufferProfiles(IReadOnlyList<string> profiles)
		{
			string key = "default";
			foreach (string profile in profiles)
			{
				if (!string.IsNullOrWhiteSpace(profile) && !profile.StartsWith("#"))
				{
					if (profile.StartsWith("["))
					{
						key = profile.Replace("[", "").Replace("]", "").Replace(" ", "")
							.ToLower();
					}
					else if (!Buffer_DataTypes.SyncedBufferProfiles.Value.ContainsKey(key))
					{
						Buffer_DataTypes.SyncedBufferProfiles.Value.Add(key, profile.Replace(" ", ""));
					}
				}
			}
		}

		private static void ReadBufferDatabase(string fPath, IReadOnlyList<string> profiles)
		{
			string text = null;
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					text = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "");
					continue;
				}
				try
				{
					if (text == null)
					{
						continue;
					}
					if (i + 5 > profiles.Count)
					{
						break;
					}
					Buffer_DataTypes.BufferBuffData bufferBuffData = new Buffer_DataTypes.BufferBuffData
					{
						UniqueName = text,
						Name = profiles[i],
						Duration = int.Parse(profiles[i + 1].Replace(" ", "")),
						SpritePrefab = profiles[i + 2].Replace(" ", "")
					};
					string[] array = profiles[i + 3].Replace(" ", "").Split(new char[1] { ',' });
					bufferBuffData.NeededPrefab = array[0];
					bufferBuffData.NeededPrefabCount = int.Parse(array[1]);
					Buffer_DataTypes.WhatToModify whatToModify = Buffer_DataTypes.WhatToModify.None;
					string[] array2 = profiles[i + 4].Replace(" ", "").Split(new char[1] { ',' });
					string[] array3 = array2;
					foreach (string text2 in array3)
					{
						string[] array4 = text2.Split(new char[1] { '=' });
						if (array4.Length == 2)
						{
							string value = array4[0];
							float value2 = float.Parse(array4[1], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
							if (Enum.TryParse<Buffer_DataTypes.WhatToModify>(value, ignoreCase: true, out var result))
							{
								whatToModify |= result;
								bufferBuffData.ModifyList[result] = value2;
							}
						}
					}
					bufferBuffData.Flags = whatToModify;
					bufferBuffData.StartEffectPrefab = profiles[i + 5].Replace(" ", "");
					bufferBuffData.BuffGroup = profiles[i + 6].Trim(new char[1] { ' ' });
					Buffer_DataTypes.SyncedBufferBuffs.Value.Add(bufferBuffData);
					text = null;
				}
				catch (Exception arg)
				{
					Utils.print($"Buffer error {fPath} in profile {text} : {arg}", ConsoleColor.Red);
				}
			}
		}
	}
	public static class Buffer_UI
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				__instance.m_prefabs.Add(Explosion);
				__instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)Explosion).name), Explosion);
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class BufferUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsVisible())
				{
					__result = true;
				}
			}
		}

		private static GameObject UI = null;

		private static GameObject BufferGroup = null;

		private static GameObject BufferItem = null;

		private static Transform MainTransform = null;

		private static Text NPCName = null;

		private static Scrollbar Scrollbar = null;

		private static string CurrentProfile = "";

		private static GameObject Explosion = null;

		private static readonly List<GameObject> AllElements = new List<GameObject>();

		private static readonly Dictionary<GameObject, Buffer_DataTypes.BufferBuffData> tempBuffData = new Dictionary<GameObject, Buffer_DataTypes.BufferBuffData>();

		public static bool IsVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("BufferHud"));
			Explosion = AssetStorage.asset.LoadAsset<GameObject>("MarketplaceBuffExplosion");
			BufferGroup = AssetStorage.asset.LoadAsset<GameObject>("BufferGroup");
			BufferItem = AssetStorage.asset.LoadAsset<GameObject>("BufferListItem");
			MainTransform = UI.transform.Find("Canvas/Buffer/BufferList/ListPanel/Scroll View/Viewport/Content");
			Scrollbar = UI.GetComponentInChildren<Scrollbar>();
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.SetActive(false);
			NPCName = ((Component)UI.transform.Find("Canvas/Buffer/Header/Text")).GetComponent<Text>();
			Localization.instance.Localize(UI.transform);
		}

		public static string GetFlagsText(Buffer_DataTypes.BufferBuffData data)
		{
			string text = "";
			Buffer_DataTypes.WhatToModify[] bufferModifyList = Buffer_DataTypes.BufferModifyList;
			foreach (Buffer_DataTypes.WhatToModify whatToModify in bufferModifyList)
			{
				if (data.Flags.HasFlagFast(whatToModify))
				{
					switch (whatToModify)
					{
					case Buffer_DataTypes.WhatToModify.ModifyAttack:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_modifyattack"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifyHealthRegen:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_healthregenmodifier"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifyStaminaRegen:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_staminaregenmodifier"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifyRaiseSkills:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_modifyraisingskills"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifySpeed:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_movementspeedmodifier"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifyNoise:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_noisemodifier"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifyMaxCarryWeight:
						text += string.Format("{0}: <color=#00FFFF>+{1}</color>\n", Localization.instance.Localize("$mpasn_maxcarryweight"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.ModifyStealth:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_stealthbonus"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.RunStaminaDrain:
						text += string.Format("{0}: <color=#00FFFF>x{1}</color>\n", Localization.instance.Localize("$mpasn_runstaminadrain"), data.ModifyList[whatToModify]);
						break;
					case Buffer_DataTypes.WhatToModify.DamageReduction:
						text += string.Format("{0}: <color=#00FFFF>-{1}%</color>\n", Localization.instance.Localize("$mpasn_damagereduction"), (int)(data.ModifyList[whatToModify] * 100f));
						break;
					}
				}
			}
			return text;
		}

		private static void SetColors()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<GameObject, Buffer_DataTypes.BufferBuffData> tempBuffDatum in tempBuffData)
			{
				Image component = ((Component)tempBuffDatum.Key.transform.Find("Button")).GetComponent<Image>();
				((Graphic)component).color = (tempBuffDatum.Value.CanTake() ? Color.green : Color.red);
			}
		}

		private static void ApplyBuff(Buffer_DataTypes.BufferBuffData buff)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && buff.CanTake())
			{
				((Character)Player.m_localPlayer).m_seman.AddStatusEffect((StatusEffect)(object)buff.GetMain(), true, 0, 0f);
				((Humanoid)Player.m_localPlayer).m_inventory.RemoveItem(buff.GetItemName(), buff.NeededPrefabCount, -1, true);
				Object.Instantiate<GameObject>(Explosion, ((Component)Player.m_localPlayer).transform.position + Vector3.up, Quaternion.identity);
				SetColors();
			}
		}

		private static void CreateElements()
		{
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Expected O, but got Unknown
			tempBuffData.Clear();
			AllElements.ForEach((Action<GameObject>)Object.Destroy);
			AllElements.Clear();
			if (!IsVisible() || !Buffer_DataTypes.ClientSideBufferProfiles.ContainsKey(CurrentProfile))
			{
				return;
			}
			Dictionary<string, List<Buffer_DataTypes.BufferBuffData>> dictionary = new Dictionary<string, List<Buffer_DataTypes.BufferBuffData>>();
			foreach (Buffer_DataTypes.BufferBuffData item in Buffer_DataTypes.ClientSideBufferProfiles[CurrentProfile])
			{
				string text = item.BuffGroup;
				if (string.IsNullOrEmpty(text))
				{
					text = "No Group";
				}
				if (!dictionary.ContainsKey(text))
				{
					dictionary[text] = new List<Buffer_DataTypes.BufferBuffData>();
				}
				dictionary[text].Add(item);
			}
			foreach (KeyValuePair<string, List<Buffer_DataTypes.BufferBuffData>> item2 in dictionary)
			{
				GameObject val = Object.Instantiate<GameObject>(BufferGroup, MainTransform);
				((Component)val.transform.Find("HeaderSeparator/Text")).GetComponent<Text>().text = "<color=yellow>" + item2.Key + "</color>";
				Transform val2 = val.transform.Find("Content");
				foreach (Buffer_DataTypes.BufferBuffData buff in item2.Value)
				{
					GameObject val3 = Object.Instantiate<GameObject>(BufferItem, val2);
					((Component)val3.transform.Find("Name")).GetComponent<Text>().text = buff.Name;
					((Component)val3.transform.Find("Time")).GetComponent<Text>().text = string.Format("{0}: {1}", Localization.instance.Localize("$mpasn_duration"), buff.Duration);
					((Component)val3.transform.Find("Description")).GetComponent<Text>().text = GetFlagsText(buff);
					((Component)val3.transform.Find("Image")).GetComponent<Image>().sprite = buff.GetIcon();
					((Component)val3.transform.Find("PriceImage")).GetComponent<Image>().sprite = buff.GetIconNeeded();
					((Component)val3.transform.Find("PriceText")).GetComponent<Text>().text = $"x {buff.NeededPrefabCount}";
					((Component)val3.transform.Find("Button/Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_bufferbuy");
					Button component = ((Component)val3.transform.Find("Button")).GetComponent<Button>();
					((UnityEvent)component.onClick).AddListener((UnityAction)delegate
					{
						ApplyBuff(buff);
					});
					tempBuffData.Add(val3, buff);
					SetColors();
				}
				AllElements.Add(val);
			}
			Canvas.ForceUpdateCanvases();
			List<ContentSizeFitter> list = ((Component)MainTransform).GetComponentsInChildren<ContentSizeFitter>().ToList();
			list.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			list.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
		}

		public static void Reload()
		{
			if (IsVisible())
			{
				if (!Buffer_DataTypes.ClientSideBufferProfiles.ContainsKey(CurrentProfile))
				{
					Hide();
				}
				else
				{
					CreateElements();
				}
			}
		}

		public static void Show(string profile, string _npcName)
		{
			if (Buffer_DataTypes.ClientSideBufferProfiles.ContainsKey(profile))
			{
				UI.SetActive(true);
				NPCName.text = (string.IsNullOrEmpty(_npcName) ? Localization.instance.Localize("$mpasn_Buffer") : _npcName);
				CurrentProfile = profile;
				CreateElements();
			}
		}

		public static void Hide()
		{
			tempBuffData.Clear();
			AllElements.ForEach((Action<GameObject>)Object.Destroy);
			AllElements.Clear();
			Scrollbar.value = 1f;
			UI.SetActive(false);
		}
	}
}
namespace Marketplace.Modules.Banker
{
	public static class Banker_DataTypes
	{
		internal static readonly CustomSyncedValue<Dictionary<string, List<int>>> SyncedBankerProfiles = new CustomSyncedValue<Dictionary<string, List<int>>>(Marketplace.configSync, "bankerData", new Dictionary<string, List<int>>());

		public static Dictionary<int, int> BankerClientData = new Dictionary<int, int>();
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Banker_Main_Client
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			Banker_UI.Init();
			Banker_DataTypes.SyncedBankerProfiles.ValueChanged += OnBankerUpdate;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void OnBankerUpdate()
		{
			Banker_UI.Reload();
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Banker_UI.IsPanelVisible())
			{
				Banker_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		[MarketplaceRPC("KGmarket GetBankerClientData", Market_Autoload.Type.Client)]
		private static void GetBankerClientData(long sender, ZPackage pkg)
		{
			pkg.Decompress();
			Banker_DataTypes.BankerClientData = JSON.ToObject<Dictionary<int, int>>(pkg.ReadString());
			Banker_UI.Reload();
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "BA" }, new string[] { "OnBankerProfilesFileChange" })]
	public static class Banker_Main_Server
	{
		[HarmonyPatch(typeof(ZNet), "RPC_CharacterID")]
		[ServerOnlyPatch]
		private static class ZnetSyncBankerProfiles
		{
			[UsedImplicitly]
			private static void Postfix(ZRpc rpc)
			{
				if (ZNet.instance.IsServer())
				{
					if (!BankerTimeStamp.ContainsKey(rpc.m_socket.GetHostName()))
					{
						BankerTimeStamp[rpc.m_socket.GetHostName()] = new Dictionary<int, DateTime>();
					}
					ZNetPeer peer = ZNet.instance.GetPeer(rpc);
					if (peer != null)
					{
						SendBankerDataToClient(peer, sendif0: true);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "GetPeer", new Type[] { typeof(long) })]
		[ServerOnlyPatch]
		private static class ZNet_GetPeer_Patch
		{
			private static void Postfix(ZNet __instance, long uid, ref ZNetPeer __result)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: 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)
				//IL_003d: Expected O, but got Unknown
				if (ZNet.IsSinglePlayer && uid == ZRoutedRpc.instance.m_id)
				{
					__result = new ZNetPeer((ISocket)(object)new Utils.SelfSocket(), true)
					{
						m_uid = uid,
						m_playerName = Game.instance.m_playerProfile.m_playerName
					};
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "GetPeerByHostName")]
		[ServerOnlyPatch]
		private static class ZNet_GetPeerByHostName_Patch
		{
			private static void Postfix(ZNet __instance, string endpoint, ref ZNetPeer __result)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				if (ZNet.IsSinglePlayer && ((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID.m_userID == endpoint)
				{
					__result = new ZNetPeer((ISocket)(object)new Utils.SelfSocket(), true)
					{
						m_uid = ZRoutedRpc.instance.m_id,
						m_playerName = Game.instance.m_playerProfile.m_playerName
					};
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public Task task;

			internal bool <BankerIncome>b__1()
			{
				return task.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <BankerIncome>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass5_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Expected O, but got Unknown
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
					{
						Utils.print("Adding Banker Income");
						<>8__1.task = Task.Run(delegate
						{
							global::Marketplace.DB.DB._context.IncreaseInterest(Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Split(new char[1] { ',' }).ToHashSet(), BankerTimeStamp);
						});
						<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.task.IsCompleted));
						<>1__state = 2;
						return true;
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						foreach (ZNetPeer peer in ZNet.instance.m_peers)
						{
							if (peer.IsReady())
							{
								SendBankerDataToClient(peer, sendif0: false);
							}
						}
						if (ZNet.IsSinglePlayer)
						{
							SendBankerDataToClient(((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID.m_userID, ZRoutedRpc.instance.m_id, sendif0: false);
						}
						<>8__1 = null;
						goto IL_0022;
					}
					IL_0022:
					<>8__1 = new <>c__DisplayClass5_0();
					<>2__current = (object)new WaitForSecondsRealtime((float)(Global_Configs.BankerIncomeTime * 3600));
					<>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 readonly Dictionary<string, Dictionary<int, DateTime>> BankerTimeStamp = new Dictionary<string, Dictionary<int, DateTime>>();

		[UsedImplicitly]
		private static void OnInit()
		{
			if (Global_Configs.BankerIncomeTime > 0)
			{
				((MonoBehaviour)Marketplace._thistype).StartCoroutine(BankerIncome());
			}
			ReadServerBankerProfiles();
		}

		[UsedImplicitly]
		private static void OnBankerProfilesFileChange()
		{
			ReadServerBankerProfiles();
			Utils.print("Banker Changed. Sending new info to all clients");
		}

		private static void ProcessBankerProfiles(IReadOnlyList<string> profiles)
		{
			string key = "default";
			foreach (string profile in profiles)
			{
				if (string.IsNullOrWhiteSpace(profile) || profile.StartsWith("#"))
				{
					continue;
				}
				if (profile.StartsWith("["))
				{
					key = profile.Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					continue;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(profile.Replace(" ", ""));
				if (Banker_DataTypes.SyncedBankerProfiles.Value.TryGetValue(key, out List<int> value))
				{
					value.Add(stableHashCode);
					continue;
				}
				Banker_DataTypes.SyncedBankerProfiles.Value[key] = new List<int>(1) { stableHashCode };
			}
		}

		public static void ReadServerBankerProfiles()
		{
			Banker_DataTypes.SyncedBankerProfiles.Value.Clear();
			string bankerProfilesFolder = Market_Paths.BankerProfilesFolder;
			string[] files = Directory.GetFiles(bankerProfilesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string path in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(path).ToList();
				ProcessBankerProfiles(profiles);
			}
			Banker_DataTypes.SyncedBankerProfiles.Update();
		}

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

		private static void SendBankerDataToClient(ZNetPeer peer, bool sendif0)
		{
			string hostName = peer.m_socket.GetHostName();
			SendBankerDataToClient(hostName, peer.m_uid, sendif0);
		}

		private static void SendBankerDataToClient(string hostname, long id, bool sendif0)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (!(hostname == "0"))
			{
				Dictionary<int, int> userBankItems = global::Marketplace.DB.DB._context.GetUserBankItems(hostname);
				if (userBankItems.Count != 0 || sendif0)
				{
					string text = JSON.ToJSON(userBankItems);
					ZPackage val = new ZPackage();
					val.Write(text);
					val.Compress();
					ZRoutedRpc.instance.InvokeRoutedRPC(id, "KGmarket GetBankerClientData", new object[1] { val });
				}
			}
		}

		[MarketplaceRPC("KGmarket BankerDeposit", Market_Autoload.Type.Server)]
		public static void MethodBankerDeposit(long sender, string item, int value)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				int stableHashCode = StringExtensionMethods.GetStableHashCode(item);
				if (!BankerTimeStamp.ContainsKey(hostName))
				{
					BankerTimeStamp[hostName] = new Dictionary<int, DateTime>();
				}
				BankerTimeStamp[hostName][stableHashCode] = DateTime.Now;
				global::Marketplace.DB.DB._context.AddBankItem(hostName, stableHashCode, value);
				SendBankerDataToClient(peer, sendif0: true);
				Market_Logger.Log(Market_Logger.LogType.Banker, $"Player User ID: {hostName} Deposit an item {item} with quantity: {value}.");
			}
		}

		[MarketplaceRPC("KGmarket BankerWithdraw", Market_Autoload.Type.Server)]
		private static void MethodBankerWithdraw(long sender, string item, int value)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				int stableHashCode = StringExtensionMethods.GetStableHashCode(item);
				if (!BankerTimeStamp.ContainsKey(hostName))
				{
					BankerTimeStamp[hostName] = new Dictionary<int, DateTime>();
				}
				BankerTimeStamp[hostName][stableHashCode] = DateTime.Now;
				int num = global::Marketplace.DB.DB._context.RemoveBankItem(hostName, stableHashCode, value);
				if (num > 0)
				{
					global::Marketplace.DB.DB.MarketSlot obj = new global::Marketplace.DB.DB.MarketSlot
					{
						Count = num,
						ItemPrefab = item,
						Quality = 1
					};
					string text = JSON.ToJSON(obj);
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket BuyItemAnswer", new object[1] { text });
					SendBankerDataToClient(peer, sendif0: true);
					Market_Logger.Log(Market_Logger.LogType.Banker, $"Player User ID: {hostName} Withdraw an item {item} with quantity: {num}");
				}
			}
		}

		[MarketplaceRPC("KGmarket BankerRemove", Market_Autoload.Type.Server)]
		private static void MethodBankerRemove(long sender, string item, int value)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				int stableHashCode = StringExtensionMethods.GetStableHashCode(item);
				global::Marketplace.DB.DB._context.RemoveBankItem(hostName, stableHashCode, value);
				SendBankerDataToClient(peer, sendif0: true);
				Market_Logger.Log(Market_Logger.LogType.Banker, $"Player User ID: {hostName} Removed (Paid with) an item {item} with quantity: {value}");
			}
		}
	}
	public static class Banker_UI
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class BankerUIFix
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsPanelVisible())
				{
					__result = true;
				}
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__PutAll;

			public static Action<GameObject> <1>__Destroy;
		}

		private static GameObject UI = null;

		private static GameObject ItemElement = null;

		private static Transform ContentTransform = null;

		private static readonly List<GameObject> CurrentObjects = new List<GameObject>();

		private static readonly List<InputField> CurrentValues = new List<InputField>();

		private static string CurrentProfile = "";

		private static Scrollbar MainBar = null;

		private static readonly List<ContentSizeFitter> AllFilters = new List<ContentSizeFitter>();

		private static Text NPCName = null;

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceBankerNewUI"));
			ItemElement = AssetStorage.asset.LoadAsset<GameObject>("BankerItem");
			ContentTransform = UI.transform.Find("Canvas/Trader/ItemList/ListPanel/Scroll View/Viewport/Content");
			Object.DontDestroyOnLoad((Object)(object)UI);
			MainBar = UI.GetComponentInChildren<Scrollbar>();
			AllFilters.AddRange(UI.GetComponentsInChildren<ContentSizeFitter>().ToList());
			NPCName = ((Component)UI.transform.Find("Canvas/Trader/Header/Text")).GetComponent<Text>();
			ButtonClickedEvent onClick = ((Component)UI.transform.Find("Canvas/Trader/Background/PutAll")).GetComponent<Button>().onClick;
			object obj = <>O.<0>__PutAll;
			if (obj == null)
			{
				UnityAction val = PutAll;
				<>O.<0>__PutAll = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			UI.SetActive(false);
			Localization.instance.Localize(ItemElement.transform);
			Localization.instance.Localize(UI.transform);
		}

		private static void PutAll()
		{
			if (string.IsNullOrEmpty(CurrentProfile) || !Banker_DataTypes.SyncedBankerProfiles.Value.ContainsKey(CurrentProfile))
			{
				return;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory)
			{
				if (item.m_stack > 0 && Object.op_Implicit((Object)(object)item.m_dropPrefab) && Banker_DataTypes.SyncedBankerProfiles.Value[CurrentProfile].Contains(StringExtensionMethods.GetStableHashCode(((Object)item.m_dropPrefab).name)) && item.m_quality <= 1)
				{
					if (dictionary.ContainsKey(((Object)item.m_dropPrefab).name))
					{
						dictionary[((Object)item.m_dropPrefab).name] += item.m_stack;
					}
					else
					{
						dictionary.Add(((Object)item.m_dropPrefab).name, item.m_stack);
					}
					item.m_stack = 0;
				}
			}
			foreach (KeyValuePair<string, int> item2 in dictionary)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket BankerDeposit", new object[2] { item2.Key, item2.Value });
			}
			((Humanoid)Player.m_localPlayer).m_inventory.m_inventory.RemoveAll((ItemData x) => x.m_stack <= 0);
			((Humanoid)Player.m_localPlayer).m_inventory.Changed();
		}

		private static void CreateElements(string profile)
		{
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			CurrentObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentObjects.Clear();
			CurrentValues.Clear();
			if (!Banker_DataTypes.SyncedBankerProfiles.Value.ContainsKey(profile))
			{
				return;
			}
			for (int i = 0; i < Banker_DataTypes.SyncedBankerProfiles.Value[profile].Count; i++)
			{
				int data = Banker_DataTypes.SyncedBankerProfiles.Value[profile][i];
				GameObject prefab = ZNetScene.instance.GetPrefab(data);
				ItemDrop val = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val == (Object)null)
				{
					break;
				}
				GameObject val2 = Object.Instantiate<GameObject>(ItemElement, ContentTransform);
				string text = Localization.instance.Localize(val.m_itemData.m_shared.m_name);
				int value;
				int num = (Banker_DataTypes.BankerClientData.TryGetValue(data, out value) ? value : 0);
				int id = i;
				((Component)val2.transform.Find("Icon/IconItem")).GetComponent<Image>().sprite = val.m_itemData.GetIcon();
				((Component)val2.transform.Find("Inventory")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_inventory: ") + Utils.CustomCountItems(((Object)val).name, 1);
				((Component)val2.transform.Find("ItemName")).GetComponent<Text>().text = text;
				((Component)val2.transform.Find("BankCount")).GetComponent<Text>().text = num.ToString();
				((UnityEvent<string>)(object)((Component)val2.transform.Find("Control/InputField")).GetComponent<InputField>().onValueChanged).AddListener((UnityAction<string>)delegate(string arg0)
				{
					ValueChange(id, arg0);
				});
				((UnityEvent)((Component)val2.transform.Find("Control/Add")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					ClickBUTTON(id, data, DEPOSIT: true);
				});
				((UnityEvent)((Component)val2.transform.Find("Control/Remove")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					ClickBUTTON(id, data, DEPOSIT: false);
				});
				CurrentObjects.Add(val2);
				CurrentValues.Add(((Component)val2.transform.Find("Control/InputField")).GetComponent<InputField>());
			}
			Canvas.ForceUpdateCanvases();
			AllFilters.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			AllFilters.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
			MainBar.value = 1f;
		}

		private static void ValueChange(int index, string data)
		{
			AssetStorage.AUsrc.PlayOneShot(AssetStorage.TypeClip, 0.7f);
			if (int.TryParse(data, out var result) && result < 0)
			{
				CurrentValues[index].text = "0";
			}
		}

		private static void ClickBUTTON(int index, int hash, bool DEPOSIT)
		{
			AssetStorage.AUsrc.Play();
			if (!int.TryParse(CurrentValues[index].text, out var result))
			{
				return;
			}
			CurrentValues[index].text = "";
			if (result <= 0)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(hash);
			string name = ((Object)prefab).name;
			if (DEPOSIT)
			{
				int num = Utils.CustomCountItems(name, 1);
				if (result > num)
				{
					result = num;
				}
				if (result <= 0)
				{
					return;
				}
				Utils.CustomRemoveItems(name, result, 1);
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket BankerDeposit", new object[2] { name, result });
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket BankerWithdraw", new object[2] { name, result });
			}
			CurrentValues[index].text = "";
		}

		public static void Hide()
		{
			UI.SetActive(false);
			CurrentObjects.ForEach((Action<GameObject>)Object.Destroy);
			CurrentObjects.Clear();
		}

		public static void Reload()
		{
			if (IsPanelVisible())
			{
				CreateElements(CurrentProfile);
			}
		}

		public static void Show(string profile, string _npcName)
		{
			if (Banker_DataTypes.SyncedBankerProfiles.Value.ContainsKey(profile))
			{
				CurrentProfile = profile;
				UI.SetActive(true);
				CreateElements(CurrentProfile);
				_npcName = Utils.RichTextFormatting(_npcName);
				NPCName.text = (string.IsNullOrEmpty(_npcName) ? Localization.instance.Localize("$mpasn_Banker") : _npcName);
			}
		}
	}
}
namespace Marketplace.Modules.Transmogrification
{
	public static class PlayerModelPreview
	{
		public class PreviewModelAngleController : MonoBehaviour, IDragHandler, IEventSystemHandler
		{
			public void OnDrag(PointerEventData eventData)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Invalid comparison between Unknown and I4
				//IL_0021: 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)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				if ((int)eventData.button == 0)
				{
					CurrentPreviewGO.transform.Rotate(new Vector3(0f, 1f, 0f), (0f - eventData.delta.x) / 2f, (Space)0);
				}
				if ((int)eventData.button == 1 && Object.op_Implicit((Object)(object)CurrentPreviewGO))
				{
					float y = CurrentPreviewGO.transform.position.y;
					float num = y + eventData.delta.y / 400f;
					num = Mathf.Clamp(num, OriginalYPos - 1f, OriginalYPos + 1f);
					Vector3 position = CurrentPreviewGO.transform.position;
					((Vector3)(ref position))..ctor(position.x, num, position.z);
					CurrentPreviewGO.transform.position = position;
				}
			}

			public void Update()
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				float axis = Input.GetAxis("Mouse ScrollWheel");
				if (IsVisible && axis != 0f)
				{
					bool flag = RectTransformUtility.RectangleContainsScreenPoint(CHECK, Vector2.op_Implicit(Input.mousePosition));
					if (Object.op_Implicit((Object)(object)CurrentPreviewGO) && flag)
					{
						float z = ((Component)renderCamera).transform.position.z;
						float num = z - axis * 100f;
						num = Mathf.Clamp(num, OriginalCameraZPos - 120f, OriginalCameraZPos);
						Vector3 position = ((Component)renderCamera).transform.position;
						((Vector3)(ref position))..ctor(position.x, position.y, num);
						((Component)renderCamera).transform.position = position;
					}
				}
			}
		}

		private enum Intensity
		{
			_025,
			_050,
			_1,
			_15,
			_2
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class Menu_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= IsVisible;
			}
		}

		private static readonly Camera renderCamera;

		private static readonly Light Light;

		private static readonly Vector3 SpawnPoint;

		private static readonly GameObject UI;

		private static readonly RectTransform CHECK;

		private static float OriginalYPos;

		private static float OriginalCameraZPos;

		private static GameObject CurrentPreviewGO;

		private static GameObject BehindWallRender;

		private static string CurrentWall;

		private static readonly int ChestTex;

		private static readonly int ChestBumpMap;

		private static readonly int ChestMetal;

		private static readonly int LegsTex;

		private static readonly int LegsBumpMap;

		private static readonly int LegsMetal;

		private static readonly int Wakeup;

		private static Intensity LightIntensity;

		private static bool IsVisible
		{
			get
			{
				if (Object.op_Implicit((Object)(object)CurrentPreviewGO))
				{
					return CurrentPreviewGO.activeSelf;
				}
				return false;
			}
		}

		static PlayerModelPreview()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			SpawnPoint = new Vector3(25000f, 25000f, 25000f);
			CurrentWall = "woodwall@grey";
			ChestTex = Shader.PropertyToID("_ChestTex");
			ChestBumpMap = Shader.PropertyToID("_ChestBumpMap");
			ChestMetal = Shader.PropertyToID("_ChestMetal");
			LegsTex = Shader.PropertyToID("_LegsTex");
			LegsBumpMap = Shader.PropertyToID("_LegsBumpMap");
			LegsMetal = Shader.PropertyToID("_LegsMetal");
			Wakeup = Animator.StringToHash("wakeup");
			LightIntensity = Intensity._2;
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplacePreviewUI"));
			((UnityEvent)((Component)UI.transform.Find("Canvas/Preview/Background/Close")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				AssetStorage.AUsrc.Play();
				StopPreview();
			});
			CHECK = ((Component)UI.transform.Find("Canvas/Preview/Background")).GetComponent<RectTransform>();
			((UnityEvent)((Component)UI.transform.Find("Canvas/Preview/Background/Light")).GetComponent<Button>().onClick).AddListener(new UnityAction(ChangeLight));
			((UnityEvent)((Component)UI.transform.Find("Canvas/Preview/Background/Wood")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				ResetWall("woodwall");
			});
			((UnityEvent)((Component)UI.transform.Find("Canvas/Preview/Background/Black")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				ResetWall("woodwall@black");
			});
			((UnityEvent)((Component)UI.transform.Find("Canvas/Preview/Background/Stone")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				ResetWall("woodwall@grey");
			});
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.AddComponent<PreviewModelAngleController>();
			UI.SetActive(false);
			renderCamera = new GameObject("Render Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
			renderCamera.backgroundColor = new Color(0f, 0f, 0f, 0f);
			renderCamera.clearFlags = (CameraClearFlags)2;
			((Component)renderCamera).transform.position = SpawnPoint;
			((Component)renderCamera).transform.rotation = Quaternion.Euler(0f, 180f, 0f);
			renderCamera.fieldOfView = 0.5f;
			renderCamera.farClipPlane = 100000f;
			renderCamera.targetTexture = new RenderTexture(2048, 2048, 32);
			Object.DontDestroyOnLoad((Object)(object)renderCamera);
			Light = new GameObject("Render Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
			((Component)Light).transform.position = SpawnPoint;
			((Component)Light).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
			Light.type = (LightType)2;
			Light.intensity = 2f;
			Light.range = 30f;
			Object.DontDestroyOnLoad((Object)(object)Light);
			((Component)renderCamera).gameObject.SetActive(false);
			((Component)Light).gameObject.SetActive(false);
			UI.GetComponentInChildren<RawImage>().texture = (Texture)(object)renderCamera.targetTexture;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		public static GameObject CreatePlayerModel(string item, ItemType itemType, Color c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected I4, but got Unknown
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Invalid comparison between Unknown and I4
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Invalid comparison between Unknown and I4
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Expected I4, but got Unknown
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Invalid comparison between Unknown and I4
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Invalid comparison between Unknown and I4
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(item));
			if (itemPrefab == null)
			{
				return null;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return null;
			}
			GameObject val = (GameObject)((itemType - 3) switch
			{
				0 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_rightItemInstance, 
				1 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_leftItemInstance, 
				2 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_leftItemInstance, 
				3 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_helmetItemInstance, 
				4 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_chestItemInstances?[0], 
				8 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_legItemInstances?[0], 
				11 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_rightItemInstance, 
				12 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_leftItemInstance, 
				14 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_shoulderItemInstances?[0], 
				15 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_utilityItemInstances?[0], 
				16 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_rightItemInstance, 
				19 => ((Humanoid)Player.m_localPlayer).m_visEquipment.m_leftItemInstance, 
				_ => null, 
			});
			if (Object.op_Implicit((Object)(object)val))
			{
				val.SetActive(false);
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)((Component)Player.m_localPlayer).GetComponentInChildren<Animator>()).gameObject, SpawnPoint, Quaternion.identity);
			SkinnedMeshRenderer componentInChildren = val2.GetComponentInChildren<SkinnedMeshRenderer>();
			if (Object.op_Implicit((Object)(object)val))
			{
				val.SetActive(true);
			}
			if ((int)itemType == 7)
			{
				((Renderer)componentInChildren).material.SetTexture(ChestTex, ((Humanoid)Player.m_localPlayer).m_visEquipment.m_emptyBodyTexture);
				((Renderer)componentInChildren).material.SetTexture(ChestBumpMap, (Texture)null);
				((Renderer)componentInChildren).material.SetTexture(ChestMetal, (Texture)null);
			}
			if ((int)itemType == 11)
			{
				((Renderer)componentInChildren).material.SetTexture(LegsTex, ((Humanoid)Player.m_localPlayer).m_visEquipment.m_emptyLegsTexture);
				((Renderer)componentInChildren).material.SetTexture(LegsBumpMap, (Texture)null);
				((Renderer)componentInChildren).material.SetTexture(LegsMetal, (Texture)null);
			}
			Animator component2 = val2.GetComponent<Animator>();
			Dictionary<ItemType, Transform> dictionary = new Dictionary<ItemType, Transform>
			{
				{
					(ItemType)3,
					Utils.FindChild(val2.transform, "RightHand_Attach", (IterativeSearchType)0)
				},
				{
					(ItemType)4,
					Utils.FindChild(val2.transform, "LeftHand_Attach", (IterativeSearchType)0)
				},
				{
					(ItemType)5,
					Utils.FindChild(val2.transform, "LeftHand_Attach", (IterativeSearchType)0)
				},
				{
					(ItemType)6,
					Utils.FindChild(val2.transform, "Helmet_attach", (IterativeSearchType)0)
				},
				{
					(ItemType)14,
					Utils.FindChild(val2.transform, "RightHand_Attach", (IterativeSearchType)0)
				},
				{
					(ItemType)15,
					Utils.FindChild(val2.transform, "RightHand_Attach", (IterativeSearchType)0)
				},
				{
					(ItemType)22,
					Utils.FindChild(val2.transform, "LeftHand_Attach", (IterativeSearchType)0)
				},
				{
					(ItemType)19,
					Utils.FindChild(val2.transform, "RightHand_Attach", (IterativeSearchType)0)
				}
			};
			Transform val3 = itemPrefab.transform.Find("attach");
			if (val3 != null)
			{
				Transform value;
				Transform val4 = (dictionary.TryGetValue(itemType, out value) ? value : dictionary[(ItemType)3]);
				GameObject val5 = Object.Instantiate<GameObject>(((Component)val3).gameObject, val4);
				val5.transform.localPosition = Vector3.zero;
				val5.transform.localRotation = Quaternion.identity;
				if (c != Color.white)
				{
					Utils.SetGOColors(val5, c);
				}
			}
			else
			{
				Transform val6 = itemPrefab.transform.Find("attach_skin");
				if (val6 != null)
				{
					Transform transform = val2.transform;
					GameObject val7 = Object.Instantiate<GameObject>(((Component)val6).gameObject, transform.position, transform.rotation);
					val7.SetActive(true);
					val7.GetComponentInChildren<SkinnedMeshRenderer>().rootBone = componentInChildren.rootBone;
					val7.GetComponentInChildren<SkinnedMeshRenderer>().bones = componentInChildren.bones;
					val7.transform.SetParent(val2.transform);
					CapsuleCollider[] array = val2.GetComponentsInChildren<CapsuleCollider>(false).ToArray();
					Cloth[] componentsInChildren = val7.GetComponentsInChildren<Cloth>();
					foreach (Cloth val8 in componentsInChildren)
					{
						if (array.Length != 0)
						{
							if (val8.capsuleColliders.Length != 0)
							{
								List<CapsuleCollider> list = new List<CapsuleCollider>(array);
								list.AddRange(val8.capsuleColliders);
								val8.capsuleColliders = list.ToArray();
							}
							else
							{
								val8.capsuleColliders = array;
							}
						}
					}
					if (c != Color.white)
					{
						Utils.SetGOColors(val7, c);
					}
					if (Object.op_Implicit((Object)(object)component.m_itemData.m_shared.m_armorMaterial) && (int)itemType == 7)
					{
						((Renderer)componentInChildren).material.SetTexture(ChestTex, component.m_itemData.m_shared.m_armorMaterial.GetTexture(ChestTex));
						((Renderer)componentInChildren).material.SetTexture(ChestBumpMap, component.m_itemData.m_shared.m_armorMaterial.GetTexture(ChestBumpMap));
						((Renderer)componentInChildren).material.SetTexture(ChestMetal, component.m_itemData.m_shared.m_armorMaterial.GetTexture(ChestMetal));
					}
					if (Object.op_Implicit((Object)(object)component.m_itemData.m_shared.m_armorMaterial) && (int)itemType == 11)
					{
						((Renderer)componentInChildren).material.SetTexture(LegsTex, component.m_itemData.m_shared.m_armorMaterial.GetTexture(LegsTex));
						((Renderer)componentInChildren).material.SetTexture(LegsBumpMap, component.m_itemData.m_shared.m_armorMaterial.GetTexture(LegsBumpMap));
						((Renderer)componentInChildren).material.SetTexture(LegsMetal, component.m_itemData.m_shared.m_armorMaterial.GetTexture(LegsMetal));
					}
				}
			}
			component2.SetBool(Wakeup, false);
			component2.cullingMode = (AnimatorCullingMode)0;
			if (component.m_itemData.IsWeapon())
			{
				component2.SetFloat(Humanoid.s_statef, (float)component.m_itemData.m_shared.m_animationState);
				component2.SetInteger(Humanoid.s_statei, (int)component.m_itemData.m_shared.m_animationState);
			}
			else
			{
				component2.SetFloat(Humanoid.s_statef, ((Character)Player.m_localPlayer).m_animator.GetFloat(Humanoid.s_statef));
				component2.SetInteger(Humanoid.s_statei, ((Character)Player.m_localPlayer).m_animator.GetInteger(Humanoid.s_statei));
			}
			component2.Update(0f);
			component2.speed = 0f;
			return val2;
		}

		public static void SetAsCurrent(GameObject go)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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_015b: 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_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			StopPreview();
			if (!Object.op_Implicit((Object)(object)go))
			{
				return;
			}
			CurrentPreviewGO = go;
			CurrentPreviewGO.transform.position = Vector3.zero;
			CurrentPreviewGO.transform.rotation = Quaternion.Euler(2f, 0f, 0f);
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(1000f, 1000f, 1000f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(-1000f, -1000f, -1000f);
			Renderer[] componentsInChildren = CurrentPreviewGO.GetComponentsInChildren<Renderer>();
			foreach (Renderer val3 in componentsInChildren)
			{
				if (!(val3 is ParticleSystemRenderer))
				{
					Vector3 val4 = val;
					Bounds bounds = val3.bounds;
					val = Vector3.Min(val4, ((Bounds)(ref bounds)).min);
					Vector3 val5 = val2;
					bounds = val3.bounds;
					val2 = Vector3.Max(val5, ((Bounds)(ref bounds)).max);
				}
			}
			CurrentPreviewGO.transform.position = SpawnPoint - (val + val2) / 2f;
			OriginalYPos = CurrentPreviewGO.transform.position.y;
			ResetWall(CurrentWall);
			((Component)Light).transform.position = SpawnPoint + new Vector3(0f, 2f, 2f);
			Vector3 val6 = default(Vector3);
			((Vector3)(ref val6))..ctor(Mathf.Abs(val.x) + Mathf.Abs(val2.x), Mathf.Abs(val.y) + Mathf.Abs(val2.y), Mathf.Abs(val.z) + Mathf.Abs(val2.z));
			float num = Mathf.Max(val6.x, val6.y) + 0.1f;
			float num2 = num / Mathf.Tan(renderCamera.fieldOfView * ((float)Math.PI / 180f)) * 0.9f;
			((Component)renderCamera).transform.position = SpawnPoint + new Vector3(0f, 0.05f, num2);
			OriginalCameraZPos = ((Component)renderCamera).transform.position.z;
			UI.SetActive(true);
			((Component)renderCamera).gameObject.SetActive(true);
			((Component)Light).gameObject.SetActive(true);
		}

		public static string MakeScreenshot(GameObject go, int texSize)
		{
			//IL_0015: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			StopPreview();
			if (!Object.op_Implicit((Object)(object)go))
			{
				return null;
			}
			Vector3 position = go.transform.position;
			Quaternion rotation = go.transform.rotation;
			go.transform.position = Vector3.zero;
			go.transform.rotation = Quaternion.Euler(2f, -24f, 0f);
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(1000f, 1000f, 1000f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(-1000f, -1000f, -1000f);
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>();
			foreach (Renderer val3 in componentsInChildren)
			{
				if (!(val3 is ParticleSystemRenderer))
				{
					Vector3 val4 = val;
					Bounds bounds = val3.bounds;
					val = Vector3.Min(val4, ((Bounds)(ref bounds)).min);
					Vector3 val5 = val2;
					bounds = val3.bounds;
					val2 = Vector3.Max(val5, ((Bounds)(ref bounds)).max);
				}
			}
			go.transform.position = SpawnPoint - (val + val2) / 2f;
			((Component)Light).transform.position = SpawnPoint + new Vector3(0f, 2f, 2f);
			float intensity = Light.intensity;
			Light.intensity = 2f;
			Vector3 val6 = default(Vector3);
			((Vector3)(ref val6))..ctor(Mathf.Abs(val.x) + Mathf.Abs(val2.x), Mathf.Abs(val.y) + Mathf.Abs(val2.y), Mathf.Abs(val.z) + Mathf.Abs(val2.z));
			float num = Mathf.Max(val6.x, val6.y);
			float num2 = num / Mathf.Tan(renderCamera.fieldOfView * ((float)Math.PI / 180f));
			((Component)renderCamera).transform.position = SpawnPoint + new Vector3(0f, 0f, num2);
			((Component)renderCamera).gameObject.SetActive(true);
			((Component)Light).gameObject.SetActive(true);
			Texture2D val7 = new Texture2D(2048, 2048, (TextureFormat)4, false);
			RenderTexture.active = renderCamera.targetTexture;
			renderCamera.Render();
			val7.ReadPixels(new Rect(0f, 0f, 2048f, 2048f), 0, 0);
			val7.Apply();
			RenderTexture.active = null;
			go.transform.position = position;
			go.transform.rotation = rotation;
			Light.intensity = intensity;
			StopPreview();
			byte[] inArray = ImageConversion.EncodeToPNG(val7.CustomSize(texSize, texSize));
			return Convert.ToBase64String(inArray);
		}

		private static void StopPreview()
		{
			if (Object.op_Implicit((Object)(object)CurrentPreviewGO))
			{
				Object.Destroy((Object)(object)CurrentPreviewGO);
				CurrentPreviewGO = null;
			}
			if (Object.op_Implicit((Object)(object)BehindWallRender))
			{
				Object.Destroy((Object)(object)BehindWallRender);
				BehindWallRender = null;
			}
			((Component)renderCamera).gameObject.SetActive(false);
			((Component)Light).gameObject.SetActive(false);
			UI.SetActive(false);
		}

		private static void ResetWall(string newWall)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			if (Object.op_Implicit((Object)(object)BehindWallRender))
			{
				Object.Destroy((Object)(object)BehindWallRender);
			}
			CurrentWall = newWall;
			bool flag = newWall.Contains("@grey");
			bool flag2 = newWall.Contains("@black");
			string text = newWall.Replace("@grey", "").Replace("@black", "");
			GameObject prefab = ZNetScene.instance.GetPrefab(text);
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			Vector3 localScale = default(Vector3);
			((Vector3)(ref localScale))..ctor(1.3f, 1.3f, 0.2f);
			Transform val = prefab.transform.Find("New");
			if (Object.op_Implicit((Object)(object)val))
			{
				Vector3 position = CurrentPreviewGO.transform.position;
				position.y = OriginalYPos;
				BehindWallRender = Object.Instantiate<GameObject>(((Component)val).gameObject, position, Quaternion.identity);
				BehindWallRender.transform.localScale = localScale;
				Vector3 val2 = BehindWallRender.transform.position + Vector3.up;
				((Vector3)(ref val2))..ctor(val2.x, val2.y, val2.z - 2f);
				BehindWallRender.transform.position = val2;
				if (flag)
				{
					BehindWallRender.GetComponentInChildren<Renderer>().material.color = Color.black;
				}
				if (flag2)
				{
					BehindWallRender.GetComponentInChildren<Renderer>().material.shader = Transmogrification_UI.SPEC_SHADER;
					BehindWallRender.GetComponentInChildren<Renderer>().material.color = Color.black;
					BehindWallRender.GetComponentInChildren<Renderer>().material.SetColor("_SpecColor", Color.black);
				}
			}
		}

		private static void ChangeLight()
		{
			AssetStorage.AUsrc.Play();
			LightIntensity = (Intensity)((int)(LightIntensity + 1) % 5);
			switch (LightIntensity)
			{
			case Intensity._025:
				Light.intensity = 0.25f;
				break;
			case Intensity._050:
				Light.intensity = 0.5f;
				break;
			case Intensity._1:
				Light.intensity = 1f;
				break;
			case Intensity._15:
				Light.intensity = 1.5f;
				break;
			case Intensity._2:
				Light.intensity = 2f;
				break;
			}
		}

		private static void Update(float _)
		{
			if (Input.GetKeyDown((KeyCode)27) && IsVisible)
			{
				StopPreview();
			}
		}
	}
	public static class Transmogrification_DataTypes
	{
		public class TransmogItem_Data : ISerializableParameter
		{
			public string Prefab;

			public string Price_Prefab;

			public int Price_Amount;

			public bool IgnoreCategory;

			private string LocalizedName;

			private string LocalizedPrice;

			private Sprite Icon;

			private Sprite PriceIcon;

			public string GetLocalizedName()
			{
				return LocalizedName;
			}

			public string GetLocalizedPrice()
			{
				return LocalizedPrice;
			}

			public Sprite GetIcon()
			{
				return Icon;
			}

			public Sprite GetPriceIcon()
			{
				return PriceIcon;
			}

			public void SetLocalizedName(string name)
			{
				LocalizedName = name;
			}

			public void SetLocalizedPrice(string price)
			{
				LocalizedPrice = price;
			}

			public void SetIcon(Sprite icon)
			{
				Icon = icon;
			}

			public void SetPriceIcon(Sprite icon)
			{
				PriceIcon = icon;
			}

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(Prefab ?? "");
				pkg.Write(Price_Prefab ?? "");
				pkg.Write(Price_Amount);
				pkg.Write(IgnoreCategory);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Prefab = pkg.ReadString();
				Price_Prefab = pkg.ReadString();
				Price_Amount = pkg.ReadInt();
				IgnoreCategory = pkg.ReadBool();
			}
		}

		public class TransmogItem_ComponentV2 : ItemData
		{
			[SerializeField]
			public string ReplacedPrefab;

			[SerializeField]
			public string ItemColor;
		}

		internal static readonly CustomSyncedValue<Dictionary<string, List<TransmogItem_Data>>> SyncedTransmogData = new CustomSyncedValue<Dictionary<string, List<TransmogItem_Data>>>(Marketplace.configSync, "transmogData", new Dictionary<string, List<TransmogItem_Data>>());
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Transmogrification_Main_Client
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			private static void Postfix()
			{
				InitTransmogData();
			}
		}

		private class TempItem
		{
			public string ReplacedPrefab;

			public string ItemColor;

			public int Variant;

			public static implicit operator bool(TempItem item)
			{
				return item != null;
			}
		}

		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
		[ClientOnlyPatch]
		private static class Humanoid_SetupVisEquipment_Patch_TRANSMOG
		{
			private static void OneArg_SetItem(Player p, ItemData item, string colorID, Action<string> invoke)
			{
				TempItem tempItem = item.T_Data();
				if ((bool)tempItem)
				{
					invoke(tempItem.ReplacedPrefab);
				}
			}

			private static void OneArg_SetItem_ZNS(Player p, ItemData item, string colorID, Action<string> invoke)
			{
				TempItem tempItem = item.T_Data();
				if ((bool)tempItem)
				{
					invoke(tempItem.ReplacedPrefab);
					((Character)p).m_nview.m_zdo.Set(colorID, tempItem.ItemColor);
				}
				else
				{
					((Character)p).m_nview.m_zdo.Set(colorID, "");
				}
			}

			private static void TwoArg_SetItem(Player p, ItemData item, string colorID, Action<string, int> invoke)
			{
				TempItem tempItem = item.T_Data();
				if ((bool)tempItem)
				{
					invoke(tempItem.ReplacedPrefab, tempItem.Variant);
				}
			}

			private static void TwoArg_SetItem_ZNS(Player p, ItemData item, string colorID, Action<string, int> invoke)
			{
				TempItem tempItem = item.T_Data();
				if ((bool)tempItem)
				{
					invoke(tempItem.ReplacedPrefab, tempItem.Variant);
					((Character)p).m_nview.m_zdo.Set(colorID, tempItem.ItemColor);
				}
				else
				{
					((Character)p).m_nview.m_zdo.Set(colorID, "");
				}
			}

			[HarmonyPriority(-6000)]
			public static void Postfix(Humanoid __instance, VisEquipment visEq, bool isRagdoll)
			{
				Player val = (Player)(Object.op_Implicit((Object)(object)ZNetScene.instance) ? ((object)Player.m_localPlayer) : ((object)((__instance is Player) ? __instance : null)));
				bool flag = Object.op_Implicit((Object)(object)ZNetScene.instance);
				if (!((Object)(object)__instance == (Object)(object)val))
				{
					return;
				}
				if (!isRagdoll)
				{
					if (flag)
					{
						TwoArg_SetItem_ZNS(val, ((Humanoid)val).m_leftItem, "MPASN_TMGleftitemColor", (Action<string, int>)visEq.SetLeftItem);
						OneArg_SetItem_ZNS(val, ((Humanoid)val).m_rightItem, "MPASN_TMGrightitemColor", (Action<string>)visEq.SetRightItem);
						TwoArg_SetItem_ZNS(val, ((Humanoid)val).m_hiddenLeftItem, "MPASN_TMGleftbackitemColor", (Action<string, int>)visEq.SetLeftBackItem);
						OneArg_SetItem_ZNS(val, ((Humanoid)val).m_hiddenRightItem, "MPASN_TMGrightbackitemColor", (Action<string>)visEq.SetRightBackItem);
					}
					else
					{
						TwoArg_SetItem(val, ((Humanoid)val).m_leftItem, "MPASN_TMGleftitemColor", (Action<string, int>)visEq.SetLeftItem);
						OneArg_SetItem(val, ((Humanoid)val).m_rightItem, "MPASN_TMGrightitemColor", (Action<string>)visEq.SetRightItem);
						TwoArg_SetItem(val, ((Humanoid)val).m_hiddenLeftItem, "MPASN_TMGleftbackitemColor", (Action<string, int>)visEq.SetLeftBackItem);
						OneArg_SetItem(val, ((Humanoid)val).m_hiddenRightItem, "MPASN_TMGrightbackitemColor", (Action<string>)visEq.SetRightBackItem);
					}
				}
				if (flag)
				{
					OneArg_SetItem_ZNS(val, ((Humanoid)val).m_chestItem, "MPASN_TMGchestitemColor", (Action<string>)visEq.SetChestItem);
					OneArg_SetItem_ZNS(val, ((Humanoid)val).m_legItem, "MPASN_TMGlegitemColor", (Action<string>)visEq.SetLegItem);
					OneArg_SetItem_ZNS(val, ((Humanoid)val).m_helmetItem, "MPASN_TMGhelmetitemColor", (Action<string>)visEq.SetHelmetItem);
					TwoArg_SetItem_ZNS(val, ((Humanoid)val).m_shoulderItem, "MPASN_TMGshoulderitemColor", (Action<string, int>)visEq.SetShoulderItem);
				}
				else
				{
					OneArg_SetItem(val, ((Humanoid)val).m_chestItem, "MPASN_TMGchestitemColor", (Action<string>)visEq.SetChestItem);
					OneArg_SetItem(val, ((Humanoid)val).m_legItem, "MPASN_TMGlegitemColor", (Action<string>)visEq.SetLegItem);
					OneArg_SetItem(val, ((Humanoid)val).m_helmetItem, "MPASN_TMGhelmetitemColor", (Action<string>)visEq.SetHelmetItem);
					TwoArg_SetItem(val, ((Humanoid)val).m_shoulderItem, "MPASN_TMGshoulderitemColor", (Action<string, int>)visEq.SetShoulderItem);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "Awake")]
		[ClientOnlyPatch]
		public static class InventoryGrid_Awake_Patch
		{
			private static readonly HashSet<GameObject> firsttime = new HashSet<GameObject>();

			public static void Postfix(InventoryGrid __instance)
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)__instance.m_elementPrefab) && !firsttime.Contains(__instance.m_elementPrefab))
				{
					firsttime.Add(__instance.m_elementPrefab);
					Transform transform = __instance.m_elementPrefab.transform;
					GameObject val = Object.Instantiate<GameObject>(Transmog_UI_Icon_Part);
					val.transform.SetParent(transform);
					((Object)val).name = "MPASN_Transmog";
					val.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, -26f);
					val.gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		[ClientOnlyPatch]
		private static class Hud_Awake_Patch
		{
			public static HotkeyBar barRef;

			[UsedImplicitly]
			private static void Postfix(Hud __instance)
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				Transform obj = __instance.m_rootObject.transform.Find("HotKeyBar");
				HotkeyBar val = (barRef = ((obj != null) ? ((Component)obj).GetComponent<HotkeyBar>() : null));
				if (Object.op_Implicit((Object)(object)val))
				{
					Transform transform = val.m_elementPrefab.transform;
					GameObject val2 = Object.Instantiate<GameObject>(Transmog_UI_Icon_Part);
					val2.transform.SetParent(transform);
					((Object)val2).name = "MPASN_Transmog";
					val2.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, -26f);
					val2.gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
		[ClientOnlyPatch]
		private static class HotkeyBar_UpdateIcons_Patch
		{
			private static bool FirstInit;

			public static void Postfix(HotkeyBar __instance)
			{
				if ((Object)(object)__instance != (Object)(object)Hud_Awake_Patch.barRef || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || ((Character)Player.m_localPlayer).IsDead())
				{
					return;
				}
				foreach (ElementData item in __instance.m_elements.Where((ElementData element) => !element.m_used))
				{
					((Component)item.m_go.transform.Find("MPASN_Transmog")).gameObject.SetActive(false);
				}
				for (int i = 0; i < __instance.m_items.Count; i++)
				{
					ItemData val = __instance.m_items[i];
					ElementData val2 = __instance.m_elements[val.m_gridPos.x];
					((Component)val2.m_go.transform.Find("MPASN_Transmog")).gameObject.SetActive(val.HasTransmog());
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		[ClientOnlyPatch]
		private static class InventoryGrid_UpdateGui_Patch
		{
			public static void Postfix(InventoryGrid __instance)
			{
				int width = __instance.m_inventory.GetWidth();
				foreach (Element element2 in __instance.m_elements)
				{
					if (!element2.m_used)
					{
						Transform obj = element2.m_go.transform.Find("MPASN_Transmog");
						if (obj != null)
						{
							((Component)obj).gameObject.SetActive(false);
						}
					}
				}
				foreach (ItemData allItem in __instance.m_inventory.GetAllItems())
				{
					Element element = __instance.GetElement(allItem.m_gridPos.x, allItem.m_gridPos.y, width);
					Transform obj2 = element.m_go.transform.Find("MPASN_Transmog");
					if (obj2 != null)
					{
						((Component)obj2).gameObject.SetActive(allItem.HasTransmog());
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		[ClientOnlyPatch]
		private static class ItemDrop_ItemData_Tooltip__Patch_TRANSMOG
		{
			public static void Postfix(ItemData item, ref string __result)
			{
				if (item.HasTransmog())
				{
					__result += AddTooltipTransmog(item);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetRightHandEquipped")]
		[ClientOnlyPatch]
		private static class MockRight
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentRightItemHash != hash)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				if (Object.op_Implicit((Object)(object)__instance.m_rightItemInstance))
				{
					string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGrightitemColor", "");
					Color val = default(Color);
					if (!string.IsNullOrEmpty(@string) && ColorUtility.TryParseHtmlString(@string, ref val) && val != Color.white)
					{
						Utils.SetGOColors(__instance.m_rightItemInstance, val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLeftHandEquipped")]
		[ClientOnlyPatch]
		private static class MockLeft
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentLeftItemHash != hash)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				if (Object.op_Implicit((Object)(object)__instance.m_leftItemInstance))
				{
					string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGleftitemColor", "");
					Color val = default(Color);
					if (!string.IsNullOrEmpty(@string) && ColorUtility.TryParseHtmlString(@string, ref val) && val != Color.white)
					{
						Utils.SetGOColors(__instance.m_leftItemInstance, val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
		[ClientOnlyPatch]
		private static class MockHelmet
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentHelmetItemHash != hash)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				if (Object.op_Implicit((Object)(object)__instance.m_helmetItemInstance))
				{
					string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGhelmetitemColor", "");
					Color val = default(Color);
					if (!string.IsNullOrEmpty(@string) && ColorUtility.TryParseHtmlString(@string, ref val) && val != Color.white)
					{
						Utils.SetGOColors(__instance.m_helmetItemInstance, val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[ClientOnlyPatch]
		private static class MockCape
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentShoulderItemHash != hash)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				List<GameObject> shoulderItemInstances = __instance.m_shoulderItemInstances;
				if (shoulderItemInstances == null || shoulderItemInstances.Count <= 0)
				{
					return;
				}
				string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGshoulderitemColor", "");
				Color val = default(Color);
				if (string.IsNullOrEmpty(@string) || !ColorUtility.TryParseHtmlString(@string, ref val) || !(val != Color.white))
				{
					return;
				}
				foreach (GameObject shoulderItemInstance in __instance.m_shoulderItemInstances)
				{
					Utils.SetGOColors(shoulderItemInstance, val);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
		[ClientOnlyPatch]
		private static class MockLegs
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentLegItemHash != hash)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				List<GameObject> legItemInstances = __instance.m_legItemInstances;
				if (legItemInstances == null || legItemInstances.Count <= 0)
				{
					return;
				}
				string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGlegitemColor", "");
				Color val = default(Color);
				if (string.IsNullOrEmpty(@string) || !ColorUtility.TryParseHtmlString(@string, ref val) || !(val != Color.white))
				{
					return;
				}
				foreach (GameObject legItemInstance in __instance.m_legItemInstances)
				{
					Utils.SetGOColors(legItemInstance, val);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetBackEquipped")]
		[ClientOnlyPatch]
		private static class MockBackItems
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int leftItem, int rightItem, int leftVariant)
			{
				if (__instance.m_currentLeftBackItemHash != leftItem || __instance.m_currentRightBackItemHash != rightItem || __instance.m_currentLeftBackItemVariant != leftVariant)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				if (Object.op_Implicit((Object)(object)__instance.m_leftBackItemInstance))
				{
					string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGleftbackitemColor", "");
					Color val = default(Color);
					if (!string.IsNullOrEmpty(@string) && ColorUtility.TryParseHtmlString(@string, ref val) && val != Color.white)
					{
						Utils.SetGOColors(__instance.m_leftBackItemInstance, val);
					}
				}
				if (Object.op_Implicit((Object)(object)__instance.m_rightBackItemInstance))
				{
					string string2 = __instance.m_nview.m_zdo.GetString("MPASN_TMGrightbackitemColor", "");
					Color val2 = default(Color);
					if (!string.IsNullOrEmpty(string2) && ColorUtility.TryParseHtmlString(string2, ref val2) && val2 != Color.white)
					{
						Utils.SetGOColors(__instance.m_rightBackItemInstance, val2);
					}
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[ClientOnlyPatch]
		private static class MockChest
		{
			private static bool Transfer;

			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentChestItemHash != hash)
				{
					Transfer = true;
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				if (!Transfer || !Object.op_Implicit((Object)(object)__instance.m_nview) || __instance.m_nview.m_zdo == null)
				{
					return;
				}
				Transfer = false;
				List<GameObject> chestItemInstances = __instance.m_chestItemInstances;
				if (chestItemInstances == null || chestItemInstances.Count <= 0)
				{
					return;
				}
				string @string = __instance.m_nview.m_zdo.GetString("MPASN_TMGchestitemColor", "");
				Color val = default(Color);
				if (string.IsNullOrEmpty(@string) || !ColorUtility.TryParseHtmlString(@string, ref val) || !(val != Color.white))
				{
					return;
				}
				foreach (GameObject chestItemInstance in __instance.m_chestItemInstances)
				{
					Utils.SetGOColors(chestItemInstance, val);
				}
			}
		}

		private static GameObject Transmog_UI_Icon_Part;

		public static readonly Dictionary<string, Dictionary<ItemType, List<Transmogrification_DataTypes.TransmogItem_Data>>> FilteredTransmogData = new Dictionary<string, Dictionary<ItemType, List<Transmogrification_DataTypes.TransmogItem_Data>>>();

		private static void OnInit()
		{
			Transmogrification_UI.Init();
			Transmog_UI_Icon_Part = AssetStorage.asset.LoadAsset<GameObject>("TransmogUI_Part");
			Transmogrification_DataTypes.SyncedTransmogData.ValueChanged += InitTransmogData;
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Transmogrification_UI.IsVisble())
			{
				Transmogrification_UI.Hide();
				Menu.instance.OnClose();
			}
		}

		public static void InitTransmogData()
		{
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			FilteredTransmogData.Clear();
			foreach (KeyValuePair<string, List<Transmogrification_DataTypes.TransmogItem_Data>> item in Transmogrification_DataTypes.SyncedTransmogData.Value)
			{
				if (!FilteredTransmogData.ContainsKey(item.Key))
				{
					FilteredTransmogData.Add(item.Key, new Dictionary<ItemType, List<Transmogrification_DataTypes.TransmogItem_Data>>());
				}
				foreach (Transmogrification_DataTypes.TransmogItem_Data item2 in item.Value)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(item2.Prefab);
					GameObject prefab2 = ZNetScene.instance.GetPrefab(item2.Price_Prefab);
					if (!Object.op_Implicit((Object)(object)prefab) || !Object.op_Implicit((Object)(object)prefab2))
					{
						continue;
					}
					ItemData itemData = prefab.GetComponent<ItemDrop>().m_itemData;
					item2.SetIcon(itemData.GetIcon());
					string localizedName = Localization.instance.Localize(itemData.m_shared.m_name);
					item2.SetLocalizedName(localizedName);
					item2.SetLocalizedPrice(Localization.instance.Localize("$mpasn_transmog_price: <color=#00ff00>") + Localization.instance.Localize(prefab2.GetComponent<ItemDrop>().m_itemData.m_shared.m_name) + "</color>");
					item2.SetPriceIcon(prefab2.GetComponent<ItemDrop>().m_itemData.m_shared.m_icons[0]);
					if (item2.IgnoreCategory)
					{
						if (FilteredTransmogData[item.Key].ContainsKey((ItemType)999))
						{
							FilteredTransmogData[item.Key][(ItemType)999].Add(item2);
							continue;
						}
						FilteredTransmogData[item.Key].Add((ItemType)999, new List<Transmogrification_DataTypes.TransmogItem_Data>(1) { item2 });
					}
					else if (FilteredTransmogData[item.Key].ContainsKey(itemData.m_shared.m_itemType))
					{
						FilteredTransmogData[item.Key][itemData.m_shared.m_itemType].Add(item2);
					}
					else
					{
						FilteredTransmogData[item.Key].Add(itemData.m_shared.m_itemType, new List<Transmogrification_DataTypes.TransmogItem_Data>(1) { item2 });
					}
				}
			}
			Transmogrification_UI.Reload();
		}

		private static string AddTooltipTransmog(ItemData item)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			TempItem tempItem = item.T_Data();
			string text = "";
			if (!string.IsNullOrEmpty(tempItem.ReplacedPrefab))
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(tempItem.ReplacedPrefab);
				text = ((prefab == null) ? null : prefab.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_name) ?? "";
			}
			string text2 = Localization.instance.Localize("\n<color=#FF00FF>$mpasn_transmog_transmogrifiedinfo: <color=#00FFFF>" + text + "</color></color>");
			Color val = default(Color);
			if (!string.IsNullOrEmpty(tempItem.ItemColor) && ColorUtility.TryParseHtmlString(tempItem.ItemColor, ref val))
			{
				text2 = text2 + "\n<color=#FF00FF>Color: <color=#" + ColorUtility.ToHtmlStringRGB(val) + ">" + tempItem.ItemColor + "</color></color>";
			}
			return text2;
		}

		public static bool HasTransmog(this ItemData item)
		{
			return item?.Data().Get<Transmogrification_DataTypes.TransmogItem_ComponentV2>() != null;
		}

		private static TempItem T_Data(this ItemData item)
		{
			if (item == null)
			{
				return null;
			}
			Transmogrification_DataTypes.TransmogItem_ComponentV2 transmogItem_ComponentV = item.Data().Get<Transmogrification_DataTypes.TransmogItem_ComponentV2>();
			if (transmogItem_ComponentV != null)
			{
				return new TempItem
				{
					ReplacedPrefab = (string.IsNullOrEmpty(transmogItem_ComponentV.ReplacedPrefab) ? ((Object)item.m_dropPrefab).name : transmogItem_ComponentV.ReplacedPrefab),
					ItemColor = (transmogItem_ComponentV.ItemColor ?? ""),
					Variant = item.m_variant
				};
			}
			return null;
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "TM" }, new string[] { "OnTransmogrificationProfileChanged" })]
	public static class Transmogrification_Main_Server
	{
		private static void OnInit()
		{
			ReadTransmogrificationProfiles();
		}

		private static void OnTransmogrificationProfileChanged()
		{
			ReadTransmogrificationProfiles();
			Utils.print("Transmogrification profiles changed, sending to clients");
		}

		private static void ProcessTransmogrificationProfiles(IReadOnlyList<string> profiles)
		{
			string key = "default";
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					key = profiles[i].Replace("[", "").Replace("]", "").Replace(" ", "")
						.ToLower();
					if (!Transmogrification_DataTypes.SyncedTransmogData.Value.ContainsKey(key))
					{
						Transmogrification_DataTypes.SyncedTransmogData.Value.Add(key, new List<Transmogrification_DataTypes.TransmogItem_Data>());
					}
					continue;
				}
				string[] array = profiles[i].Replace(" ", "").Split(new char[1] { ',' });
				if (array.Length >= 4)
				{
					try
					{
						string prefab = array[0];
						string price_Prefab = array[1];
						int price_Amount = int.Parse(array[2]);
						bool ignoreCategory = bool.Parse(array[3]);
						Transmogrification_DataTypes.SyncedTransmogData.Value[key].Add(new Transmogrification_DataTypes.TransmogItem_Data
						{
							Prefab = prefab,
							Price_Prefab = price_Prefab,
							Price_Amount = price_Amount,
							IgnoreCategory = ignoreCategory
						});
					}
					catch (Exception arg)
					{
						Utils.print($"Error while parsing line {i + 1} in TransmogConfig: {arg}", ConsoleColor.Red);
					}
				}
			}
		}

		private static void ReadTransmogrificationProfiles()
		{
			Transmogrification_DataTypes.SyncedTransmogData.Value.Clear();
			string transmogrificationFolder = Market_Paths.TransmogrificationFolder;
			string[] files = Directory.GetFiles(transmogrificationFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string path in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(path).ToList();
				ProcessTransmogrificationProfiles(profiles);
			}
			Transmogrification_DataTypes.SyncedTransmogData.Update();
		}
	}
	public static class Transmogrification_UI
	{
		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class visiblePatch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (IsVisble())
				{
					__result = true;
				}
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__TransformReverse;
		}

		private static GameObject UI;

		private static GameObject Inventory_Element;

		private static Transform Inventory_Content;

		private static GameObject Category_Element;

		private static Transform Category_Content;

		private static GameObject Transmog_Element;

		private static ItemData CurrentChoosenItem;

		private static Transform ChoosenItem_Transform;

		private static GameObject ClickEffect;

		private static GameObject ClickEffect2;

		private static GameObject ClickEffectReverse;

		private static string CurrentProfile;

		public static Shader SPEC_SHADER;

		private static readonly List<ContentSizeFitter> AllFillers = new List<ContentSizeFitter>();

		private static Scrollbar MainBar;

		private static Scrollbar SubBar;

		private static readonly Dictionary<ItemType, Color> TypeColors = new Dictionary<ItemType, Color>
		{
			{
				(ItemType)999,
				Color.cyan
			},
			{
				(ItemType)3,
				Color.yellow
			},
			{
				(ItemType)14,
				new Color(1f, 0.56f, 0.03f)
			},
			{
				(ItemType)22,
				new Color(1f, 0.46f, 0.23f)
			},
			{
				(ItemType)4,
				Color.green
			},
			{
				(ItemType)19,
				new Color(1f, 0.33f, 0.42f)
			},
			{
				(ItemType)5,
				Color.magenta
			},
			{
				(ItemType)7,
				Color.blue
			},
			{
				(ItemType)6,
				new Color(0.53f, 0.66f, 1f)
			},
			{
				(ItemType)11,
				new Color(0.36f, 0.05f, 1f)
			},
			{
				(ItemType)17,
				new Color(0.74f, 0.53f, 1f)
			},
			{
				(ItemType)18,
				Color.white
			}
		};

		private static readonly HashSet<ItemType> AvaliableTypes = new HashSet<ItemType>
		{
			(ItemType)3,
			(ItemType)14,
			(ItemType)22,
			(ItemType)4,
			(ItemType)19,
			(ItemType)5,
			(ItemType)7,
			(ItemType)6,
			(ItemType)11,
			(ItemType)17,
			(ItemType)18
		};

		private static int IndexOfChoosenItem;

		public static bool IsVisble()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceTransmogUI"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.SetActive(false);
			SPEC_SHADER = ((Graphic)((Component)UI.transform.Find("Canvas/ShaderHolder")).GetComponent<Image>()).material.shader;
			MainBar = ((Component)UI.transform.Find("Canvas/SelectItemTab/ItemList/ListPanel/Scroll View/Scrollbar")).GetComponent<Scrollbar>();
			SubBar = ((Component)UI.transform.Find("Canvas/SelectTransmogTab/ItemList/ListPanel/Scroll View/Scrollbar")).GetComponent<Scrollbar>();
			AllFillers.AddRange(UI.GetComponentsInChildren<ContentSizeFitter>(true).ToList());
			Inventory_Element = AssetStorage.asset.LoadAsset<GameObject>("TransmogInventoryItem");
			Inventory_Content = UI.transform.Find("Canvas/SelectItemTab/ItemList/ListPanel/Scroll View/Viewport/Content");
			Category_Element = AssetStorage.asset.LoadAsset<GameObject>("TransmogCategory");
			Category_Content = UI.transform.Find("Canvas/SelectTransmogTab/ItemList/ListPanel/Scroll View/Viewport/Content");
			Transmog_Element = AssetStorage.asset.LoadAsset<GameObject>("TransmogItem");
			ChoosenItem_Transform = UI.transform.Find("Canvas/SelectItemTab/ItemList/ChoosenItem");
			ClickEffect = AssetStorage.asset.LoadAsset<GameObject>("TransmogClick");
			ClickEffect2 = AssetStorage.asset.LoadAsset<GameObject>("TransmogClick2");
			ClickEffectReverse = AssetStorage.asset.LoadAsset<GameObject>("TransmogReverse");
			ButtonClickedEvent onClick = ((Component)UI.transform.Find("Canvas/SelectItemTab/ItemList/DestroyTransmog")).GetComponent<Button>().onClick;
			object obj = <>O.<0>__TransformReverse;
			if (obj == null)
			{
				UnityAction val = TransformReverse;
				<>O.<0>__TransformReverse = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Localization.instance.Localize(UI.transform);
		}

		private static void UpdateFillers()
		{
			Canvas.ForceUpdateCanvases();
			AllFillers.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = false;
			});
			AllFillers.ForEach(delegate(ContentSizeFitter filter)
			{
				((Behaviour)filter).enabled = true;
			});
		}

		private static void LoadInventory()
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			ClearStuff();
			MainBar.value = 1f;
			SubBar.value = 1f;
			IOrderedEnumerable<ItemData> orderedEnumerable = from item in ((Humanoid)Player.m_localPlayer).m_inventory.GetAllItems()
				where AvaliableTypes.Contains(item.m_shared.m_itemType)
				orderby !item.HasTransmog(), Localization.instance.Localize(item.m_shared.m_name)
				select item;
			int num = 0;
			foreach (ItemData item2 in orderedEnumerable)
			{
				GameObject val = Object.Instantiate<GameObject>(Inventory_Element, Inventory_Content);
				((Component)val.transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize(item2.m_shared.m_name);
				((Graphic)((Component)val.transform.Find("Text")).GetComponent<Text>()).color = (Color)(item2.HasTransmog() ? new Color(1f, 0.31f, 0.31f) : Color.white);
				((Component)val.transform.Find("Icon")).GetComponent<Image>().sprite = item2.GetIcon();
				int index = num;
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					ChooseItem(item2, index);
				});
				num++;
			}
			LoadCategories(null);
			UpdateFillers();
		}

		private static void LoadCategories(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item2 in Category_Content)
			{
				Transform val = item2;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			if (item == null)
			{
				LoadOneCategory((ItemType)999, active: false);
				{
					foreach (ItemType avaliableType in AvaliableTypes)
					{
						LoadOneCategory(avaliableType, active: false);
					}
					return;
				}
			}
			ItemType itemType = item.m_shared.m_itemType;
			LoadOneCategory((ItemType)999, active: true);
			LoadOneCategory(itemType, active: true);
			UpdateFillers();
		}

		private static void LoadOneCategory(ItemType category, bool active)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Expected O, but got Unknown
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Expected O, but got Unknown
			if (!Transmogrification_Main_Client.FilteredTransmogData[CurrentProfile].TryGetValue(category, out List<Transmogrification_DataTypes.TransmogItem_Data> value) || value.Count <= 0)
			{
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(Category_Element, Category_Content);
			((Graphic)val.GetComponent<Image>()).color = TypeColors[category];
			((Component)val.transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize("$mpasn_transmog_" + ((object)(ItemType)(ref category)).ToString().ToLower());
			foreach (Transmogrification_DataTypes.TransmogItem_Data data in value)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(data.Prefab);
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					continue;
				}
				GameObject transmogElement = Object.Instantiate<GameObject>(Transmog_Element, val.transform);
				((Component)transmogElement.transform.Find("ItemName")).GetComponent<Text>().text = data.GetLocalizedName();
				((Component)transmogElement.transform.Find("Icon/IconItem")).GetComponent<Image>().sprite = data.GetIcon();
				((Component)transmogElement.transform.Find("Price")).GetComponent<Text>().text = data.GetLocalizedPrice();
				((Component)transmogElement.transform.Find("Price/X")).GetComponent<Text>().text = $"X {data.Price_Amount}";
				((Component)transmogElement.transform.Find("Price/PriceIcon/IconItem")).GetComponent<Image>().sprite = data.GetPriceIcon();
				if (!active)
				{
					((Component)transmogElement.transform.Find("Add")).gameObject.SetActive(false);
					((Component)transmogElement.transform.Find("HEX")).gameObject.SetActive(false);
					((Component)transmogElement.transform.Find("ColorText")).gameObject.SetActive(false);
					((Component)transmogElement.transform.Find("Preview")).gameObject.SetActive(false);
					continue;
				}
				string name = ZNetScene.instance.GetPrefab(data.Price_Prefab).GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				int num = ((Humanoid)Player.m_localPlayer).m_inventory.CountItems(name, -1, true);
				bool flag = num >= data.Price_Amount;
				((Graphic)((Component)transmogElement.transform.Find("Price/X")).GetComponent<Text>()).color = (Color)(flag ? Color.yellow : new Color(1f, 0.31f, 0.31f));
				((Graphic)transmogElement.GetComponent<Image>()).color = (Color)(flag ? Color.white : new Color(0.78f, 0.49f, 0.51f));
				((Component)transmogElement.transform.Find("Add")).gameObject.SetActive(flag);
				((UnityEvent)((Component)transmogElement.transform.Find("Add")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					ClickTransmog(data, transmogElement);
				});
				((UnityEvent<string>)(object)((Component)transmogElement.transform.Find("HEX")).GetComponent<TMP_InputField>().onValueChanged).AddListener((UnityAction<string>)delegate(string str)
				{
					//IL_0038: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					Image component = ((Component)transmogElement.transform.Find("HEX")).GetComponent<Image>();
					Color color = default(Color);
					if (ColorUtility.TryParseHtmlString("#" + str, ref color))
					{
						((Graphic)component).color = color;
					}
					else
					{
						((Graphic)component).color = Color.white;
					}
				});
				((UnityEvent)((Component)transmogElement.transform.Find("Preview")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					StartPreview(transmogElement, data.Prefab, category);
				});
			}
		}

		private static void StartPreview(GameObject go, string prefab, ItemType category)
		{
			//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_003b: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Color c = Color.white;
			TMP_InputField component = ((Component)go.transform.Find("HEX")).GetComponent<TMP_InputField>();
			Color val = default(Color);
			if (component != null && ColorUtility.TryParseHtmlString("#" + component.text, ref val))
			{
				c = val;
			}
			PlayerModelPreview.SetAsCurrent(PlayerModelPreview.CreatePlayerModel(prefab, category, c));
		}

		private static void ClickTransmog(Transmogrification_DataTypes.TransmogItem_Data data, GameObject element)
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			if (CurrentChoosenItem == null)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(data.Price_Prefab);
			if (!((Object)(object)prefab == (Object)null))
			{
				int num = ((Humanoid)Player.m_localPlayer).m_inventory.CountItems(prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name, -1, true);
				if (num >= data.Price_Amount)
				{
					((Humanoid)Player.m_localPlayer).m_inventory.RemoveItem(prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name, data.Price_Amount, -1, true);
					Transmogrification_DataTypes.TransmogItem_ComponentV2 orCreate = CurrentChoosenItem.Data().GetOrCreate<Transmogrification_DataTypes.TransmogItem_ComponentV2>();
					orCreate.ReplacedPrefab = data.Prefab;
					string text = "#" + ((Component)element.transform.Find("HEX")).GetComponent<TMP_InputField>().text;
					Color val = default(Color);
					orCreate.ItemColor = (ColorUtility.TryParseHtmlString(text, ref val) ? text : "");
					orCreate.Save();
					((Component)ChoosenItem_Transform.Find("EIDF")).gameObject.SetActive(true);
					GameObject val2 = Object.Instantiate<GameObject>(ClickEffect, ChoosenItem_Transform);
					val2.transform.SetAsLastSibling();
					GameObject val3 = Object.Instantiate<GameObject>(ClickEffect2, ChoosenItem_Transform);
					((Transform)val3.GetComponent<RectTransform>()).position = element.transform.position;
					AssetStorage.AUsrc.PlayOneShot(Gambler_UI.SOUNDEFFECT3, 0.6f);
					LoadCategories(CurrentChoosenItem);
					((Graphic)((Component)Inventory_Content.GetChild(IndexOfChoosenItem).Find("Text")).GetComponent<Text>()).color = new Color(1f, 0.31f, 0.31f);
					string text2 = "Player " + Player.m_localPlayer.GetPlayerName() + " has transmogged " + CurrentChoosenItem.m_shared.m_name + " " + $"to {data.GetLocalizedName()} for {data.Price_Amount} {prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name}";
					ZRoutedRpc.instance.InvokeRoutedRPC("LogOnServer_mpasn", new object[2] { 4, text2 });
				}
			}
		}

		private static void TransformReverse()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			if (CurrentChoosenItem?.Data().Get<Transmogrification_DataTypes.TransmogItem_ComponentV2>() != null)
			{
				CurrentChoosenItem.Data().Remove<Transmogrification_DataTypes.TransmogItem_ComponentV2>();
				GameObject val = Object.Instantiate<GameObject>(ClickEffectReverse, ChoosenItem_Transform);
				val.transform.SetAsLastSibling();
				AssetStorage.AUsrc.PlayOneShot(Gambler_UI.SOUNDEFFECT3, 0.6f);
				((Component)ChoosenItem_Transform.Find("EIDF")).gameObject.SetActive(false);
				((Graphic)((Component)Inventory_Content.GetChild(IndexOfChoosenItem).Find("Text")).GetComponent<Text>()).color = Color.white;
			}
		}

		private static void ChooseItem(ItemData item, int childIndex)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			AssetStorage.AUsrc.Play();
			if (item == CurrentChoosenItem)
			{
				CurrentChoosenItem = null;
				LoadInventory();
				return;
			}
			CurrentChoosenItem = item;
			IndexOfChoosenItem = childIndex;
			foreach (Transform item2 in Inventory_Content)
			{
				Transform val = item2;
				((Graphic)((Component)val).GetComponent<Image>()).color = Color.white;
			}
			((Graphic)((Component)Inventory_Content.GetChild(childIndex)).GetComponent<Image>()).color = Color.green;
			((Component)ChoosenItem_Transform.Find("Text")).GetComponent<Text>().text = Localization.instance.Localize(item.m_shared.m_name);
			((Component)ChoosenItem_Transform.Find("Icon")).GetComponent<Image>().sprite = item.GetIcon();
			((Component)ChoosenItem_Transform.Find("EIDF")).gameObject.SetActive(item.HasTransmog());
			LoadCategories(item);
		}

		private static void ClearStuff()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			CurrentChoosenItem = null;
			((Component)ChoosenItem_Transform.Find("Text")).GetComponent<Text>().text = "";
			((Component)ChoosenItem_Transform.Find("Icon")).GetComponent<Image>().sprite = AssetStorage.NullSprite;
			((Component)ChoosenItem_Transform.Find("EIDF")).gameObject.SetActive(false);
			foreach (Transform item in Inventory_Content)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			foreach (Transform item2 in Category_Content)
			{
				Transform val2 = item2;
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
		}

		public static void Reload()
		{
			if (IsVisble())
			{
				LoadInventory();
			}
		}

		public static void Show(string profile, string _npcName)
		{
			if (Transmogrification_Main_Client.FilteredTransmogData.ContainsKey(profile))
			{
				CurrentProfile = profile;
				((Component)UI.transform.Find("Canvas/Header/Text")).GetComponent<Text>().text = _npcName;
				CurrentChoosenItem = null;
				UI.SetActive(true);
				LoadInventory();
			}
		}

		public static void Hide()
		{
			UI.SetActive(false);
			ClearStuff();
		}
	}
}
namespace Marketplace.Modules.TerritorySystem
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class ZoneVisualizer
	{
		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			private static void Postfix()
			{
				Off();
			}
		}

		private static GameObject ZoneVisualizer_Square;

		private static GameObject ZoneVisualizer_Circle;

		public static readonly List<GameObject> Visualizers = new List<GameObject>();

		public static float VisualizerAlpha = 0.2f;

		private static void OnInit()
		{
			ZoneVisualizer_Square = AssetStorage.asset.LoadAsset<GameObject>("SquareZoneVisualizer");
			ZoneVisualizer_Circle = AssetStorage.asset.LoadAsset<GameObject>("CircleZoneVisualizer");
		}

		public static void OnMapChange()
		{
			if (Visualizers.Count > 0 || (TerritorySystem_Main_Client.AlwaysShowZoneVisualizer.Value && Object.op_Implicit((Object)(object)ZoneVisualizer_Square)))
			{
				On();
			}
		}

		public static void On()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			Visualizers.ForEach(delegate(GameObject x)
			{
				if (Object.op_Implicit((Object)(object)x))
				{
					Object.Destroy((Object)(object)x);
				}
			});
			Visualizers.Clear();
			foreach (TerritorySystem_DataTypes.Territory territory in TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories)
			{
				if (territory.Colors.Count != 0)
				{
					GameObject val = Object.Instantiate<GameObject>((territory.Shape == TerritorySystem_DataTypes.TerritoryShape.Circle) ? ZoneVisualizer_Circle : ZoneVisualizer_Square);
					Transform transform = val.transform;
					transform.position = (Vector3)(territory.Shape switch
					{
						TerritorySystem_DataTypes.TerritoryShape.Circle => territory.Pos3D(), 
						TerritorySystem_DataTypes.TerritoryShape.Square => territory.Pos3D(), 
						TerritorySystem_DataTypes.TerritoryShape.Rectangle => territory.Pos3D() + new Vector3((float)territory.X[1] / 2f, 0f, (float)territory.Y[1] / 2f), 
						_ => territory.Pos3D(), 
					});
					float num = territory.HeightBounds.Item2 - territory.HeightBounds.Item1;
					Transform transform2 = val.transform;
					transform2.localScale = (Vector3)(territory.Shape switch
					{
						TerritorySystem_DataTypes.TerritoryShape.Circle => new Vector3((float)territory.Radius * 2f, num, (float)territory.Radius * 2f), 
						TerritorySystem_DataTypes.TerritoryShape.Square => new Vector3((float)territory.Radius * 2f, num, (float)territory.Radius * 2f), 
						TerritorySystem_DataTypes.TerritoryShape.Rectangle => new Vector3((float)territory.X[1], num, (float)territory.Y[1]), 
						_ => new Vector3((float)territory.Radius, num, (float)territory.Radius), 
					});
					Color color = Color32.op_Implicit(territory.GetColor());
					color.a = VisualizerAlpha;
					((Renderer)val.GetComponentInChildren<MeshRenderer>()).material.color = color;
					Visualizers.Add(val);
				}
			}
			EnvMan instance = EnvMan.instance;
			if (instance != null)
			{
				((Component)((Component)instance).transform.Find("Clouds")).gameObject.SetActive(false);
			}
		}

		public static void Off()
		{
			Visualizers.ForEach(delegate(GameObject x)
			{
				if (Object.op_Implicit((Object)(object)x))
				{
					Object.Destroy((Object)(object)x);
				}
			});
			Visualizers.Clear();
			EnvMan instance = EnvMan.instance;
			if (instance != null)
			{
				((Component)((Component)instance).transform.Find("Clouds")).gameObject.SetActive(false);
			}
		}
	}
	public static class TerritorySystem_DataTypes
	{
		public class TerritoryContainer : ISerializableParameter
		{
			public List<Territory> Territories = new List<Territory>();

			public bool ShouldRedraw;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(Territories.Count);
				foreach (Territory territory in Territories)
				{
					territory.Serialize(ref pkg);
				}
				pkg.Write(ShouldRedraw);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				int num = pkg.ReadInt();
				Territories = new List<Territory>();
				for (int i = 0; i < num; i++)
				{
					Territory territory = new Territory();
					territory.Deserialize(ref pkg);
					Territories.Add(territory);
				}
				ShouldRedraw = pkg.ReadBool();
			}
		}

		public class Territory : ISerializableParameter
		{
			[NonSerialized]
			public static Territory LastTerritory;

			public TerritoryShape Shape;

			public TerritoryFlags Flags;

			public AdditionalTerritoryFlags AdditionalFlags;

			public int[] X;

			public int[] Y;

			public string Name = "";

			public List<Color32> Colors = new List<Color32>();

			public string Permitted = "";

			public int Radius;

			public bool ShowExternalWater = true;

			public int Priority;

			public GradientType GradientType = GradientType.LeftRight;

			public float ExponentialValue = 1f;

			public string OnlyForGuild;

			public string OnlyForFaction;

			public int UID = Random.Range(int.MinValue, int.MaxValue);

			public float PeriodicHealValue;

			public float PeriodicDamageValue;

			public float IncreasedPlayerDamageValue;

			public float IncreasedMonsterDamageValue;

			public string[] CustomEnvironment;

			public float MoveSpeedMultiplier;

			public float OverridenHeight;

			public int OverridenBiome;

			public int AddMonsterLevel;

			public float Wind;

			public float DropMultiplier;

			public PaintType PaintGround;

			public HashSet<string> CustomSpawnerNames = new HashSet<string>();

			public string JoinOtherServerString = "";

			public TerritoryType Type;

			public string Owner = "";

			public int SellPrice;

			public (int, int) HeightBounds = (-100000, 100000);

			private bool? IsPermittedCache;

			public void Serialize(ref ZPackage pkg)
			{
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				pkg.Write((int)Shape);
				pkg.Write((int)Flags);
				pkg.Write((int)AdditionalFlags);
				pkg.Write(X.Length);
				int[] x = X;
				foreach (int num in x)
				{
					pkg.Write(num);
				}
				pkg.Write(Y.Length);
				int[] y = Y;
				foreach (int num2 in y)
				{
					pkg.Write(num2);
				}
				pkg.Write(Name ?? "");
				pkg.Write(Colors.Count);
				foreach (Color32 color in Colors)
				{
					pkg.Write(color.r);
					pkg.Write(color.g);
					pkg.Write(color.b);
				}
				pkg.Write(Radius);
				pkg.Write(ShowExternalWater);
				pkg.Write(Priority);
				pkg.Write(PeriodicHealValue);
				pkg.Write(PeriodicDamageValue);
				pkg.Write(IncreasedPlayerDamageValue);
				pkg.Write(IncreasedMonsterDamageValue);
				ZPackage obj = pkg;
				string[] customEnvironment = CustomEnvironment;
				obj.Write((customEnvironment != null) ? customEnvironment.Length : 0);
				if (CustomEnvironment != null)
				{
					string[] customEnvironment2 = CustomEnvironment;
					foreach (string text in customEnvironment2)
					{
						pkg.Write(text ?? "");
					}
				}
				pkg.Write(MoveSpeedMultiplier);
				pkg.Write(Permitted ?? "");
				pkg.Write(OverridenHeight);
				pkg.Write(OverridenBiome);
				pkg.Write(AddMonsterLevel);
				pkg.Write((int)PaintGround);
				pkg.Write((int)GradientType);
				pkg.Write(ExponentialValue);
				pkg.Write(HeightBounds.Item1);
				pkg.Write(HeightBounds.Item2);
				pkg.Write(Wind);
				pkg.Write(DropMultiplier);
				pkg.Write(OnlyForGuild ?? "");
				pkg.Write(OnlyForFaction ?? "");
				pkg.Write(CustomSpawnerNames.Count);
				foreach (string customSpawnerName in CustomSpawnerNames)
				{
					pkg.Write(customSpawnerName);
				}
				pkg.Write((int)Type);
				pkg.Write(Owner ?? "");
				pkg.Write(SellPrice);
				pkg.Write(UID);
				pkg.Write(JoinOtherServerString ?? "");
			}

			public void Deserialize(ref ZPackage pkg)
			{
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				Shape = (TerritoryShape)pkg.ReadInt();
				Flags = (TerritoryFlags)pkg.ReadInt();
				AdditionalFlags = (AdditionalTerritoryFlags)pkg.ReadInt();
				int num = pkg.ReadInt();
				X = new int[num];
				for (int i = 0; i < num; i++)
				{
					X[i] = pkg.ReadInt();
				}
				int num2 = pkg.ReadInt();
				Y = new int[num2];
				for (int j = 0; j < num2; j++)
				{
					Y[j] = pkg.ReadInt();
				}
				Name = pkg.ReadString();
				int num3 = pkg.ReadInt();
				Colors = new List<Color32>();
				for (int k = 0; k < num3; k++)
				{
					Colors.Add(new Color32(pkg.ReadByte(), pkg.ReadByte(), pkg.ReadByte(), byte.MaxValue));
				}
				Radius = pkg.ReadInt();
				ShowExternalWater = pkg.ReadBool();
				Priority = pkg.ReadInt();
				PeriodicHealValue = pkg.ReadSingle();
				PeriodicDamageValue = pkg.ReadSingle();
				IncreasedPlayerDamageValue = pkg.ReadSingle();
				IncreasedMonsterDamageValue = pkg.ReadSingle();
				int num4 = pkg.ReadInt();
				CustomEnvironment = new string[num4];
				for (int l = 0; l < num4; l++)
				{
					CustomEnvironment[l] = pkg.ReadString();
				}
				MoveSpeedMultiplier = pkg.ReadSingle();
				Permitted = pkg.ReadString();
				OverridenHeight = pkg.ReadSingle();
				OverridenBiome = pkg.ReadInt();
				AddMonsterLevel = pkg.ReadInt();
				PaintGround = (PaintType)pkg.ReadInt();
				GradientType = (GradientType)pkg.ReadInt();
				ExponentialValue = pkg.ReadSingle();
				HeightBounds = (pkg.ReadInt(), pkg.ReadInt());
				Wind = pkg.ReadSingle();
				DropMultiplier = pkg.ReadSingle();
				OnlyForGuild = pkg.ReadString();
				OnlyForFaction = pkg.ReadString();
				int num5 = pkg.ReadInt();
				CustomSpawnerNames = new HashSet<string>();
				for (int m = 0; m < num5; m++)
				{
					CustomSpawnerNames.Add(pkg.ReadString());
				}
				Type = (TerritoryType)pkg.ReadInt();
				Owner = pkg.ReadString();
				SellPrice = pkg.ReadInt();
				UID = pkg.ReadInt();
				JoinOtherServerString = pkg.ReadString();
			}

			public bool DrawOnMap()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if (Colors.Count > 0)
				{
					return Vector2.Distance(new Vector2(0f, 0f), new Vector2((float)X[0], (float)Y[0])) <= 12500f;
				}
				return false;
			}

			public bool UsingGradient()
			{
				if (Shape != TerritoryShape.Rectangle)
				{
					return Colors.Count > 1;
				}
				return false;
			}

			public static Territory GetCurrentTerritory(Vector3 pos)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				foreach (Territory territory in SyncedTerritoriesData.Value.Territories)
				{
					if (territory.IsInside(pos))
					{
						return territory;
					}
				}
				return null;
			}

			public Vector3 Pos3D()
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3((float)X[0], (float)(HeightBounds.Item1 + HeightBounds.Item2) / 2f, (float)Y[0]);
			}

			public Color32 GetColor()
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (Colors.Count <= 0)
				{
					return Color32.op_Implicit(Color.green);
				}
				return Colors[0];
			}

			private Color32 CalculateGradient(float t)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: 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)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				if (!(t <= 0f))
				{
					if (t >= 1f)
					{
						return Colors[Colors.Count - 1];
					}
					float num = 1f / (float)(Colors.Count - 1);
					int num2 = Mathf.FloorToInt(t / num);
					float num3 = (t - (float)num2 * num) / num;
					float num4 = 1f - Mathf.Pow(1f - num3, ExponentialValue);
					return Color32.Lerp(Colors[num2], Colors[num2 + 1], num4);
				}
				return Colors[0];
			}

			public Color32 GetGradientX(float x, bool reverse = false)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				float num = X[0] - Radius;
				float num2 = X[0] + Radius;
				float num3 = Mathf.Clamp01((x - num) / (num2 - num));
				if (reverse)
				{
					num3 = 1f - num3;
				}
				return CalculateGradient(num3);
			}

			public Color32 GetGradientY(float y, bool reverse = false)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				float num = Y[0] - Radius;
				float num2 = Y[0] + Radius;
				float num3 = Mathf.Clamp01((y - num) / (num2 - num));
				if (reverse)
				{
					num3 = 1f - num3;
				}
				return CalculateGradient(num3);
			}

			public Color32 GetGradientXY(Vector2 pos, bool reverse = false)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: 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)
				float num = X[0] - Radius;
				float num2 = X[0] + Radius;
				float num3 = Y[0] - Radius;
				float num4 = Y[0] + Radius;
				float num5 = Mathf.Clamp01((pos.x - num) / (num2 - num));
				float num6 = Mathf.Clamp01((pos.y - num3) / (num4 - num3));
				float num7 = (num5 + num6) / 2f;
				if (reverse)
				{
					num7 = 1f - num7;
				}
				return CalculateGradient(num7);
			}

			public Color32 GetGradientXY_2(Vector2 pos, bool reverse = false)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: 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)
				float num = X[0] + Radius;
				float num2 = X[0] - Radius;
				float num3 = Y[0] - Radius;
				float num4 = Y[0] + Radius;
				float num5 = Mathf.Clamp01((pos.x - num) / (num2 - num));
				float num6 = Mathf.Clamp01((pos.y - num3) / (num4 - num3));
				float num7 = (num5 + num6) / 2f;
				if (reverse)
				{
					num7 = 1f - num7;
				}
				return CalculateGradient(num7);
			}

			public Color32 GetGradientFromCenter(Vector2 pos, bool reverse = false)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				float num = Mathf.Clamp01(Vector2.Distance(pos, new Vector2((float)X[0], (float)Y[0])) / (float)Radius);
				if (reverse)
				{
					num = 1f - num;
				}
				return CalculateGradient(num);
			}

			public string RawName()
			{
				return Name;
			}

			public string GetName()
			{
				return Name + "\n" + (IsPermitted() ? "<color=#00ff00>Permitted</color>\n" : "");
			}

			public bool IsPermitted()
			{
				if (Utils.IsDebug_Strict)
				{
					return true;
				}
				bool valueOrDefault = IsPermittedCache.GetValueOrDefault();
				if (!IsPermittedCache.HasValue)
				{
					valueOrDefault = Owner == Global_Configs._localUserID || Permitted.Contains(Global_Configs._localUserID) || Permitted.Contains("ALL") || (Guilds.API.GetOwnGuild() != null && Guilds.API.GetOwnGuild().Name == OnlyForGuild) || Factions_Client.IsMyFaction(OnlyForFaction);
					IsPermittedCache = valueOrDefault;
				}
				return IsPermittedCache.Value;
			}

			public void ClearOwnerCache()
			{
				IsPermittedCache = null;
			}

			public bool IsInside2D(Vector2 mouse)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return IsInside2D(mouse.x, mouse.y);
			}

			public bool IsInside2D(float x, float y)
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				switch (Shape)
				{
				case TerritoryShape.Square:
					if (x >= (float)(X[0] - Radius) && x <= (float)(X[0] + Radius) && y >= (float)(Y[0] - Radius))
					{
						return y <= (float)(Y[0] + Radius);
					}
					return false;
				case TerritoryShape.Circle:
					return Vector2.Distance(new Vector2((float)X[0], (float)Y[0]), new Vector2(x, y)) <= (float)Radius;
				case TerritoryShape.Rectangle:
					if (x >= (float)X[0] && x <= (float)(X[0] + X[1]) && y >= (float)Y[0])
					{
						return y <= (float)(Y[0] + Y[1]);
					}
					return false;
				default:
					return false;
				}
			}

			public bool IsInside(Vector3 init)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: 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)
				if (IsInside2D(init.x, init.z) && init.y >= (float)HeightBounds.Item1)
				{
					return init.y <= (float)HeightBounds.Item2;
				}
				return false;
			}

			public override string ToString()
			{
				return $"Name: {Name}, Type: {Shape}, Flags: {Flags}, values:\nHeal: {PeriodicHealValue}, Damage: {PeriodicDamageValue}, MoveSpeed: {MoveSpeedMultiplier}, PlayerDamage: {IncreasedPlayerDamageValue}, MonsterDamage: {IncreasedMonsterDamageValue}, CustomEnvironment: {CustomEnvironment}\nOwners: {Permitted}";
			}

			public string GetTerritoryFlags()
			{
				string text = "";
				if (Type == TerritoryType.ForSale && string.IsNullOrWhiteSpace(Owner))
				{
					text += $"\n<color=#00FFFF>Can be bought for {SellPrice} coins</color>\n";
				}
				if (HeightBounds.Item1 != int.MinValue && HeightBounds.Item2 != int.MaxValue)
				{
					text += $"\n(Height Bounds: {HeightBounds.Item1} - {HeightBounds.Item2})\n";
				}
				TerritoryFlags[] allTerritoryFlagsArray = AllTerritoryFlagsArray;
				foreach (TerritoryFlags territoryFlags in allTerritoryFlagsArray)
				{
					if (Flags.HasFlagFast(territoryFlags) && LocalizedTerritoryFlags.TryGetValue(territoryFlags, out string value))
					{
						text += Localization.instance.Localize(value);
					}
				}
				AdditionalTerritoryFlags[] allAdditionaTerritoryFlagsArray = AllAdditionaTerritoryFlagsArray;
				foreach (AdditionalTerritoryFlags additionalTerritoryFlags in allAdditionaTerritoryFlagsArray)
				{
					if (AdditionalFlags.HasFlagFast(additionalTerritoryFlags) && LocalizedAdditionalTerritoryFlags.TryGetValue(additionalTerritoryFlags, out string value2))
					{
						text += Localization.instance.Localize(value2);
					}
				}
				return text;
			}
		}

		public enum TerritoryShape
		{
			Circle,
			Square,
			Rectangle
		}

		public enum TerritoryType
		{
			AdminCreated,
			ForSale
		}

		public enum GradientType
		{
			FromCenter,
			ToCenter,
			LeftRight,
			RightLeft,
			TopBottom,
			BottomTop,
			BottomRightTopLeft,
			TopRightBottomLeft,
			BottomLeftTopRight,
			TopLeftBottomRight
		}

		public enum PaintType
		{
			Paved,
			Grass,
			Cultivated,
			Dirt
		}

		[Flags]
		public enum TerritoryFlags
		{
			None = 0,
			PushAway = 1,
			NoBuild = 2,
			NoPickaxe = 4,
			NoInteract = 8,
			NoAttack = 0x10,
			PvpOnly = 0x20,
			PveOnly = 0x40,
			PeriodicHeal = 0x80,
			PeriodicDamage = 0x100,
			IncreasedPlayerDamage = 0x200,
			IncreasedMonsterDamage = 0x400,
			NoMonsters = 0x800,
			CustomEnvironment = 0x1000,
			MoveSpeedMultiplier = 0x2000,
			NoDeathPenalty = 0x4000,
			NoPortals = 0x8000,
			PeriodicHealALL = 0x10000,
			ForceGroundHeight = 0x20000,
			ForceBiome = 0x40000,
			AddGroundHeight = 0x80000,
			NoBuildDamage = 0x100000,
			MonstersAddStars = 0x200000,
			InfiniteFuel = 0x400000,
			NoInteractItems = 0x800000,
			NoInteractCraftingStation = 0x1000000,
			NoInteractItemStands = 0x2000000,
			NoInteractChests = 0x4000000,
			NoInteractDoors = 0x8000000,
			NoStructureSupport = 0x10000000,
			NoInteractPortals = 0x20000000,
			CustomPaint = 0x40000000,
			LimitZoneHeight = int.MinValue
		}

		[Flags]
		public enum AdditionalTerritoryFlags
		{
			None = 0,
			NoItemLoss = 1,
			SnowMask = 2,
			NoMist = 4,
			InfiniteEitr = 8,
			InfiniteStamina = 0x10,
			DropMultiplier = 0x20,
			ForceWind = 0x40,
			GodMode = 0x80,
			OnlyForGuild = 0x100,
			CustomJereSpawner = 0x200,
			JoinOtherServer = 0x400,
			RevealOnMap = 0x800,
			OnlyForFaction = 0x1000
		}

		public static readonly CustomSyncedValue<TerritoryContainer> SyncedTerritoriesData = new CustomSyncedValue<TerritoryContainer>(Marketplace.configSync, "territoryData", new TerritoryContainer());

		public static readonly TerritoryFlags[] AllTerritoryFlagsArray = (TerritoryFlags[])Enum.GetValues(typeof(TerritoryFlags));

		public static readonly AdditionalTerritoryFlags[] AllAdditionaTerritoryFlagsArray = (AdditionalTerritoryFlags[])Enum.GetValues(typeof(AdditionalTerritoryFlags));

		private static readonly Dictionary<TerritoryFlags, string> LocalizedTerritoryFlags = new Dictionary<TerritoryFlags, string>
		{
			{
				TerritoryFlags.NoBuildDamage,
				"\n<color=#00FFFF>$mpasn_nobuilddamage</color>"
			},
			{
				TerritoryFlags.PushAway,
				"\n<color=#00FFFF>$mpasn_pushaway</color>"
			},
			{
				TerritoryFlags.NoBuild,
				"\n<color=#00FFFF>$mpasn_cantbuild</color>"
			},
			{
				TerritoryFlags.NoPickaxe,
				"\n<color=#00FFFF>$mpasn_cantusepickaxe</color>"
			},
			{
				TerritoryFlags.NoInteract,
				"\n<color=#00FFFF>$mpasn_nointeractions</color>"
			},
			{
				TerritoryFlags.NoAttack,
				"\n<color=#00FFFF>$mpasn_cantattack</color>"
			},
			{
				TerritoryFlags.PvpOnly,
				"\n<color=#00FFFF>$mpasn_pvponly</color>"
			},
			{
				TerritoryFlags.PveOnly,
				"\n<color=#00FFFF>$mpasn_pveonly</color>"
			},
			{
				TerritoryFlags.PeriodicHealALL,
				"\n<color=#00FFFF>$mpasn_periodichealALL</color>"
			},
			{
				TerritoryFlags.PeriodicHeal,
				"\n<color=#00FFFF>$mpasn_periodicheal</color>"
			},
			{
				TerritoryFlags.PeriodicDamage,
				"\n<color=#00FFFF>$mpasn_periodicdamage</color>"
			},
			{
				TerritoryFlags.IncreasedPlayerDamage,
				"\n<color=#00FFFF>$mpasn_increasedamagePlayer</color>"
			},
			{
				TerritoryFlags.IncreasedMonsterDamage,
				"\n<color=#00FFFF>$mpasn_increasedamageMonsters</color>"
			},
			{
				TerritoryFlags.NoMonsters,
				"\n<color=#00FFFF>$mpasn_nomonsters</color>"
			},
			{
				TerritoryFlags.MoveSpeedMultiplier,
				"\n<color=#00FFFF>$mpasn_movementspeedmultiplier</color>"
			},
			{
				TerritoryFlags.NoDeathPenalty,
				"\n<color=#00FFFF>$mpasn_nodeathpenalty</color>"
			},
			{
				TerritoryFlags.NoPortals,
				"\n<color=#00FFFF>$mpasn_noportals</color>"
			},
			{
				TerritoryFlags.InfiniteFuel,
				"\n<color=#00FFFF>$mpasn_infinitefuel</color>"
			},
			{
				TerritoryFlags.NoInteractItems,
				"\n<color=#00FFFF>$mpasn_nointeractitems</color>"
			},
			{
				TerritoryFlags.NoInteractCraftingStation,
				"\n<color=#00FFFF>$mpasn_nointeractcraftingstations</color>"
			},
			{
				TerritoryFlags.NoInteractItemStands,
				"\n<color=#00FFFF>$mpasn_nointeractitemstands</color>"
			},
			{
				TerritoryFlags.NoInteractChests,
				"\n<color=#00FFFF>$mpasn_nointeractchests</color>"
			},
			{
				TerritoryFlags.NoInteractDoors,
				"\n<color=#00FFFF>$mpasn_nointeractdoors</color>"
			},
			{
				TerritoryFlags.NoStructureSupport,
				"\n<color=#00FFFF>$mpasn_nostructuresupport</color>"
			},
			{
				TerritoryFlags.NoInteractPortals,
				"\n<color=#00FFFF>$mpasn_nointeractportals</color>"
			}
		};

		private static readonly Dictionary<AdditionalTerritoryFlags, string> LocalizedAdditionalTerritoryFlags = new Dictionary<AdditionalTerritoryFlags, string>
		{
			{
				AdditionalTerritoryFlags.NoItemLoss,
				"\n<color=#00FFFF>$mpasn_noitemloss</color>"
			},
			{
				AdditionalTerritoryFlags.InfiniteEitr,
				"\n<color=#00FFFF>$mpasn_infiniteeitr</color>"
			},
			{
				AdditionalTerritoryFlags.InfiniteStamina,
				"\n<color=#00FFFF>$mpasn_infinitestamina</color>"
			},
			{
				AdditionalTerritoryFlags.NoMist,
				"\n<color=#00FFFF>$mpasn_nomistlandsmist</color>"
			},
			{
				AdditionalTerritoryFlags.DropMultiplier,
				"\n<color=#00FFFF>$mpasn_dropmultiplier</color>"
			},
			{
				AdditionalTerritoryFlags.OnlyForGuild,
				"\n<color=#00FFFF>$mpasn_onlyforguildterritory</color>"
			}
		};
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class TerritorySystem_Main_Client
	{
		public class RevealedTerritory
		{
			public TerritorySystem_DataTypes.TerritoryType Type;

			public Vector3 Pos;

			public int Radius;
		}

		[HarmonyPatch(typeof(SpawnSystem), "FindBaseSpawnPoint")]
		public class IsSpawnPointGood
		{
			private static bool Prefix(SpawnData spawn)
			{
				if (CurrentTerritory != null && CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.CustomJereSpawner))
				{
					return CurrentTerritory.CustomSpawnerNames.Contains(spawn.m_name);
				}
				return !spawn.m_name.Contains("MARKETPLACESPAWNER");
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdateBiome")]
		[ClientOnlyPatch]
		private static class Minimap_UpdateBiome_Patch
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static PopupButtonCallback <>9__5_1;

				internal void <ShowCustomTerritoryMessage>b__5_1()
				{
					UnifiedPopup.Pop();
				}
			}

			private const string search = "\n<i><b></b></i>";

			private static DateTime LastTimeTerritoryMessage;

			private static bool Prefix()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Invalid comparison between Unknown and I4
				if (CurrentTerritory != null && (int)Minimap.instance.m_mode != 2)
				{
					return false;
				}
				return true;
			}

			private static void Postfix(Minimap __instance)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Invalid comparison between Unknown and I4
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return;
				}
				if ((int)__instance.m_mode != 2)
				{
					if (CurrentTerritory != null && TerritorySystem_DataTypes.Territory.LastTerritory != CurrentTerritory)
					{
						string text = "<color=green>" + CurrentTerritory.GetName() + "</color>";
						__instance.m_biomeNameSmall.text = text;
						((Component)__instance.m_biomeNameSmall).GetComponent<Animator>().SetTrigger(Pulse);
						ShowCustomTerritoryMessage(CurrentTerritory);
						TerritorySystem_DataTypes.Territory.LastTerritory = CurrentTerritory;
						EnvMan.instance.SetForceEnvironment("");
					}
					if (CurrentTerritory == null && TerritorySystem_DataTypes.Territory.LastTerritory != null)
					{
						TerritorySystem_DataTypes.Territory.LastTerritory = null;
						Minimap.instance.m_biome = (Biome)0;
						EnvMan.instance.SetForceEnvironment("");
						__instance.m_biomeNameSmall.text = "";
					}
					return;
				}
				Vector3 val = __instance.ScreenToWorldPoint((Vector3)(ZInput.IsMouseActive() ? Input.mousePosition : new Vector3((float)(Screen.width / 2), (float)(Screen.height / 2))));
				bool flag = false;
				foreach (TerritorySystem_DataTypes.Territory territory in TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories)
				{
					if ((territory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.RevealOnMap) || __instance.IsExplored(val)) && territory.IsInside2D(new Vector2(val.x, val.z)))
					{
						string to = "\n<i><b></b></i>\n" + territory.GetName() + territory.GetTerritoryFlags() + "\n<i><b></b></i>";
						TryReplaceTerritoryString(__instance.m_biomeNameLarge, to);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					TryReplaceTerritoryString(__instance.m_biomeNameLarge, "");
				}
			}

			private static void TryReplaceTerritoryString(TMP_Text textElement, string to)
			{
				string text = textElement.text;
				int num = text.IndexOf("\n<i><b></b></i>", StringComparison.Ordinal);
				if (num > 0)
				{
					int num2 = text.IndexOf("\n<i><b></b></i>", num + "\n<i><b></b></i>".Length, StringComparison.Ordinal);
					string oldValue = text.Substring(num, num2 - num + "\n<i><b></b></i>".Length);
					text = text.Replace(oldValue, to);
					textElement.text = text;
				}
				else
				{
					textElement.text += to;
				}
			}

			private static void ShowCustomTerritoryMessage(TerritorySystem_DataTypes.Territory territory)
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Expected O, but got Unknown
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Expected O, but got Unknown
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Expected O, but got Unknown
				string text = territory.RawName();
				if ((DateTime.Now - LastTimeTerritoryMessage).TotalSeconds <= 5.0)
				{
					return;
				}
				LastTimeTerritoryMessage = DateTime.Now;
				GameObject val = Object.Instantiate<GameObject>(MessageHud.instance.m_biomeFoundPrefab, ((Component)MessageHud.instance).transform);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0.5f, 1f);
				component.anchorMax = new Vector2(0.5f, 1f);
				component.anchoredPosition = new Vector2(0f, -200f);
				TimedDestruction val2 = val.AddComponent<TimedDestruction>();
				((Component)val.transform.GetChild(0)).GetComponent<Animator>().speed = 2f;
				((Component)Utils.FindChild(val.transform, "Title", (IterativeSearchType)0)).GetComponent<TMP_Text>().text = text;
				val2.m_timeout = 2f;
				val2.Trigger();
				if (string.IsNullOrWhiteSpace(territory.JoinOtherServerString))
				{
					return;
				}
				string[] array = territory.JoinOtherServerString.Split(new char[1] { '@' });
				string text2 = array[0];
				string ip = array[1];
				string port = array[2];
				string text3 = array[3];
				string text4 = "Do you wanna travel to <color=yellow>" + text2 + "</color>?";
				PopupButtonCallback val3 = delegate
				{
					UnifiedPopup.Pop();
					ZNet.SetServerHost(ip, Convert.ToInt32(port), (OnlineBackendType)0);
					SceneManager.LoadScene("main");
				};
				object obj = <>c.<>9__5_1;
				if (obj == null)
				{
					PopupButtonCallback val4 = delegate
					{
						UnifiedPopup.Pop();
					};
					<>c.<>9__5_1 = val4;
					obj = (object)val4;
				}
				UnifiedPopup.Push((PopupBase)new YesNoPopup("Travel", text4, val3, (PopupButtonCallback)obj, true));
			}
		}

		[HarmonyPatch(typeof(Minimap), "Awake")]
		[ClientOnlyPatch]
		private static class Minimap_Awake_Patch
		{
			private static void Postfix(Minimap __instance)
			{
				__instance.m_biomeNameLarge.alignment = (TextAlignmentOptions)260;
				__instance.m_biomeNameSmall.alignment = (TextAlignmentOptions)260;
			}
		}

		[HarmonyPatch(typeof(Minimap), "GenerateWorldMap")]
		private static class Minimap_GenerateWorldMap_Patch
		{
			public static bool GENERATING;

			[UsedImplicitly]
			private static void Prefix(Minimap __instance)
			{
				GENERATING = true;
			}

			[UsedImplicitly]
			private static void Postfix(Minimap __instance)
			{
				GENERATING = false;
			}
		}

		[HarmonyPatch(typeof(Minimap), "LoadMapData")]
		[ClientOnlyPatch]
		private class PatchMinimapCircles
		{
			[HarmonyPriority(-3000)]
			private static void Postfix(Minimap __instance)
			{
				originalMapColors = __instance.m_mapTexture.GetPixels();
				originalHeightColors = __instance.m_heightTexture.GetPixels();
				DoMapMagic();
			}
		}

		[HarmonyPatch(typeof(Minimap), "GenerateWorldMap")]
		[ClientOnlyPatch]
		private class PatchMinimapCircles2
		{
			[HarmonyPriority(3000)]
			private static void Postfix(Minimap __instance)
			{
				originalMapColors = __instance.m_mapTexture.GetPixels();
				originalHeightColors = __instance.m_heightTexture.GetPixels();
				DoMapMagic();
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece")]
		[ClientOnlyPatch]
		private static class NoBuild_Patch
		{
			private static bool Prefix(Player __instance, ref bool __result)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoBuild) && !CurrentTerritory.IsPermitted())
				{
					__result = false;
					DoAreaEffect(__instance.m_placementGhost.transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Remove")]
		[ClientOnlyPatch]
		private static class WearNTear_Damage_Patch_Remove
		{
			private static bool Prefix(WearNTear __instance)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoBuild) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)__instance).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Damage")]
		[ClientOnlyPatch]
		private static class WearNTear_Damage_Patch_Damage
		{
			private static bool Prefix(WearNTear __instance)
			{
				WearNTear __instance2 = __instance;
				return !TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.NoBuildDamage].Any((TerritorySystem_DataTypes.Territory t) => t.IsInside(((Component)__instance2).transform.position));
			}
		}

		[HarmonyPatch(typeof(Character), "Awake")]
		[ClientOnlyPatch]
		private static class Character_Awake_Patch
		{
			private static void Postfix(Character __instance)
			{
				Character __instance2 = __instance;
				__instance2.m_nview.Register<int>("KGtsLevelUpdate", (Action<long, int>)delegate(long _, int level)
				{
					__instance2.m_onLevelSet?.Invoke(level);
				});
			}
		}

		[HarmonyPatch(typeof(Character), "Start")]
		[ClientOnlyPatch]
		private static class Character_Start_Patch
		{
			private static void Postfix(Character __instance)
			{
				if (CurrentTerritory != null && __instance.IsOwner() && !__instance.IsPlayer() && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.MonstersAddStars) && !__instance.m_nview.m_zdo.GetBool("KGtsLevel", false))
				{
					int num = __instance.GetLevel() + CurrentTerritory.AddMonsterLevel;
					__instance.m_nview.m_zdo.Set("KGtsLevel", true);
					__instance.SetLevel(num);
					__instance.m_nview.GetZDO().Set("level", num);
					__instance.SetupMaxHealth();
					__instance.m_nview.InvokeRPC(ZNetView.Everybody, "KGtsLevelUpdate", new object[1] { __instance.GetLevel() });
				}
			}
		}

		[HarmonyPatch(typeof(Attack), "SpawnOnHitTerrain")]
		[ClientOnlyPatch]
		private static class NoPickaxe_Patch
		{
			private static bool Prefix()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoPickaxe) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteract_Patch
		{
			private static bool Prefix(GameObject go)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteract) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(go.transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteractItems_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractItems) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteractPortals_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractPortals) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(CraftingStation), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteractCraftingStation_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractCraftingStation) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ItemStand), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteractItemStands_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractItemStands) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ArmorStand), "UseItem")]
		[ClientOnlyPatch]
		private static class NoInteractItemStands2_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractItemStands) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Container), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteractChests_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractChests) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Door), "Interact")]
		[ClientOnlyPatch]
		private static class NoInteractDoors_Patch
		{
			private static bool Prefix()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractDoors) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "UseStamina")]
		[ClientOnlyPatch]
		private static class InfiniteStamina_Patch
		{
			private static bool Prefix()
			{
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.InfiniteStamina))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "HaveSupport")]
		[ClientOnlyPatch]
		private static class NoStructureSupport_Patch
		{
			private static void Postfix(WearNTear __instance, ref bool __result)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.NoStructureSupport])
				{
					if (item.IsInside(((Component)__instance).transform.position))
					{
						__result = true;
						break;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "HaveEitr")]
		[ClientOnlyPatch]
		private static class InfiniteEitr_Patch
		{
			private static void Postfix(ref bool __result)
			{
				if (CurrentTerritory != null && CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.InfiniteEitr))
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		[ClientOnlyPatch]
		private static class Character_RPC_Damage_Patch
		{
			[UsedImplicitly]
			private static bool Prefix(Character __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && CurrentTerritory != null && CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.GodMode))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		[ClientOnlyPatch]
		private static class IncreaseTerritoryDamagePatch
		{
			private static void Prefix(Character __instance, ref HitData hit)
			{
				if (CurrentTerritory == null)
				{
					return;
				}
				if (__instance.IsPlayer())
				{
					if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.IncreasedMonsterDamage))
					{
						hit.ApplyModifier(CurrentTerritory.IncreasedMonsterDamageValue);
					}
				}
				else if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.IncreasedPlayerDamage))
				{
					hit.ApplyModifier(CurrentTerritory.IncreasedPlayerDamageValue);
				}
			}
		}

		[HarmonyPatch(typeof(Attack), "Start")]
		[ClientOnlyPatch]
		private static class NoAttackPatch
		{
			private static bool Prefix(Humanoid character)
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || CurrentTerritory == null || (Object)(object)character != (Object)(object)Player.m_localPlayer)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoAttack) && !CurrentTerritory.IsPermitted())
				{
					DoAreaEffect(((Component)Player.m_localPlayer).transform.position);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(CreatureSpawner), "Spawn")]
		[ClientOnlyPatch]
		private static class NoMonsters_Start_Patch
		{
			private static bool Prefix(CreatureSpawner __instance)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.NoMonsters])
				{
					if (item.IsInside(((Component)__instance).transform.position))
					{
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(SpawnSystem), "UpdateSpawning")]
		[ClientOnlyPatch]
		private static class NoMonsters_Start_Patch2
		{
			private static bool Prefix()
			{
				if (CurrentTerritory == null)
				{
					return true;
				}
				if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoMonsters))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(SpawnSystem), "Spawn")]
		[ClientOnlyPatch]
		private static class SpawnSystem_Spawn_Patch
		{
			private static bool Prefix(Vector3 spawnPoint)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.NoMonsters])
				{
					if (item.IsInside(spawnPoint))
					{
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "GetRunSpeedFactor")]
		[ClientOnlyPatch]
		private static class MoveSpeed_Patch_Territory
		{
			private static void Postfix(ref float __result)
			{
				if (CurrentTerritory != null && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.MoveSpeedMultiplier))
				{
					__result *= CurrentTerritory.MoveSpeedMultiplier;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetJogSpeedFactor")]
		[ClientOnlyPatch]
		private static class MoveSpeed2_Patch_Territory
		{
			private static void Postfix(ref float __result)
			{
				if (CurrentTerritory != null && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.MoveSpeedMultiplier))
				{
					__result *= CurrentTerritory.MoveSpeedMultiplier;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "HardDeath")]
		[ClientOnlyPatch]
		private static class Skills_OnDeath_Patch
		{
			private static void Postfix(ref bool __result)
			{
				if (CurrentTerritory != null && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoDeathPenalty))
				{
					__result = false;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "AutoPickup")]
		[ClientOnlyPatch]
		private static class Player_AutoPickup_Patch
		{
			private static bool Prefix()
			{
				if (CurrentTerritory == null)
				{
					return true;
				}
				if ((CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteractItems) || CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.NoInteract)) && !CurrentTerritory.IsPermitted())
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "TeleportTo")]
		[ClientOnlyPatch]
		private static class NoPortals_Patch
		{
			private static bool Prefix(Vector3 pos)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				if (Teleporter_Main_Client.DEBUG_TELEPORTTO_TERRITORY)
				{
					Teleporter_Main_Client.DEBUG_TELEPORTTO_TERRITORY = false;
					return true;
				}
				foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.NoPortals])
				{
					if (!item.IsPermitted() && (item.IsInside(((Component)Player.m_localPlayer).transform.position) || item.IsInside(pos)))
					{
						DoAreaEffect(((Component)Player.m_localPlayer).transform.position + Vector3.up);
						MessageHud.instance.ShowMessage((MessageType)1, Localization.instance.Localize("$mpasn_cantteleport"), 0, (Sprite)null, false);
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WorldGenerator), "GetBiomeHeight")]
		[ClientOnlyPatch]
		private static class WorldGenerator_GetBiomeHeight_Patch
		{
			private static void Postfix(float wx, float wy, ref float __result)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				if (Minimap_GenerateWorldMap_Patch.GENERATING)
				{
					return;
				}
				Vector2 mouse = default(Vector2);
				((Vector2)(ref mouse))..ctor(wx, wy);
				foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.ForceGroundHeight])
				{
					if (item.IsInside2D(mouse))
					{
						__result = item.OverridenHeight;
					}
				}
				foreach (TerritorySystem_DataTypes.Territory item2 in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.AddGroundHeight])
				{
					if (item2.IsInside2D(mouse))
					{
						__result += item2.OverridenHeight;
					}
				}
				foreach (TerritorySystem_DataTypes.Territory item3 in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.LimitZoneHeight])
				{
					if (item3.IsInside2D(mouse))
					{
						__result = Mathf.Max(item3.OverridenHeight, __result);
					}
				}
			}
		}

		[HarmonyPatch(typeof(WorldGenerator), "GetBiome", new Type[]
		{
			typeof(float),
			typeof(float),
			typeof(float),
			typeof(bool)
		})]
		[ClientOnlyPatch]
		private static class WorldGenerator_GetBiome_Patch
		{
			private static void Postfix(float wx, float wy, ref Biome __result)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				if (Minimap_GenerateWorldMap_Patch.GENERATING)
				{
					return;
				}
				Vector2 mouse = default(Vector2);
				((Vector2)(ref mouse))..ctor(wx, wy);
				foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.ForceBiome])
				{
					if (item.IsInside2D(mouse))
					{
						__result = (Biome)item.OverridenBiome;
						break;
					}
				}
			}
		}

		[HarmonyPatch(typeof(CharacterDrop), "DropItems")]
		[ClientOnlyPatch]
		private static class CharacterDrop_DropItems_Patch
		{
			private static void Prefix(ref List<KeyValuePair<GameObject, int>> drops)
			{
				if (CurrentTerritory != null && CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.DropMultiplier))
				{
					for (int i = 0; i < drops.Count; i++)
					{
						drops[i] = new KeyValuePair<GameObject, int>(drops[i].Key, Mathf.RoundToInt((float)drops[i].Value * CurrentTerritory.DropMultiplier));
					}
				}
			}
		}

		[HarmonyPatch(typeof(Fireplace), "UpdateFireplace")]
		[ClientOnlyPatch]
		private static class UnlimitedFuel1
		{
			private static void Postfix(Fireplace __instance)
			{
				if (CurrentTerritory != null && __instance.m_nview.IsValid() && __instance.m_nview.IsOwner() && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.InfiniteFuel))
				{
					__instance.m_nview.m_zdo.Set("fuel", __instance.m_maxFuel);
				}
			}
		}

		[HarmonyPatch(typeof(Smelter), "UpdateSmelter")]
		[ClientOnlyPatch]
		private static class UnlimitedFuel2
		{
			private static void Postfix(Smelter __instance)
			{
				if (CurrentTerritory != null && __instance.m_nview.IsValid() && __instance.m_nview.IsOwner() && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.InfiniteFuel))
				{
					__instance.m_nview.m_zdo.Set("fuel", __instance.m_maxFuel);
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "UpdateCooking")]
		[ClientOnlyPatch]
		private static class UnlimitedFuel3
		{
			private static void Postfix(CookingStation __instance)
			{
				if (CurrentTerritory != null && __instance.m_nview.IsValid() && __instance.m_nview.IsOwner() && CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.InfiniteFuel))
				{
					__instance.m_nview.m_zdo.Set("fuel", __instance.m_maxFuel);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "CreateTombStone")]
		[ClientOnlyPatch]
		private static class Player_CreateTombStone_Patch
		{
			private static bool Prefix()
			{
				if (CurrentTerritory != null)
				{
					return !CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.NoItemLoss);
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(EnvMan), "SetTargetWind")]
		[ClientOnlyPatch]
		private static class EnvMan_SetTargetWind_Patch
		{
			private static void ToCall()
			{
				if (CurrentTerritory != null && CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.ForceWind))
				{
					EnvMan.instance.m_windDir2.w = CurrentTerritory.Wind;
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> code)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				List<CodeInstruction> list = code.ToList();
				list.Insert(list.Count - 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EnvMan_SetTargetWind_Patch), "ToCall", (Type[])null, (Type[])null)));
				return list;
			}
		}

		[HarmonyPatch(typeof(Heightmap), "ApplyModifiers")]
		[ClientOnlyPatch]
		private static class TerrainComp_ApplyToHeightmap_Patch
		{
			private static void Postfix(Heightmap __instance)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: 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_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_isDistantLod || TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.CustomPaint].Count == 0)
				{
					return;
				}
				Vector3 val = ((Component)__instance).transform.position - new Vector3((float)__instance.m_width * __instance.m_scale * 0.5f, 0f, (float)__instance.m_width * __instance.m_scale * 0.5f);
				bool flag = false;
				for (int i = 0; i < __instance.m_width; i++)
				{
					for (int j = 0; j < __instance.m_width; j++)
					{
						float num = val.x + (float)i;
						float num2 = val.z + (float)j;
						foreach (TerritorySystem_DataTypes.Territory item in TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.CustomPaint])
						{
							if (item.IsInside2D(new Vector2(num, num2)))
							{
								Color val2 = (Color)(item.PaintGround switch
								{
									TerritorySystem_DataTypes.PaintType.Paved => Color.blue, 
									TerritorySystem_DataTypes.PaintType.Grass => Color.black, 
									TerritorySystem_DataTypes.PaintType.Cultivated => Color.green, 
									TerritorySystem_DataTypes.PaintType.Dirt => Color.red, 
									_ => Color.black, 
								});
								flag = true;
								__instance.m_paintMask.SetPixel(i, j, val2);
								break;
							}
						}
					}
				}
				if (flag)
				{
					__instance.m_paintMask.Apply();
				}
			}
		}

		[HarmonyPatch(typeof(Heightmap), "RebuildRenderMesh")]
		[ClientOnlyPatch]
		private static class TerrainComp_ApplyToHeightmap_Patch_SnowMask
		{
			private static void Postfix(Heightmap __instance)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				if (TerritoriesByFlags_Additional[TerritorySystem_DataTypes.AdditionalTerritoryFlags.SnowMask].Count == 0)
				{
					return;
				}
				Vector3 val = ((Component)__instance).transform.position - new Vector3((float)__instance.m_width * __instance.m_scale * 0.5f, 0f, (float)__instance.m_width * __instance.m_scale * 0.5f);
				int num = __instance.m_width + 1;
				bool flag = false;
				Heightmap.s_tempColors.Clear();
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < num; j++)
					{
						float num2 = val.x + (float)j;
						float num3 = val.z + (float)i;
						using List<TerritorySystem_DataTypes.Territory>.Enumerator enumerator = TerritoriesByFlags_Additional[TerritorySystem_DataTypes.AdditionalTerritoryFlags.SnowMask].GetEnumerator();
						if (enumerator.MoveNext())
						{
							TerritorySystem_DataTypes.Territory current = enumerator.Current;
							if (!current.IsInside2D(new Vector2(num2, num3)))
							{
								Biome biome = WorldGenerator.instance.GetBiome(num2, num3, 0.02f, false);
								Heightmap.s_tempColors.Add(Heightmap.GetBiomeColor(biome));
							}
							else
							{
								Heightmap.s_tempColors.Add(Heightmap.GetBiomeColor((Biome)4));
								flag = true;
							}
						}
					}
				}
				if (flag)
				{
					__instance.m_renderMesh.SetColors(Heightmap.s_tempColors);
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
		[ClientOnlyPatch]
		private static class PatchClickIconMinimap
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static PopupButtonCallback <>9__0_2;

				public static PopupButtonCallback <>9__0_4;

				internal void <Prefix>b__0_2()
				{
					UnifiedPopup.Pop();
				}

				internal void <Prefix>b__0_4()
				{
					UnifiedPopup.Pop();
				}
			}

			[UsedImplicitly]
			private static bool Prefix()
			{
				//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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				//IL_00fb: Expected O, but got Unknown
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Expected O, but got Unknown
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Expected O, but got Unknown
				Vector3 pos = Minimap.instance.ScreenToWorldPoint(Input.mousePosition);
				TerritorySystem_DataTypes.Territory forSaleTerritory = ForSaleTerritories.FirstOrDefault((TerritorySystem_DataTypes.Territory t) => t.IsInside(pos));
				if (forSaleTerritory != null)
				{
					if (string.IsNullOrWhiteSpace(forSaleTerritory.Owner))
					{
						string text = $"Do you wanna buy this territory for <color=yellow>{forSaleTerritory.SellPrice} Coins</color> ?";
						PopupButtonCallback val = delegate
						{
							UnifiedPopup.Pop();
							ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket TerritorySystem GetOwnership", new object[1] { forSaleTerritory.UID });
						};
						object obj = <>c.<>9__0_2;
						if (obj == null)
						{
							PopupButtonCallback val2 = delegate
							{
								UnifiedPopup.Pop();
							};
							<>c.<>9__0_2 = val2;
							obj = (object)val2;
						}
						UnifiedPopup.Push((PopupBase)new YesNoPopup("Territory purchase", text, val, (PopupButtonCallback)obj, true));
					}
					if (forSaleTerritory.Owner == Global_Configs._localUserID)
					{
						PopupButtonCallback val3 = delegate
						{
							UnifiedPopup.Pop();
							ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket TerritorySystem CancelOwnership", new object[1] { forSaleTerritory.UID });
						};
						object obj2 = <>c.<>9__0_4;
						if (obj2 == null)
						{
							PopupButtonCallback val4 = delegate
							{
								UnifiedPopup.Pop();
							};
							<>c.<>9__0_4 = val4;
							obj2 = (object)val4;
						}
						UnifiedPopup.Push((PopupBase)new YesNoPopup("Cancel territory ownership", "Do you wanna cancel this territory ownership ?", val3, (PopupButtonCallback)obj2, true));
					}
					return false;
				}
				return true;
			}
		}

		public static TerritorySystem_DataTypes.Territory CurrentTerritory;

		private static Color[] originalMapColors = null;

		private static Color[] originalHeightColors = null;

		private static readonly int Pulse = Animator.StringToHash("pulse");

		public static readonly Dictionary<TerritorySystem_DataTypes.TerritoryFlags, List<TerritorySystem_DataTypes.Territory>> TerritoriesByFlags = new Dictionary<TerritorySystem_DataTypes.TerritoryFlags, List<TerritorySystem_DataTypes.Territory>>();

		public static readonly Dictionary<TerritorySystem_DataTypes.AdditionalTerritoryFlags, List<TerritorySystem_DataTypes.Territory>> TerritoriesByFlags_Additional = new Dictionary<TerritorySystem_DataTypes.AdditionalTerritoryFlags, List<TerritorySystem_DataTypes.Territory>>();

		public static readonly List<TerritorySystem_DataTypes.Territory> ForSaleTerritories = new List<TerritorySystem_DataTypes.Territory>();

		private static float ZoneTick;

		private static DateTime LastNoAccessMesssage;

		private static ConfigEntry<bool> UseMapDraw;

		public static ConfigEntry<bool> AlwaysShowZoneVisualizer;

		private static int MapMagicCounter;

		[UsedImplicitly]
		private static void OnInit()
		{
			UseMapDraw = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("Territories", "Use Map Draw", true, (ConfigDescription)null);
			AlwaysShowZoneVisualizer = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("Territories", "Always Show Zone Visualizer", false, (ConfigDescription)null);
			TerritorySystem_DataTypes.TerritoryFlags[] allTerritoryFlagsArray = TerritorySystem_DataTypes.AllTerritoryFlagsArray;
			foreach (TerritorySystem_DataTypes.TerritoryFlags key in allTerritoryFlagsArray)
			{
				TerritoriesByFlags[key] = new List<TerritorySystem_DataTypes.Territory>();
			}
			TerritorySystem_DataTypes.AdditionalTerritoryFlags[] allAdditionaTerritoryFlagsArray = TerritorySystem_DataTypes.AllAdditionaTerritoryFlagsArray;
			foreach (TerritorySystem_DataTypes.AdditionalTerritoryFlags key2 in allAdditionaTerritoryFlagsArray)
			{
				TerritoriesByFlags_Additional[key2] = new List<TerritorySystem_DataTypes.Territory>();
			}
			TerritorySystem_DataTypes.SyncedTerritoriesData.ValueChanged += OnTerritoryUpdate;
			Marketplace.Global_FixedUpdator = (Action<float>)Delegate.Combine(Marketplace.Global_FixedUpdator, new Action<float>(TerritoryFixedUpdate));
			Guilds.API.RegisterOnGuildJoined(guildsAPI_CacheClear);
			Guilds.API.RegisterOnGuildLeft(guildsAPI_CacheClear);
		}

		private static void guildsAPI_CacheClear(Guild guild, Guilds.PlayerReference playerReference)
		{
			TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.ForEach(delegate(TerritorySystem_DataTypes.Territory t)
			{
				t.ClearOwnerCache();
			});
		}

		private static void TerritoryFixedUpdate(float dt)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			ZoneTick -= Time.fixedDeltaTime;
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			Vector3 position = ((Component)localPlayer).transform.position;
			CurrentTerritory = TerritorySystem_DataTypes.Territory.GetCurrentTerritory(position);
			if (CurrentTerritory == null)
			{
				return;
			}
			if (CurrentTerritory.Wind != 0f)
			{
				EnvMan.instance.m_windDir2.w = CurrentTerritory.Wind;
			}
			if (Object.op_Implicit((Object)(object)ParticleMist.instance) && Object.op_Implicit((Object)(object)ParticleMist.instance.m_ps))
			{
				EmissionModule emission;
				if (CurrentTerritory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.NoMist))
				{
					emission = ParticleMist.instance.m_ps.emission;
					if (((EmissionModule)(ref emission)).enabled)
					{
						EmissionModule emission2 = ParticleMist.instance.m_ps.emission;
						((EmissionModule)(ref emission2)).enabled = false;
					}
				}
				else
				{
					emission = ParticleMist.instance.m_ps.emission;
					if (!((EmissionModule)(ref emission)).enabled)
					{
						EmissionModule emission3 = ParticleMist.instance.m_ps.emission;
						((EmissionModule)(ref emission3)).enabled = true;
					}
				}
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.PushAway) && !CurrentTerritory.IsPermitted())
			{
				float num = Time.fixedDeltaTime * 7f;
				Vector3 position2 = ((Component)localPlayer).transform.position;
				Vector3 val = ((Component)localPlayer).transform.position - CurrentTerritory.Pos3D();
				Vector3 val2 = position2 + ((Vector3)(ref val)).normalized * num;
				((Character)localPlayer).m_body.isKinematic = true;
				((Component)localPlayer).transform.position = new Vector3(val2.x, ((Component)localPlayer).transform.position.y, val2.z);
				((Character)localPlayer).m_body.isKinematic = false;
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.PveOnly))
			{
				localPlayer.SetPVP(false);
				((Humanoid)localPlayer).m_lastCombatTimer = 0f;
				InventoryGui.instance.m_pvp.isOn = false;
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.PvpOnly))
			{
				localPlayer.SetPVP(true);
				((Humanoid)localPlayer).m_lastCombatTimer = 0f;
				InventoryGui.instance.m_pvp.isOn = true;
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.PeriodicDamage) && !CurrentTerritory.IsPermitted() && ZoneTick <= 0f)
			{
				HitData val3 = new HitData();
				val3.m_damage.m_fire = CurrentTerritory.PeriodicDamageValue;
				((Character)localPlayer).Damage(val3);
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.PeriodicHealALL) && ZoneTick <= 0f)
			{
				((Character)localPlayer).Heal(CurrentTerritory.PeriodicHealValue, true);
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.PeriodicHeal) && CurrentTerritory.IsPermitted() && ZoneTick <= 0f)
			{
				((Character)localPlayer).Heal(CurrentTerritory.PeriodicHealValue, true);
			}
			if (CurrentTerritory.Flags.HasFlagFast(TerritorySystem_DataTypes.TerritoryFlags.CustomEnvironment))
			{
				EnvMan.instance.SetForceEnvironment(GetCurrentEnvironment(CurrentTerritory.CustomEnvironment, (int)EnvMan.instance.m_totalSeconds));
			}
			if (ZoneTick <= 0f)
			{
				ZoneTick = 1f;
			}
		}

		private static string GetCurrentEnvironment(string[] envs, int m_seconds)
		{
			if (envs.Length == 0)
			{
				return "";
			}
			if (envs.Length == 1)
			{
				return envs[0];
			}
			int num = m_seconds / 1200 % envs.Length;
			return envs[num];
		}

		private static void OnTerritoryUpdate()
		{
			ClientSide.FillingTerritoryData = true;
			foreach (KeyValuePair<TerritorySystem_DataTypes.TerritoryFlags, List<TerritorySystem_DataTypes.Territory>> territoriesByFlag in TerritoriesByFlags)
			{
				territoriesByFlag.Value.Clear();
			}
			foreach (KeyValuePair<TerritorySystem_DataTypes.AdditionalTerritoryFlags, List<TerritorySystem_DataTypes.Territory>> item in TerritoriesByFlags_Additional)
			{
				item.Value.Clear();
			}
			ForSaleTerritories.Clear();
			if (TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Count == 0)
			{
				ClientSide.FillingTerritoryData = false;
				DoMapMagic();
				return;
			}
			foreach (TerritorySystem_DataTypes.Territory territory in TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories)
			{
				TerritorySystem_DataTypes.TerritoryFlags[] allTerritoryFlagsArray = TerritorySystem_DataTypes.AllTerritoryFlagsArray;
				foreach (TerritorySystem_DataTypes.TerritoryFlags territoryFlags in allTerritoryFlagsArray)
				{
					if (territory.Flags.HasFlagFast(territoryFlags))
					{
						TerritoriesByFlags[territoryFlags].Add(territory);
					}
				}
				TerritorySystem_DataTypes.AdditionalTerritoryFlags[] allAdditionaTerritoryFlagsArray = TerritorySystem_DataTypes.AllAdditionaTerritoryFlagsArray;
				foreach (TerritorySystem_DataTypes.AdditionalTerritoryFlags additionalTerritoryFlags in allAdditionaTerritoryFlagsArray)
				{
					if (territory.AdditionalFlags.HasFlagFast(additionalTerritoryFlags))
					{
						TerritoriesByFlags_Additional[additionalTerritoryFlags].Add(territory);
					}
				}
				if (territory.Type == TerritorySystem_DataTypes.TerritoryType.ForSale)
				{
					ForSaleTerritories.Add(territory);
				}
			}
			TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.ForceGroundHeight].Sort((TerritorySystem_DataTypes.Territory a, TerritorySystem_DataTypes.Territory b) => a.Priority.CompareTo(b.Priority));
			TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.AddGroundHeight].Sort((TerritorySystem_DataTypes.Territory a, TerritorySystem_DataTypes.Territory b) => a.Priority.CompareTo(b.Priority));
			TerritoriesByFlags[TerritorySystem_DataTypes.TerritoryFlags.LimitZoneHeight].Sort((TerritorySystem_DataTypes.Territory a, TerritorySystem_DataTypes.Territory b) => a.Priority.CompareTo(b.Priority));
			ClientSide.FillingTerritoryData = false;
			if (TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw)
			{
				DoMapMagic();
			}
			ZoneVisualizer.OnMapChange();
		}

		private static async void DoMapMagic()
		{
			if (originalMapColors == null || TerritorySystem_DataTypes.SyncedTerritoriesData.Value == null || TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Count == 0 || !UseMapDraw.Value)
			{
				return;
			}
			ResetAndExplore();
			MapMagicCounter++;
			int currentCounter = MapMagicCounter;
			try
			{
				Color[] mapColors = (Color[])(object)new Color[originalMapColors.Length];
				Color[] heightColors = (Color[])(object)new Color[originalHeightColors.Length];
				bool[] copyExplored = new bool[Minimap.instance.m_explored.Length];
				Color[] fogColors = (Color[])(object)new Color[((Texture)Minimap.instance.m_fogTexture).width * ((Texture)Minimap.instance.m_fogTexture).height];
				int segments = Environment.ProcessorCount;
				await Task.Run(delegate
				{
					Array.Copy(Minimap.instance.m_explored, copyExplored, Minimap.instance.m_explored.Length);
					Array.Copy(originalMapColors, mapColors, originalMapColors.Length);
					Array.Copy(originalHeightColors, heightColors, originalHeightColors.Length);
					Array.Copy(Minimap.instance.m_fogTexture.GetPixels(), fogColors, fogColors.Length);
					Parallel.ForEach(Enumerable.Range(0, segments), delegate(int segment)
					{
						//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
						//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
						//IL_045c: Unknown result type (might be due to invalid IL or missing references)
						//IL_045e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0463: Unknown result type (might be due to invalid IL or missing references)
						//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
						//IL_0304: Unknown result type (might be due to invalid IL or missing references)
						//IL_0309: Unknown result type (might be due to invalid IL or missing references)
						//IL_0328: Unknown result type (might be due to invalid IL or missing references)
						//IL_032e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0333: Unknown result type (might be due to invalid IL or missing references)
						//IL_0348: Unknown result type (might be due to invalid IL or missing references)
						//IL_034d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0362: Unknown result type (might be due to invalid IL or missing references)
						//IL_0367: Unknown result type (might be due to invalid IL or missing references)
						//IL_0396: Unknown result type (might be due to invalid IL or missing references)
						//IL_039b: Unknown result type (might be due to invalid IL or missing references)
						//IL_037c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0381: Unknown result type (might be due to invalid IL or missing references)
						//IL_0408: Unknown result type (might be due to invalid IL or missing references)
						//IL_040e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0413: Unknown result type (might be due to invalid IL or missing references)
						//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
						//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
						//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
						//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
						//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
						//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
						//IL_042f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0435: Unknown result type (might be due to invalid IL or missing references)
						//IL_043a: Unknown result type (might be due to invalid IL or missing references)
						//IL_049f: Unknown result type (might be due to invalid IL or missing references)
						//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
						//IL_0446: Unknown result type (might be due to invalid IL or missing references)
						//IL_0448: Unknown result type (might be due to invalid IL or missing references)
						//IL_044d: Unknown result type (might be due to invalid IL or missing references)
						//IL_043e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0440: Unknown result type (might be due to invalid IL or missing references)
						float pixelSize = Minimap.instance.m_pixelSize;
						int textureSize = Minimap.instance.m_textureSize;
						int num = textureSize / 2;
						float num2 = pixelSize / 2f;
						int num3 = Mathf.RoundToInt((float)textureSize / (float)segments);
						int num4 = segment * num3;
						int num5 = num4 + num3;
						foreach (TerritorySystem_DataTypes.Territory item in from t in TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories
							where t.DrawOnMap()
							orderby t.Priority
							select t)
						{
							bool flag = item.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.RevealOnMap);
							Color32 color = item.GetColor();
							bool showExternalWater = item.ShowExternalWater;
							TerritorySystem_DataTypes.TerritoryShape shape = item.Shape;
							int num6 = ((shape != TerritorySystem_DataTypes.TerritoryShape.Rectangle) ? (item.Y[0] - item.Radius) : item.Y[0]);
							int i = Mathf.Clamp(Mathf.RoundToInt(((float)num6 + num2) / pixelSize + (float)num), num4, num5);
							TerritorySystem_DataTypes.TerritoryShape shape2 = item.Shape;
							num6 = ((shape2 != TerritorySystem_DataTypes.TerritoryShape.Rectangle) ? (item.Y[0] + item.Radius) : (item.Y[0] + item.Y[1]));
							for (int num7 = Mathf.Clamp(Mathf.RoundToInt(((float)num6 + num2) / pixelSize + (float)num), num4, num5); i < num7; i++)
							{
								int j = 0;
								int num8 = 0;
								switch (item.Shape)
								{
								case TerritorySystem_DataTypes.TerritoryShape.Rectangle:
									j = Mathf.RoundToInt(((float)item.X[0] + num2) / pixelSize + (float)num);
									num8 = Mathf.RoundToInt(((float)(item.X[0] + item.X[1]) + num2) / pixelSize + (float)num);
									break;
								case TerritorySystem_DataTypes.TerritoryShape.Square:
									j = Mathf.RoundToInt(((float)(item.X[0] - item.Radius) + num2) / pixelSize + (float)num);
									num8 = Mathf.RoundToInt(((float)(item.X[0] + item.Radius) + num2) / pixelSize + (float)num);
									break;
								case TerritorySystem_DataTypes.TerritoryShape.Circle:
								{
									float num9 = Mathf.Cos(Mathf.Asin(((float)(i - num) * pixelSize - num2 - (float)item.Y[0]) / (float)item.Radius)) * (float)item.Radius;
									j = Mathf.RoundToInt(((float)item.X[0] - num9 + num2) / pixelSize + (float)num);
									num8 = Mathf.RoundToInt(((float)item.X[0] + num9 + num2) / pixelSize + (float)num);
									break;
								}
								}
								for (; j < num8; j++)
								{
									int num10 = i * textureSize + j;
									if (item.UsingGradient())
									{
										Color[] array = mapColors;
										int num11 = num10;
										array[num11] = Color32.op_Implicit((Color32)(item.GradientType switch
										{
											TerritorySystem_DataTypes.GradientType.FromCenter => item.GetGradientFromCenter(new Vector2((float)(j - 1024) * pixelSize, (float)(i - 1024) * pixelSize)), 
											TerritorySystem_DataTypes.GradientType.ToCenter => item.GetGradientFromCenter(new Vector2((float)(j - 1024) * pixelSize, (float)(i - 1024) * pixelSize), reverse: true), 
											TerritorySystem_DataTypes.GradientType.LeftRight => item.GetGradientX((float)(j - 1024) * pixelSize), 
											TerritorySystem_DataTypes.GradientType.RightLeft => item.GetGradientX((float)(j - 1024) * pixelSize, reverse: true), 
											TerritorySystem_DataTypes.GradientType.BottomTop => item.GetGradientY((float)(i - 1024) * pixelSize), 
											TerritorySystem_DataTypes.GradientType.TopBottom => item.GetGradientY((float)(i - 1024) * pixelSize, reverse: true), 
											TerritorySystem_DataTypes.GradientType.BottomLeftTopRight => item.GetGradientXY(new Vector2((float)(j - 1024) * pixelSize, (float)(i - 1024) * pixelSize)), 
											TerritorySystem_DataTypes.GradientType.TopRightBottomLeft => item.GetGradientXY(new Vector2((float)(j - 1024) * pixelSize, (float)(i - 1024) * pixelSize), reverse: true), 
											TerritorySystem_DataTypes.GradientType.BottomRightTopLeft => item.GetGradientXY_2(new Vector2((float)(j - 1024) * pixelSize, (float)(i - 1024) * pixelSize)), 
											TerritorySystem_DataTypes.GradientType.TopLeftBottomRight => item.GetGradientXY_2(new Vector2((float)(j - 1024) * pixelSize, (float)(i - 1024) * pixelSize), reverse: true), 
											_ => color, 
										}));
									}
									else
									{
										mapColors[num10] = Color32.op_Implicit(color);
									}
									if (showExternalWater)
									{
										heightColors[num10] = new Color(Mathf.Clamp(heightColors[num10].r, 29f, 89f), 0f, 0f);
									}
									if (flag)
									{
										fogColors[num10].r = 0f;
									}
								}
							}
						}
					});
				});
				if (currentCounter == MapMagicCounter)
				{
					Minimap.instance.m_mapTexture.SetPixels(mapColors);
					Minimap.instance.m_heightTexture.SetPixels(heightColors);
					Minimap.instance.m_fogTexture.SetPixels(fogColors);
					Minimap.instance.m_mapTexture.Apply(false);
					Minimap.instance.m_heightTexture.Apply(false);
					Minimap.instance.m_fogTexture.Apply(false);
					Minimap.instance.m_explored = copyExplored;
				}
			}
			catch (Exception arg)
			{
				Utils.print($"Error while drawing territories on map: {arg}");
			}
		}

		private static void ResetAndExplore()
		{
			int num = Minimap.instance.m_explored.Length;
			Color[] pixels = (Color[])(object)new Color[((Texture)Minimap.instance.m_fogTexture).width * ((Texture)Minimap.instance.m_fogTexture).height];
			int num2 = Math.Max(1, Environment.ProcessorCount);
			int num3 = (num + num2 - 1) / num2;
			List<(int, int)> list = new List<(int, int)>(num2);
			for (int i = 0; i < num2; i++)
			{
				int num4 = i * num3;
				int num5 = Math.Min(num4 + num3, num);
				if (num4 < num5)
				{
					list.Add((num4, num5));
				}
			}
			Parallel.ForEach<(int, int)>(list, delegate((int start, int end) range)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				var (j, _) = range;
				for (; j < range.end; j++)
				{
					Color white = Color.white;
					if (Minimap.instance.m_explored[j])
					{
						white.r = 0f;
					}
					if (Minimap.instance.m_exploredOthers[j])
					{
						white.g = 0f;
					}
					pixels[j] = white;
				}
			});
			Minimap.instance.m_fogTexture.SetPixels(pixels);
		}

		private static void FakeReveal(Vector3 worldPos, float radius, TerritorySystem_DataTypes.TerritoryShape shape)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (shape == TerritorySystem_DataTypes.TerritoryShape.Rectangle)
			{
				return;
			}
			int pixelRadius = (int)Mathf.Ceil(radius / Minimap.instance.m_pixelSize);
			int pixelX = default(int);
			int pixelY = default(int);
			Minimap.instance.WorldToPixel(worldPos, ref pixelX, ref pixelY);
			Func<int, int, bool> func = default(Func<int, int, bool>);
			switch (shape)
			{
			case TerritorySystem_DataTypes.TerritoryShape.Circle:
				func = delegate(int x, int y)
				{
					//IL_0012: 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)
					Vector2 val = new Vector2((float)(x - pixelX), (float)(y - pixelY));
					return ((Vector2)(ref val)).magnitude <= (float)pixelRadius;
				};
				break;
			case TerritorySystem_DataTypes.TerritoryShape.Square:
				func = (int x, int y) => Mathf.Abs(x - pixelX) <= pixelRadius && Mathf.Abs(y - pixelY) <= pixelRadius;
				break;
			default:
				<d5594bdc-b525-4196-ada5-7f762636b0b9><PrivateImplementationDetails>.ThrowInvalidOperationException();
				break;
			}
			Func<int, int, bool> func2 = func;
			for (int i = pixelY - pixelRadius; i <= pixelY + pixelRadius; i++)
			{
				for (int j = pixelX - pixelRadius; j <= pixelX + pixelRadius; j++)
				{
					if (j >= 0 && i >= 0 && j < Minimap.instance.m_textureSize && i < Minimap.instance.m_textureSize && func2(j, i))
					{
						Color pixel = Minimap.instance.m_fogTexture.GetPixel(j, i);
						pixel.r = 0f;
						Minimap.instance.m_fogTexture.SetPixel(j, i, pixel);
					}
				}
			}
			Minimap.instance.m_fogTexture.Apply();
		}

		private static void DoAreaEffect(Vector3 pos)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (!((DateTime.Now - LastNoAccessMesssage).TotalSeconds <= 2.0))
			{
				LastNoAccessMesssage = DateTime.Now;
				GameObject prefab = ZNetScene.instance.GetPrefab("vfx_lootspawn");
				Object.Instantiate<GameObject>(prefab, pos, Quaternion.identity);
				WorldTextInstance val = new WorldTextInstance
				{
					m_worldPos = pos,
					m_gui = Object.Instantiate<GameObject>(DamageText.instance.m_worldTextBase, ((Component)DamageText.instance).transform)
				};
				val.m_textField = val.m_gui.GetComponent<TMP_Text>();
				DamageText.instance.m_worldTexts.Add(val);
				((Graphic)val.m_textField).color = Color.cyan;
				val.m_textField.fontSize = 24f;
				val.m_textField.text = "NO ACCESS";
				val.m_timer = -2f;
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Normal, "OnInit", new string[] { "TD" }, new string[] { "OnTerritoryConfigChange" })]
	public static class TerritorySystem_Main_Server
	{
		private struct TerritoryOverride
		{
			public string TerritoryFlags;

			public string TerritoryColor;
		}

		private struct TerritoryCompareData
		{
			public Color32[] Colors;

			public int[] X;

			public int[] Y;

			public int Radius;

			public bool ShowOnMap;

			public TerritorySystem_DataTypes.TerritoryShape Shape;

			private bool HasReveal;

			public TerritoryCompareData(TerritorySystem_DataTypes.TerritoryShape shape, Color32[] c, int[] x, int[] y, int radius, bool showOnMap, bool reveal)
			{
				Colors = c;
				X = x;
				Y = y;
				Radius = radius;
				ShowOnMap = showOnMap;
				Shape = shape;
				HasReveal = reveal;
			}

			public bool Equals(TerritoryCompareData other)
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				if (Shape != other.Shape || Colors.Length != other.Colors.Length || X.Length != other.X.Length || Y.Length != other.Y.Length)
				{
					return false;
				}
				if (HasReveal != other.HasReveal)
				{
					return false;
				}
				for (int i = 0; i < Colors.Length; i++)
				{
					if (!((object)(Color32)(ref Colors[i])).Equals((object?)other.Colors[i]))
					{
						return false;
					}
				}
				for (int j = 0; j < X.Length; j++)
				{
					if (X[j] != other.X[j])
					{
						return false;
					}
				}
				for (int k = 0; k < Y.Length; k++)
				{
					if (Y[k] != other.Y[k])
					{
						return false;
					}
				}
				if (Radius != other.Radius)
				{
					return false;
				}
				if (ShowOnMap != other.ShowOnMap)
				{
					return false;
				}
				return true;
			}

			public static bool IsEqual(TerritoryCompareData[] a, TerritoryCompareData[] b)
			{
				if (a == null || b == null)
				{
					return false;
				}
				if (a.Length != b.Length)
				{
					return false;
				}
				for (int i = 0; i < a.Length; i++)
				{
					if (!a[i].Equals(b[i]))
					{
						return false;
					}
				}
				return true;
			}
		}

		private static string TerritoriesForSale;

		private static string TerritoryOverrides;

		private static List<TerritorySystem_DataTypes.Territory> TerritoriesForSaleData = new List<TerritorySystem_DataTypes.Territory>();

		private static Dictionary<string, TerritoryOverride> TerritoriesOverridesData = new Dictionary<string, TerritoryOverride>();

		private static void OnInit()
		{
			TerritoriesForSale = Path.Combine(Market_Paths.TerritoriesFolder, "_InternalMarketplace_TerritoriesForSale.yml");
			TerritoryOverrides = Path.Combine(Market_Paths.TerritoriesFolder, "_InternalMarketplace_TerritoriesFlagOverrides.yml");
			if (File.Exists(TerritoriesForSale))
			{
				string text = File.ReadAllText(TerritoriesForSale);
				if (!string.IsNullOrWhiteSpace(text))
				{
					TerritoriesForSaleData = new Deserializer().Deserialize<List<TerritorySystem_DataTypes.Territory>>(text);
				}
			}
			if (File.Exists(TerritoryOverrides))
			{
				string text2 = File.ReadAllText(TerritoryOverrides);
				if (!string.IsNullOrWhiteSpace(text2))
				{
					TerritoriesOverridesData = new Deserializer().Deserialize<Dictionary<string, TerritoryOverride>>(text2);
				}
			}
			ReadServerTerritoryDatabase();
		}

		private static void OnTerritoryConfigChange()
		{
			ReadServerTerritoryDatabase();
			Utils.print("Territory Changed. Sending new info to all clients");
		}

		private static void ProcessTerritoryConfig(string fPath, IReadOnlyList<string> profiles)
		{
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			string text = "default";
			int priority = 1;
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					string[] array = profiles[i].Replace("[", "").Replace("]", "").Split(new char[1] { '@' });
					text = array[0];
					priority = 1;
					if (array.Length == 2)
					{
						priority = int.Parse(array[1]);
					}
					continue;
				}
				try
				{
					if (i + 4 > profiles.Count)
					{
						break;
					}
					TerritorySystem_DataTypes.Territory territory = new TerritorySystem_DataTypes.Territory
					{
						Name = text,
						Priority = priority
					};
					if (!Enum.TryParse<TerritorySystem_DataTypes.TerritoryShape>(profiles[i], ignoreCase: true, out var result) || !Enum.IsDefined(typeof(TerritorySystem_DataTypes.TerritoryShape), result))
					{
						continue;
					}
					territory.Shape = result;
					string[] array2 = profiles[i + 1].Replace(" ", "").Split(new char[1] { ',' });
					switch (result)
					{
					case TerritorySystem_DataTypes.TerritoryShape.Circle:
					case TerritorySystem_DataTypes.TerritoryShape.Square:
						territory.X = new int[1] { Convert.ToInt32(array2[0]) };
						territory.Y = new int[1] { Convert.ToInt32(array2[1]) };
						territory.Radius = Convert.ToInt32(array2[2]);
						break;
					case TerritorySystem_DataTypes.TerritoryShape.Rectangle:
						territory.X = new int[2]
						{
							Convert.ToInt32(array2[0]),
							Convert.ToInt32(array2[2])
						};
						territory.Y = new int[2]
						{
							Convert.ToInt32(array2[1]),
							Convert.ToInt32(array2[3])
						};
						break;
					}
					string text2 = ((TerritoriesOverridesData.ContainsKey(territory.Name) && !string.IsNullOrWhiteSpace(TerritoriesOverridesData[territory.Name].TerritoryColor)) ? TerritoriesOverridesData[territory.Name].TerritoryColor : profiles[i + 2]);
					List<string> list = text2.Replace(" ", "").Split(new char[1] { ',' }).ToList();
					for (int j = 0; j < list.Count; j++)
					{
						string text3 = list[j].ToLower();
						if ((text3 == "true" || text3 == "false") ? true : false)
						{
							territory.ShowExternalWater = Convert.ToBoolean(list[j]);
							list.RemoveAt(j);
							break;
						}
					}
					for (int k = 0; k < list.Count; k++)
					{
						if (!int.TryParse(list[k], out var _) && Enum.TryParse<TerritorySystem_DataTypes.GradientType>(list[k], ignoreCase: true, out var result3))
						{
							territory.GradientType = result3;
							list.RemoveAt(k);
							break;
						}
					}
					for (int l = 0; l < list.Count; l++)
					{
						if (list[l].ToLower().Contains("exp:"))
						{
							string s = list[l].Split(new char[1] { ':' })[1];
							if (float.TryParse(s, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result4))
							{
								territory.ExponentialValue = result4;
								list.RemoveAt(l);
								break;
							}
						}
					}
					for (int m = 0; m < list.Count; m++)
					{
						if (list[m].ToLower().Contains("heightbounds:"))
						{
							string text4 = list[m].Split(new char[1] { ':' })[1];
							string[] array3 = text4.Split(new char[1] { '-' });
							territory.HeightBounds = (int.Parse(array3[0]), int.Parse(array3[1]));
							list.RemoveAt(m);
							break;
						}
					}
					territory.Colors = new List<Color32>();
					for (int n = 0; n < list.Count; n += 3)
					{
						try
						{
							territory.Colors.Add(new Color32
							{
								r = Convert.ToByte(list[n]),
								g = Convert.ToByte(list[n + 1]),
								b = Convert.ToByte(list[n + 2])
							});
						}
						catch
						{
							break;
						}
					}
					TerritorySystem_DataTypes.TerritoryFlags territoryFlags = TerritorySystem_DataTypes.TerritoryFlags.None;
					TerritorySystem_DataTypes.AdditionalTerritoryFlags additionalTerritoryFlags = TerritorySystem_DataTypes.AdditionalTerritoryFlags.None;
					string input = ((TerritoriesOverridesData.ContainsKey(territory.Name) && !string.IsNullOrWhiteSpace(TerritoriesOverridesData[territory.Name].TerritoryFlags)) ? TerritoriesOverridesData[territory.Name].TerritoryFlags : profiles[i + 3]);
					string[] array4 = input.ReplaceSpacesOutsideQuotes().Split(new char[1] { ',' });
					string[] array5 = array4;
					foreach (string text5 in array5)
					{
						string text6 = "";
						string[] array6 = text5.Split(new char[1] { '=' });
						string value = array6[0];
						if (array6.Length == 2)
						{
							text6 = array6[1];
						}
						TerritorySystem_DataTypes.TerritoryFlags result6;
						if (Enum.TryParse<TerritorySystem_DataTypes.AdditionalTerritoryFlags>(value, ignoreCase: true, out var result5) && Enum.IsDefined(typeof(TerritorySystem_DataTypes.AdditionalTerritoryFlags), result5))
						{
							additionalTerritoryFlags |= result5;
							switch (result5)
							{
							case TerritorySystem_DataTypes.AdditionalTerritoryFlags.ForceWind:
								territory.Wind = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.AdditionalTerritoryFlags.DropMultiplier:
								territory.DropMultiplier = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.AdditionalTerritoryFlags.OnlyForGuild:
								territory.OnlyForGuild = text6;
								break;
							case TerritorySystem_DataTypes.AdditionalTerritoryFlags.OnlyForFaction:
								territory.OnlyForFaction = text6.ToLower();
								break;
							case TerritorySystem_DataTypes.AdditionalTerritoryFlags.CustomJereSpawner:
								territory.CustomSpawnerNames.Add(text6);
								break;
							case TerritorySystem_DataTypes.AdditionalTerritoryFlags.JoinOtherServer:
								territory.JoinOtherServerString = text6;
								break;
							}
						}
						else if (Enum.TryParse<TerritorySystem_DataTypes.TerritoryFlags>(value, ignoreCase: true, out result6) && Enum.IsDefined(typeof(TerritorySystem_DataTypes.TerritoryFlags), result6))
						{
							territoryFlags |= result6;
							switch (result6)
							{
							case TerritorySystem_DataTypes.TerritoryFlags.CustomEnvironment:
								territory.CustomEnvironment = text6.Split(new char[1] { ',' });
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.PeriodicDamage:
								territory.PeriodicDamageValue = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.PeriodicHeal:
							case TerritorySystem_DataTypes.TerritoryFlags.PeriodicHealALL:
								territory.PeriodicHealValue = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.IncreasedMonsterDamage:
								territory.IncreasedMonsterDamageValue = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.IncreasedPlayerDamage:
								territory.IncreasedPlayerDamageValue = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.MoveSpeedMultiplier:
								territory.MoveSpeedMultiplier = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.LimitZoneHeight:
							case TerritorySystem_DataTypes.TerritoryFlags.ForceGroundHeight:
							case TerritorySystem_DataTypes.TerritoryFlags.AddGroundHeight:
								territory.OverridenHeight = Convert.ToSingle(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.ForceBiome:
								territory.OverridenBiome = Convert.ToInt32(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.MonstersAddStars:
								territory.AddMonsterLevel = Convert.ToInt32(text6, new CultureInfo("en-US"));
								break;
							case TerritorySystem_DataTypes.TerritoryFlags.CustomPaint:
								territory.PaintGround = (TerritorySystem_DataTypes.PaintType)Convert.ToInt32(text6, new CultureInfo("en-US"));
								break;
							}
						}
					}
					territory.Permitted = (string.IsNullOrEmpty(profiles[i + 4]) ? "None" : profiles[i + 4].Replace(" ", ""));
					territory.Flags = territoryFlags;
					territory.AdditionalFlags = additionalTerritoryFlags;
					TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Add(territory);
				}
				catch (Exception arg)
				{
					Utils.print($"Error loading zone profile {text} in {fPath}:\n{arg}", ConsoleColor.Red);
				}
			}
		}

		private static TerritoryCompareData[] GetTerritoryCompareData()
		{
			TerritoryCompareData[] array = new TerritoryCompareData[TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Count];
			for (int i = 0; i < TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Count; i++)
			{
				TerritorySystem_DataTypes.Territory territory = TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories[i];
				array[i] = new TerritoryCompareData(territory.Shape, territory.Colors.ToArray(), territory.X, territory.Y, territory.Radius, territory.ShowExternalWater, territory.AdditionalFlags.HasFlagFast(TerritorySystem_DataTypes.AdditionalTerritoryFlags.RevealOnMap));
			}
			return array;
		}

		private static void ReadServerTerritoryDatabase()
		{
			TerritoryCompareData[] territoryCompareData = GetTerritoryCompareData();
			TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Clear();
			string territoriesFolder = Market_Paths.TerritoriesFolder;
			string[] files = Directory.GetFiles(territoriesFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ProcessTerritoryConfig(text, profiles);
			}
			TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.AddRange(TerritoriesForSaleData);
			TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Sort((TerritorySystem_DataTypes.Territory x, TerritorySystem_DataTypes.Territory y) => y.Priority.CompareTo(x.Priority));
			TerritoryCompareData[] territoryCompareData2 = GetTerritoryCompareData();
			TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw = !TerritoryCompareData.IsEqual(territoryCompareData, territoryCompareData2);
			TerritorySystem_DataTypes.SyncedTerritoriesData.Update();
		}

		private static void SaveForSaleTerritories()
		{
			List<TerritorySystem_DataTypes.Territory> list = new List<TerritorySystem_DataTypes.Territory>();
			foreach (TerritorySystem_DataTypes.Territory territory in TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories)
			{
				if (territory.Type == TerritorySystem_DataTypes.TerritoryType.ForSale)
				{
					list.Add(territory);
				}
			}
			File.WriteAllText(TerritoriesForSale, new Serializer().Serialize(list));
		}

		public static void AddOverrideFlagAndSave(string territoryName, string flag, string color)
		{
			TerritoriesOverridesData[territoryName] = new TerritoryOverride
			{
				TerritoryFlags = flag,
				TerritoryColor = color
			};
			File.WriteAllText(TerritoryOverrides, new Serializer().Serialize(TerritoriesOverridesData));
			OnTerritoryConfigChange();
		}

		[MarketplaceRPC("KGmarket TerritorySystem AddTerritory", Market_Autoload.Type.Server)]
		private static void AddTerritory(long sender, ZPackage pkg)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				TerritorySystem_DataTypes.Territory territory = new TerritorySystem_DataTypes.Territory();
				territory.Shape = (TerritorySystem_DataTypes.TerritoryShape)pkg.ReadInt();
				territory.X = new int[1] { pkg.ReadInt() };
				territory.Y = new int[1] { pkg.ReadInt() };
				territory.Radius = pkg.ReadInt();
				territory.Colors = new List<Color32>(1)
				{
					new Color32(pkg.ReadByte(), pkg.ReadByte(), pkg.ReadByte(), byte.MaxValue)
				};
				territory.Type = TerritorySystem_DataTypes.TerritoryType.ForSale;
				territory.SellPrice = pkg.ReadInt();
				territory.ShowExternalWater = false;
				territory.Name = "Free Territory";
				TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Add(territory);
				SaveForSaleTerritories();
				TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw = true;
				TerritorySystem_DataTypes.SyncedTerritoriesData.Update();
			}
		}

		[MarketplaceRPC("KGmarket TerritorySystem RemoveTerritory", Market_Autoload.Type.Server)]
		private static void RemoveTerritory(long sender, ZPackage pkg)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				int uid = pkg.ReadInt();
				TerritorySystem_DataTypes.Territory territory = TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Find((TerritorySystem_DataTypes.Territory t) => t.Type == TerritorySystem_DataTypes.TerritoryType.ForSale && t.UID == uid);
				if (territory != null)
				{
					TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Remove(territory);
					SaveForSaleTerritories();
					TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw = true;
					TerritorySystem_DataTypes.SyncedTerritoriesData.Update();
				}
			}
		}

		[MarketplaceRPC("KGmarket TerritorySystem GetOwnership", Market_Autoload.Type.Server)]
		private static void BuyTerritory(long sender, int uid)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				TerritorySystem_DataTypes.Territory territory = TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Find((TerritorySystem_DataTypes.Territory t) => t.Type == TerritorySystem_DataTypes.TerritoryType.ForSale && t.UID == uid);
				if (territory != null && string.IsNullOrWhiteSpace(territory.Owner))
				{
					territory.Owner = peer.m_socket.GetHostName();
					SaveForSaleTerritories();
					TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw = false;
					TerritorySystem_DataTypes.SyncedTerritoriesData.Update();
				}
			}
		}

		[MarketplaceRPC("KGmarket TerritorySystem CancelOwnership", Market_Autoload.Type.Server)]
		private static void SellTerritory(long sender, ZPackage pkg)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				int uid = pkg.ReadInt();
				TerritorySystem_DataTypes.Territory territory = TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Find((TerritorySystem_DataTypes.Territory t) => t.Type == TerritorySystem_DataTypes.TerritoryType.ForSale && t.UID == uid);
				if (territory != null && territory.Owner == peer.m_socket.GetHostName())
				{
					territory.Owner = "";
					SaveForSaleTerritories();
					TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw = false;
					TerritorySystem_DataTypes.SyncedTerritoriesData.Update();
				}
			}
		}

		public static void CreateOrUpdateTerritory(string name, int x, int y, Color32 color, TerritorySystem_DataTypes.TerritoryShape shape, int radius, TerritorySystem_DataTypes.TerritoryFlags flags, TerritorySystem_DataTypes.AdditionalTerritoryFlags flags2, string owners)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			string name2 = name;
			TerritorySystem_DataTypes.Territory[] source = TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Where((TerritorySystem_DataTypes.Territory t) => t.Type == TerritorySystem_DataTypes.TerritoryType.ForSale).ToArray();
			TerritorySystem_DataTypes.Territory territory = source.FirstOrDefault((TerritorySystem_DataTypes.Territory t) => t.Name == name2);
			if (territory != null)
			{
				territory.X = new int[1] { x };
				territory.Y = new int[1] { y };
				territory.Shape = shape;
				territory.Radius = radius;
				territory.Colors = new List<Color32>(1) { color };
				territory.Flags = flags;
				territory.AdditionalFlags = flags2;
				territory.Owner = owners;
				territory.Type = TerritorySystem_DataTypes.TerritoryType.ForSale;
				SaveForSaleTerritories();
				TerritorySystem_DataTypes.SyncedTerritoriesData.Value.ShouldRedraw = true;
				TerritorySystem_DataTypes.SyncedTerritoriesData.Update();
			}
			else
			{
				TerritorySystem_DataTypes.Territory territory2 = new TerritorySystem_DataTypes.Territory();
				territory2.Name = name2;
				territory2.X = new int[1] { x };
				territory2.Y = new int[1] { y };
				territory2.Shape = shape;
				territory2.Radius = radius;
				territory2.Flags = flags;
				territory2.AdditionalFlags = flags2;
				territory2.Owner = owners;
				territory2.Colors = new List<Color32>(1) { color };
				territory2.ShowExternalWater = false;
				territory2.Type = TerritorySystem_DataTypes.TerritoryType.ForSale;
				TerritorySystem_DataTypes.Territory item = territory2;
				TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.Add(item);
			}
		}
	}
}
namespace Marketplace.Modules.NPC
{
	public static class NPC_DataTypes
	{
		public struct NPC_Main
		{
			public Market_NPC.NPCType Type;

			public string NameOverride;

			public string Profile;

			public string Prefab;

			public string Dialogue;

			public string PinIcon;

			public string IMAGE;

			public string Description()
			{
				string text = $"<color=yellow>Type:</color> {Type}. ";
				if (!string.IsNullOrEmpty(NameOverride))
				{
					text = text + "<color=yellow>Name:</color> " + NameOverride + ". ";
				}
				if (!string.IsNullOrEmpty(Profile))
				{
					text = text + "<color=yellow>Profile:</color> " + Profile + ". ";
				}
				if (!string.IsNullOrEmpty(Prefab))
				{
					text = text + "<color=yellow>MovelOverride:</color> " + Prefab + ". ";
				}
				if (!string.IsNullOrEmpty(Dialogue))
				{
					text = text + "<color=yellow>Dialogue:</color> " + Dialogue + ". ";
				}
				if (!string.IsNullOrEmpty(PinIcon))
				{
					text = text + "<color=yellow>PinIcon:</color> " + PinIcon + ". ";
				}
				return text;
			}
		}

		public struct NPC_Fashion : ISerializableParameter
		{
			public string LeftItem;

			public string RightItem;

			public string HelmetItem;

			public string ChestItem;

			public string LegsItem;

			public string CapeItem;

			public string HairItem;

			public string HairColor;

			public string ModelScale;

			public string LeftItemHidden;

			public string RightItemHidden;

			public string InteractAnimation;

			public string GreetAnimation;

			public string ByeAnimation;

			public string GreetText;

			public string ByeText;

			public string SkinColor;

			public string CraftingAnimation;

			public string BeardItem;

			public string BeardColor;

			public string InteractAudioClip;

			public string TextSize;

			public string TextHeight;

			public string PeriodicAnimation;

			public string PeriodicAnimationTime;

			public string PeriodicSound;

			public string PeriodicSoundTime;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(LeftItem ?? "");
				pkg.Write(RightItem ?? "");
				pkg.Write(HelmetItem ?? "");
				pkg.Write(ChestItem ?? "");
				pkg.Write(LegsItem ?? "");
				pkg.Write(CapeItem ?? "");
				pkg.Write(HairItem ?? "");
				pkg.Write(HairColor ?? "");
				pkg.Write(ModelScale ?? "");
				pkg.Write(LeftItemHidden ?? "");
				pkg.Write(RightItemHidden ?? "");
				pkg.Write(InteractAnimation ?? "");
				pkg.Write(GreetAnimation ?? "");
				pkg.Write(ByeAnimation ?? "");
				pkg.Write(GreetText ?? "");
				pkg.Write(ByeText ?? "");
				pkg.Write(SkinColor ?? "");
				pkg.Write(CraftingAnimation ?? "");
				pkg.Write(BeardItem ?? "");
				pkg.Write(BeardColor ?? "");
				pkg.Write(InteractAudioClip ?? "");
				pkg.Write(TextSize ?? "");
				pkg.Write(TextHeight ?? "");
				pkg.Write(PeriodicAnimation ?? "");
				pkg.Write(PeriodicAnimationTime ?? "");
				pkg.Write(PeriodicSound ?? "");
				pkg.Write(PeriodicSoundTime ?? "");
			}

			public void Deserialize(ref ZPackage pkg)
			{
				LeftItem = pkg.ReadString();
				RightItem = pkg.ReadString();
				HelmetItem = pkg.ReadString();
				ChestItem = pkg.ReadString();
				LegsItem = pkg.ReadString();
				CapeItem = pkg.ReadString();
				HairItem = pkg.ReadString();
				HairColor = pkg.ReadString();
				ModelScale = pkg.ReadString();
				LeftItemHidden = pkg.ReadString();
				RightItemHidden = pkg.ReadString();
				InteractAnimation = pkg.ReadString();
				GreetAnimation = pkg.ReadString();
				ByeAnimation = pkg.ReadString();
				GreetText = pkg.ReadString();
				ByeText = pkg.ReadString();
				SkinColor = pkg.ReadString();
				CraftingAnimation = pkg.ReadString();
				BeardItem = pkg.ReadString();
				BeardColor = pkg.ReadString();
				InteractAudioClip = pkg.ReadString();
				TextSize = pkg.ReadString();
				TextHeight = pkg.ReadString();
				PeriodicAnimation = pkg.ReadString();
				PeriodicAnimationTime = pkg.ReadString();
				PeriodicSound = pkg.ReadString();
				PeriodicSoundTime = pkg.ReadString();
			}

			public void ApplyRandom()
			{
				LeftItem = LeftItem.RandomSplitSpace();
				RightItem = RightItem.RandomSplitSpace();
				HelmetItem = HelmetItem.RandomSplitSpace();
				ChestItem = ChestItem.RandomSplitSpace();
				LegsItem = LegsItem.RandomSplitSpace();
				CapeItem = CapeItem.RandomSplitSpace();
				HairItem = HairItem.RandomSplitSpace();
				HairColor = HairColor.RandomSplitSpace();
				LeftItemHidden = LeftItemHidden.RandomSplitSpace();
				RightItemHidden = RightItemHidden.RandomSplitSpace();
				InteractAnimation = InteractAnimation.RandomSplitSpace();
				GreetAnimation = GreetAnimation.RandomSplitSpace();
				ByeAnimation = ByeAnimation.RandomSplitSpace();
				SkinColor = SkinColor.RandomSplitSpace();
				CraftingAnimation = CraftingAnimation.RandomSplitSpace();
				BeardItem = BeardItem.RandomSplitSpace();
				BeardColor = BeardColor.RandomSplitSpace();
				PeriodicAnimation = PeriodicAnimation.RandomSplitSpace();
			}
		}
	}
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class NPC_MapController
	{
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		[ClientOnlyPatch]
		private static class Terminal_InitTerminal_Patch
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_0;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					EnableMapControl.Value = !EnableMapControl.Value;
					((BaseUnityPlugin)Marketplace._thistype).Config.Save();
					args.Context.AddString("Map control is now " + (EnableMapControl.Value ? "<color=green>enabled</color>" : "<color=red>disabled</color>"));
				}
			}

			[UsedImplicitly]
			private static void Postfix(Terminal __instance)
			{
				//IL_0032: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						EnableMapControl.Value = !EnableMapControl.Value;
						((BaseUnityPlugin)Marketplace._thistype).Config.Save();
						args.Context.AddString("Map control is now " + (EnableMapControl.Value ? "<color=green>enabled</color>" : "<color=red>disabled</color>"));
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("mmapcontrol", "Enable / Disable map control", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[HarmonyPatch(typeof(Minimap), "GetSprite")]
		[ClientOnlyPatch]
		private static class Minimap_GetSprite_Patch
		{
			[UsedImplicitly]
			private static void Postfix(PinType type, ref Sprite __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Invalid comparison between Unknown and I4
				if ((int)type == 72)
				{
					__result = AssetStorage.NPC_MapControl;
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		[ClientOnlyPatch]
		private static class NPC_MapControllerPatch
		{
			public static void ReapplyPins()
			{
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Expected O, but got Unknown
				foreach (KeyValuePair<PinData, ZDO> pin in _pins)
				{
					Minimap.instance.RemovePin(pin.Key);
				}
				_pins.Clear();
				List<ZDO> list = new List<ZDO>();
				int num = 0;
				while (!ZDOMan.instance.GetAllZDOsWithPrefabIterative("MarketPlaceNPC", list, ref num))
				{
				}
				foreach (ZDO item in list)
				{
					if (item.IsValid())
					{
						string text = item.GetString("KGnpcNameOverride", "");
						int @int = item.GetInt("KGmarketNPC", 0);
						if (string.IsNullOrWhiteSpace(text))
						{
							Localization instance = Localization.instance;
							Market_NPC.NPCType nPCType = (Market_NPC.NPCType)@int;
							text = instance.Localize("$" + nPCType);
						}
						PinData val = new PinData
						{
							m_type = (PinType)72,
							m_name = Utils.RichTextFormatting(text),
							m_pos = item.GetPosition()
						};
						if (!string.IsNullOrEmpty(val.m_name))
						{
							val.m_NamePinData = new PinNameData(val);
						}
						val.m_icon = AssetStorage.NPC_MapControl;
						val.m_save = false;
						val.m_checked = false;
						val.m_ownerID = 0L;
						_pins.Add(val, item);
					}
				}
				foreach (KeyValuePair<PinData, ZDO> pin2 in _pins)
				{
					Minimap.instance.m_pins.Add(pin2.Key);
				}
			}

			[UsedImplicitly]
			private static void Prefix(Minimap __instance, MapMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Invalid comparison between Unknown and I4
				if ((int)mode != 2)
				{
					foreach (KeyValuePair<PinData, ZDO> pin in _pins)
					{
						__instance.RemovePin(pin.Key);
					}
					_pins.Clear();
				}
				if ((int)mode == 2 && Utils.IsDebug_Strict && EnableMapControl.Value)
				{
					ReapplyPins();
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
		[ClientOnlyPatch]
		private static class PatchClickIconMinimap
		{
			[UsedImplicitly]
			private static bool Prefix()
			{
				return Control(leftClick: true);
			}
		}

		[HarmonyPatch(typeof(Minimap), "OnMapRightClick")]
		[ClientOnlyPatch]
		private static class PatchRightClickIconMinimap
		{
			[UsedImplicitly]
			private static bool Prefix()
			{
				return Control(leftClick: false);
			}
		}

		private static readonly Dictionary<PinData, ZDO> _pins = new Dictionary<PinData, ZDO>();

		private const string npcToSearchPrefabName = "MarketPlaceNPC";

		private const PinType PINTYPENPC = 72;

		public static ConfigEntry<bool> EnableMapControl;

		private static void OnInit()
		{
			EnableMapControl = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<bool>("General", "DisableMapNPCControl", true, (ConfigDescription)null);
		}

		private static bool Control(bool leftClick)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Vector3 pos = Minimap.instance.ScreenToWorldPoint(Input.mousePosition);
			PinData customPin = Utils.GetCustomPin((PinType)72, pos, Minimap.instance.m_removeRadius * (Minimap.instance.m_largeZoom * 2f));
			if (customPin != null && _pins.TryGetValue(customPin, out ZDO value))
			{
				if (leftClick)
				{
					Market_NPC.NPCUI.ShowMain(value, NPC_MapControllerPatch.ReapplyPins);
				}
				else
				{
					Market_NPC.NPCUI.ShowFashion(value, NPC_MapControllerPatch.ReapplyPins);
				}
				return false;
			}
			return true;
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Both, Market_Autoload.Priority.Normal, "OnInit", null, null)]
	public static class Market_NPC
	{
		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			private static bool done;

			[UsedImplicitly]
			private static void Postfix(FejdStartup __instance)
			{
				if (!done)
				{
					done = true;
					Transform obj = ((Component)__instance).transform.Find("StartGame/Panel/JoinPanel/serverCount");
					TextMeshProUGUI val = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
					if (val != null)
					{
						((Component)NPC.transform.Find("TMP")).GetComponent<TMP_Text>().font = ((TMP_Text)val).font;
						((Component)NPC.transform.Find("TMP")).GetComponent<TMP_Text>().outlineWidth = 0.075f;
						Utils.print("Replaced TMP for NPC");
					}
				}
			}
		}

		public enum NPCType
		{
			None,
			Trader,
			Info,
			Teleporter,
			Feedback,
			Banker,
			Gambler,
			Quests,
			Buffer,
			Transmog,
			Marketplace,
			Mail
		}

		[HarmonyPatch(typeof(FejdStartup), "Start")]
		private static class FejdStartup_Start_Patch
		{
			[UsedImplicitly]
			private static void Postfix(FejdStartup __instance)
			{
				Animator componentInChildren = NPC.GetComponentInChildren<Animator>(true);
				((Component)componentInChildren).gameObject.AddComponent<CustomLookAt>();
				Shader val = ((IEnumerable<Shader>)Resources.FindObjectsOfTypeAll<Shader>()).FirstOrDefault((Func<Shader, bool>)((Shader s) => ((Object)s).name == "Custom/Creature"));
				if (Object.op_Implicit((Object)(object)val))
				{
					SkinnedMeshRenderer componentInChildren2 = ((Component)componentInChildren).gameObject.GetComponentInChildren<SkinnedMeshRenderer>(true);
					Material[] materials = ((Renderer)componentInChildren2).materials;
					foreach (Material val2 in materials)
					{
						val2.shader = val;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class NPCZnet
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				__instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)NPC).name), NPC);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class OdinFix
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				GameObject prefab = __instance.GetPrefab("odin");
				Animator val = ((prefab != null) ? prefab.GetComponent<Animator>() : null);
				if (val != null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class IsVisiblePatch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				if (NPCUI.IsVisible())
				{
					__result = true;
				}
			}
		}

		private class TextComponent : MonoBehaviour
		{
			private void Update()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: 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_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				Quaternion val = Quaternion.LookRotation(((Component)GameCamera.instance).transform.forward);
				Vector3 eulerAngles = ((Quaternion)(ref val)).eulerAngles;
				eulerAngles.z = 0f;
				((Component)this).transform.rotation = Quaternion.Euler(eulerAngles);
			}
		}

		public class HoverOnButton_WithImage : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
		{
			private static readonly Dictionary<string, Sprite> Cache = new Dictionary<string, Sprite>();

			private bool HasImage;

			private Image _image;

			private Sprite _sprite;

			private Transform _tt;

			private void Awake()
			{
				_image = ((Component)this).GetComponent<Image>();
			}

			public void Setup(string _name, Transform t, string base64)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				_tt = t;
				try
				{
					if (Cache.TryGetValue(_name, out Sprite value))
					{
						_sprite = value;
						HasImage = true;
						return;
					}
					byte[] array = Convert.FromBase64String(base64);
					Texture2D val = new Texture2D(1, 1);
					ImageConversion.LoadImage(val, array);
					_sprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), Vector2.zero);
					Cache.Add(_name, _sprite);
					HasImage = true;
				}
				catch
				{
					HasImage = false;
				}
			}

			public void OnPointerEnter(PointerEventData eventData)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)_image).color = Color.green;
				if (HasImage)
				{
					((Component)_tt).gameObject.SetActive(true);
					((Component)((Component)_tt).transform.GetChild(0)).GetComponent<Image>().sprite = _sprite;
				}
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)_image).color = Color.white;
				((Component)_tt).gameObject.SetActive(false);
			}
		}

		private class CustomLookAt : MonoBehaviour
		{
			private Animator animator;

			private Vector3 currentLookAt = Vector3.zero;

			private ZNetView _znet;

			private void Awake()
			{
				//IL_0021: 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)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				_znet = ((Component)this).GetComponentInParent<ZNetView>();
				animator = ((Component)this).GetComponent<Animator>();
				Transform transform = ((Component)this).transform;
				currentLookAt = transform.position + transform.forward * 4f + Vector3.up * 1.2f;
			}

			private void OnAnimatorIK(int layerIndex)
			{
				//IL_003d: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: 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)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: 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_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//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_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				if (!_znet.IsValid() || !Object.op_Implicit((Object)(object)animator) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return;
				}
				float num = 2f;
				Vector3 val = ((Character)Player.m_localPlayer).m_head.position;
				if (Vector3.Distance(val, ((Component)this).transform.position) > 4f)
				{
					Transform transform = ((Component)this).transform;
					val = transform.position + transform.forward * 3f + Vector3.up * 1.2f;
					num = 4f;
				}
				else
				{
					Vector3 val2 = ((Component)this).transform.position - val;
					Vector3 normalized = ((Vector3)(ref val2)).normalized;
					Quaternion val3 = Quaternion.LookRotation(normalized);
					float y = ((Quaternion)(ref val3)).eulerAngles.y;
					val3 = ((Component)this).transform.rotation;
					float y2 = ((Quaternion)(ref val3)).eulerAngles.y;
					float num2 = Mathf.Abs(Mathf.DeltaAngle(y, y2));
					if (num2 < 100f)
					{
						Transform transform2 = ((Component)this).transform;
						val = transform2.position + transform2.forward * 3f + Vector3.up * 1.2f;
					}
				}
				currentLookAt = Vector3.MoveTowards(currentLookAt, val, Time.deltaTime * num);
				animator.SetLookAtPosition(currentLookAt);
				animator.SetLookAtWeight(1f, 0.1f, 1f, 0f);
			}
		}

		public class NPCcomponent : MonoBehaviour, Hoverable, Interactable, IDestructible
		{
			[HarmonyPatch(typeof(MonoUpdaters), "Update")]
			[ClientOnlyPatch]
			private static class MonoUpdaters_Update_Patch
			{
				[UsedImplicitly]
				private static void Postfix()
				{
					foreach (NPCcomponent item in ALL)
					{
						item.CustomUpdate();
					}
				}
			}

			[HarmonyPatch(typeof(MonoUpdaters), "FixedUpdate")]
			private static class MonoUpdaters_FixedUpdate_Patch
			{
				[UsedImplicitly]
				private static void Postfix()
				{
					foreach (NPCcomponent item in ALL)
					{
						item.CustomFixedUpdate();
					}
				}
			}

			private const string PatrolData = "KGmarket PatrolData";

			private const string LatestPatrolPoint = "KGmarket LatestPatrolPoint";

			private const string GoBackPatrol = "KGmarket GoBack";

			public static readonly List<NPCcomponent> ALL = new List<NPCcomponent>();

			public ZNetView znv;

			public GameObject pastOverrideModel;

			public NPCType _currentNpcType;

			public ZSyncAnimation zanim;

			private TMP_Text canvas;

			public AudioSource NPC_SoundSource;

			private bool WasClose;

			private Vector2[] PatrolArray;

			private float MaxSpeed;

			private float ForwardSpeed;

			private float PatrolTime;

			private float periodicAnimationTimer = 999f;

			private float periodicSoundTimer = 999f;

			private bool RequestedUpdate;

			private int TargetRevision;

			private float _counter;

			public string LocalModelOverride;

			private void OnDestroy()
			{
				ALL.Remove(this);
			}

			private void InitPatrolData(string ForceData)
			{
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				ForwardSpeed = 0f;
				if (((Behaviour)zanim).enabled)
				{
					zanim.SetFloat(Character.s_forwardSpeed, 0f);
				}
				MaxSpeed = 1f;
				if (string.IsNullOrEmpty(ForceData))
				{
					PatrolArray = null;
					return;
				}
				try
				{
					string[] array = ForceData.Split(new char[1] { '@' });
					string[] array2 = array[0].Replace(" ", "").Split(new char[1] { ',' });
					if (array.Length == 2)
					{
						MaxSpeed = Convert.ToSingle(array[1], new CultureInfo("en-US"));
					}
					PatrolArray = (Vector2[])(object)new Vector2[array2.Length / 2];
					for (int i = 0; i < array2.Length; i += 2)
					{
						float num = Convert.ToSingle(array2[i], new CultureInfo("en-US"));
						float num2 = Convert.ToSingle(array2[i + 1], new CultureInfo("en-US"));
						PatrolArray[i / 2] = new Vector2(num, num2);
					}
				}
				catch
				{
					PatrolArray = null;
				}
			}

			private void CustomUpdate()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: 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_0208: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_022b: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: 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_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				PatrolTime += Time.deltaTime;
				if (znv.m_zdo == null || !znv.IsOwner())
				{
					return;
				}
				Vector2[] patrolArray = PatrolArray;
				if (patrolArray == null || patrolArray.Length <= 1 || PatrolTime < 2f)
				{
					return;
				}
				Player closestPlayer = Player.GetClosestPlayer(((Component)this).transform.position, 3f);
				ForwardSpeed = ((Object.op_Implicit((Object)(object)closestPlayer) && _currentNpcType != 0) ? Mathf.Clamp(ForwardSpeed - Time.deltaTime, 0f, MaxSpeed) : Mathf.Clamp(ForwardSpeed + Time.deltaTime, 0f, MaxSpeed));
				if (((Behaviour)zanim).enabled)
				{
					zanim.SetFloat(Character.s_forwardSpeed, ForwardSpeed * 1.5f);
				}
				int @int = znv.m_zdo.GetInt("KGmarket LatestPatrolPoint", 0);
				Vector3 position = ((Component)this).transform.position;
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(position.x, position.z);
				Vector2 val2 = Vector2.MoveTowards(val, PatrolArray[@int], Time.deltaTime * ForwardSpeed);
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(val2.x, position.y, val2.y);
				Utils.CustomFindFloor(val3, out var height);
				height = Mathf.Max(new float[3]
				{
					30f,
					height,
					ZoneSystem.instance.GetGroundHeight(val3)
				});
				if (ForwardSpeed > 0f)
				{
					Vector3 val4 = val3 - ((Component)this).transform.position;
					Vector3 normalized = ((Vector3)(ref val4)).normalized;
					if (normalized != Vector3.zero)
					{
						Quaternion val5 = Quaternion.LookRotation(normalized);
						val5.x = 0f;
						((Component)this).transform.rotation = Quaternion.RotateTowards(((Component)this).transform.rotation, val5, Time.deltaTime * 200f);
					}
				}
				((Component)this).transform.position = new Vector3(val3.x, height, val3.z);
				if (!(Vector2.Distance(PatrolArray[@int], new Vector2(((Component)this).transform.position.x, ((Component)this).transform.position.z)) <= 0.25f))
				{
					return;
				}
				if (znv.m_zdo.GetBool("KGmarket GoBack", false))
				{
					@int--;
					if (@int < 0)
					{
						@int = 1;
						znv.m_zdo.Set("KGmarket GoBack", false);
					}
					znv.m_zdo.Set("KGmarket LatestPatrolPoint", @int);
					ForwardSpeed = MaxSpeed / 2.5f;
				}
				else
				{
					@int++;
					if (@int >= PatrolArray.Length)
					{
						@int -= 2;
						znv.m_zdo.Set("KGmarket GoBack", true);
					}
					znv.m_zdo.Set("KGmarket LatestPatrolPoint", @int);
					ForwardSpeed = MaxSpeed / 2.5f;
				}
			}

			private void CustomFixedUpdate()
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: 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_0041: 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_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03af: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0289: Unknown result type (might be due to invalid IL or missing references)
				//IL_0293: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)znv) || znv.m_zdo == null)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				Vector3 val = ((localPlayer != null) ? ((Character)localPlayer).m_head.position : Vector3.zero);
				Vector3 val2 = ((Component)this).transform.position - val;
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				Quaternion val3 = Quaternion.LookRotation(normalized);
				float y = ((Quaternion)(ref val3)).eulerAngles.y;
				val3 = ((Component)this).transform.rotation;
				float y2 = ((Quaternion)(ref val3)).eulerAngles.y;
				float num = Mathf.Abs(Mathf.DeltaAngle(y, y2));
				if (znv.IsOwner() && znv.m_zdo.GET_NPC_PeriodicAnimationTime() > 0f)
				{
					periodicAnimationTimer += Time.fixedDeltaTime;
					if (periodicAnimationTimer >= znv.m_zdo.GET_NPC_PeriodicAnimationTime())
					{
						periodicAnimationTimer = 0f;
						if (!string.IsNullOrWhiteSpace(znv.m_zdo.GET_NPC_PeriodicAnimation()))
						{
							zanim.SetTrigger(znv.m_zdo.GET_NPC_PeriodicAnimation());
						}
					}
				}
				if (znv.m_zdo.GET_NPC_PeriodicSoundTime() > 0f)
				{
					periodicSoundTimer += Time.fixedDeltaTime;
					if (periodicSoundTimer >= znv.m_zdo.GET_NPC_PeriodicSoundTime())
					{
						periodicSoundTimer = 0f;
						if (!string.IsNullOrWhiteSpace(znv.m_zdo.GET_NPC_PeriodicSound()) && AssetStorage.NPC_AudioClips.TryGetValue(znv.m_zdo.GET_NPC_PeriodicSound(), out AudioClip value) && !NPC_SoundSource.isPlaying)
						{
							NPC_SoundSource.clip = value;
							NPC_SoundSource.Play();
						}
					}
				}
				string reason;
				if (!WasClose)
				{
					if (!(Vector3.Distance(val, ((Component)this).transform.position) < 10f))
					{
						return;
					}
					WasClose = true;
					string text = znv.m_zdo.GET_NPC_Dialogue();
					if (!string.IsNullOrEmpty(text) && Dialogues_DataTypes.ClientReadyDialogues.TryGetValue(text, out Dialogues_DataTypes.Dialogue value2))
					{
						Dialogues_DataTypes.Dialogue.PlayerInteraction[] interactions = value2.Interactions;
						foreach (Dialogues_DataTypes.Dialogue.PlayerInteraction playerInteraction in interactions)
						{
							if (playerInteraction.Type == Dialogues_DataTypes.RawDialogue.InteractionType.InRange && playerInteraction.CheckCondition(this, out reason))
							{
								playerInteraction.CallCommands(this);
							}
						}
					}
					if (num > 80f)
					{
						if (!string.IsNullOrWhiteSpace(znv.m_zdo.GET_NPC_GreetingText()))
						{
							Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 4f, 20f, 3f, "", znv.m_zdo.GET_NPC_GreetingText(), false);
						}
						if (!string.IsNullOrWhiteSpace(znv.m_zdo.GET_NPC_GreetingAnimation()))
						{
							zanim.SetTrigger(znv.m_zdo.GET_NPC_GreetingAnimation());
						}
					}
				}
				else
				{
					if (!(Vector3.Distance(val, ((Component)this).transform.position) > 12f))
					{
						return;
					}
					WasClose = false;
					string text2 = znv.m_zdo.GET_NPC_Dialogue();
					if (!string.IsNullOrEmpty(text2) && Dialogues_DataTypes.ClientReadyDialogues.TryGetValue(text2, out Dialogues_DataTypes.Dialogue value3))
					{
						Dialogues_DataTypes.Dialogue.PlayerInteraction[] interactions2 = value3.Interactions;
						foreach (Dialogues_DataTypes.Dialogue.PlayerInteraction playerInteraction2 in interactions2)
						{
							if (playerInteraction2.Type == Dialogues_DataTypes.RawDialogue.InteractionType.OutRange && playerInteraction2.CheckCondition(this, out reason))
							{
								playerInteraction2.CallCommands(this);
							}
						}
					}
					if (num > 80f)
					{
						if (!string.IsNullOrWhiteSpace(znv.m_zdo.GET_NPC_ByeText()))
						{
							Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 4f, 20f, 3f, "", znv.m_zdo.GET_NPC_ByeText(), false);
						}
						if (!string.IsNullOrWhiteSpace(znv.m_zdo.GET_NPC_ByeAnimation()))
						{
							zanim.SetTrigger(znv.m_zdo.GET_NPC_ByeAnimation());
						}
					}
				}
			}

			private void Awake()
			{
				znv = ((Component)this).GetComponent<ZNetView>();
				if (Object.op_Implicit((Object)(object)znv) && znv.IsValid())
				{
					ALL.Add(this);
					canvas = ((Component)((Component)this).transform.Find("TMP")).GetComponent<TMP_Text>();
					zanim = ((Component)this).GetComponent<ZSyncAnimation>();
					if (!znv.m_functions.ContainsKey(StringExtensionMethods.GetStableHashCode("KGMarket changeNpcType")))
					{
						znv.Register<int, bool, string>("KGMarket changeNpcType", (Action<long, int, bool, string>)ChangeNpcType);
						znv.Register<string, string>("KGmarket changeprofile", (Action<long, string, string>)ChangeProfile);
						znv.Register<string>("KGmarket overridename", (Action<long, string>)OverrideName);
						znv.Register<string>("KGmarket overridemodel", (Action<long, string>)OverrideModel);
						znv.Register<NPC_DataTypes.NPC_Fashion>("KGmarket fashion", (Action<long, NPC_DataTypes.NPC_Fashion>)FashionApply);
						znv.Register<string>("KGmarket GetPatrolData", (Action<long, string>)GetPatrolData);
						znv.Register<int>("ValheimMap_Update", (Action<long, int>)RequestUpdate);
					}
				}
			}

			private void InitNpc()
			{
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				int num = znv.m_zdo.GetInt("KGmarketNPC", 0);
				if (num >= TypeNames.Length)
				{
					num = 0;
				}
				_currentNpcType = (NPCType)num;
				ApplyName(znv.m_zdo.GET_NPC_Name());
				OverrideModel(0L, znv.m_zdo.GetString("KGnpcModelOverride", ""));
				GameObject val = Object.Instantiate<GameObject>(AssetStorage.MarketplaceQuestQuestionIcon, ((Component)this).transform);
				Transform transform = val.transform;
				transform.position += Vector3.up * 4.5f;
				((Object)val).name = "MPASNquest";
				bool flag = Quests_DataTypes.Quest.IsQuestTarget(GetNPCName());
				val.SetActive(flag);
				GameObject val2 = Object.Instantiate<GameObject>(AssetStorage.MarketplaceQuestHasQuestIcon, ((Component)this).transform);
				Transform transform2 = val2.transform;
				transform2.position += Vector3.up * 4.5f;
				((Object)val2).name = "MPASNHasQuests";
				val2.SetActive(!flag && Quests_DataTypes.Quest.HasQuests(this));
				InitPatrolData(znv.m_zdo.GetString("KGmarket PatrolData", ""));
			}

			private void Start()
			{
				if (Object.op_Implicit((Object)(object)znv) && znv.IsValid())
				{
					NPC_SoundSource = ((Component)this).gameObject.AddComponent<AudioSource>();
					NPC_SoundSource.spatialBlend = 1f;
					NPC_SoundSource.volume = 0.8f;
					NPC_SoundSource.outputAudioMixerGroup = AudioMan.instance.m_masterMixer.outputAudioMixerGroup;
					NPC_SoundSource.maxDistance = 10f;
					NPC_SoundSource.bypassReverbZones = true;
					((Component)((Component)((Component)this).transform.Find("NPC")).GetComponentInChildren<Collider>()).gameObject.layer = LayerMask.NameToLayer("character");
					InitNpc();
				}
			}

			private void Update()
			{
				_counter += Time.deltaTime;
				if (!(_counter < 1f))
				{
					_counter = 0f;
					if (RequestedUpdate && znv.m_zdo.DataRevision >= TargetRevision)
					{
						RequestedUpdate = false;
						InitNpc();
					}
				}
			}

			private void RequestUpdate(long obj, int targetRevision)
			{
				RequestedUpdate = true;
				TargetRevision = targetRevision;
			}

			public void GetPatrolData(long sender, string data)
			{
				if (znv.IsOwner())
				{
					znv.m_zdo.Set("KGmarket PatrolData", data);
					znv.m_zdo.Set("KGmarket LatestPatrolPoint", 0);
					znv.m_zdo.Set("KGmarket GoBack", false);
				}
				InitPatrolData(data);
			}

			public string GetHoverText()
			{
				if (TextInput.IsVisible())
				{
					return "";
				}
				string text = (Utils.IsDebug_Marketplace ? ("\n" + Localization.instance.Localize("[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>]") + " " + Localization.instance.Localize("$mpasn_opennnpcui") + "\n" + Localization.instance.Localize("[<color=yellow><b>ALT + $KEY_Use</b></color>]") + " " + Localization.instance.Localize("$mpasn_fashionmenu") + "\n" + Localization.instance.Localize("[<color=yellow><b>C + $KEY_Use</b></color>]") + " " + Localization.instance.Localize("$mpasn_savenpc")) : "");
				string text2 = Localization.instance.Localize("[<color=yellow><b>$KEY_Use</b></color>] ") + Localization.instance.Localize("$mpasn_interact");
				return text2 + text;
			}

			public string GetHoverName()
			{
				return "";
			}

			public string GetNPCName()
			{
				ZDO zdo = znv.m_zdo;
				return ((zdo != null) ? zdo.GetString("KGnpcNameOverride", "") : null) ?? "";
			}

			public string GetClearNPCName()
			{
				return Regex.Replace(GetNPCName(), "</?(?!color\\b)\\w+[^>]*>", "");
			}

			public void OpenUIForType()
			{
				OpenUIForType(_currentNpcType, znv.m_zdo.GET_NPC_Profile(), GetClearNPCName());
			}

			public static void OpenUIForType(string type, string profile, string npcName)
			{
				if (type != null && profile != null)
				{
					profile = profile.ToLower();
					if ((type == "Dialogue" || type == "Dialog") ? true : false)
					{
						Dialogues_UI.LoadDialogue(null, profile);
					}
					else
					{
						OpenUIForType((NPCType)Enum.Parse(typeof(NPCType), type, ignoreCase: true), profile, npcName);
					}
				}
			}

			public static void OpenUIForType(NPCType? type, string profile, string npcName)
			{
				if (!type.HasValue || profile == null || !type.HasValue)
				{
					return;
				}
				switch (type.GetValueOrDefault())
				{
				case NPCType.Marketplace:
					if (!string.IsNullOrWhiteSpace(Global_Configs._localUserID))
					{
						Marketplace_UI.Show();
					}
					break;
				case NPCType.Info:
					ServerInfo_UI.Show(profile, npcName);
					break;
				case NPCType.Trader:
					Trader_UI.Show(profile, npcName);
					break;
				case NPCType.Banker:
					Banker_UI.Show(profile, npcName);
					break;
				case NPCType.Teleporter:
					Teleporter_Main_Client.ShowTeleporterUI(profile);
					break;
				case NPCType.Feedback:
					Feedback_UI.Show();
					break;
				case NPCType.Gambler:
					Gambler_UI.Show(profile);
					break;
				case NPCType.Quests:
					Quests_UIs.QuestUI.Show(profile, npcName);
					break;
				case NPCType.Buffer:
					Buffer_UI.Show(profile, npcName);
					break;
				case NPCType.Transmog:
					Transmogrification_UI.Show(profile, npcName);
					break;
				case NPCType.Mail:
					CentralizedMailSystem_UI.Show(canTakeAttachments: true);
					break;
				}
			}

			public bool Interact(Humanoid user, bool hold, bool alt)
			{
				if (!string.IsNullOrWhiteSpace(znv.m_zdo.GetString("KGinteractAnimation", "")))
				{
					zanim.SetTrigger(znv.m_zdo.GetString("KGinteractAnimation", ""));
				}
				string @string = znv.m_zdo.GetString("KGinteractSound", "");
				NPC_SoundSource.Stop();
				if (!string.IsNullOrEmpty(@string) && AssetStorage.NPC_AudioClips.TryGetValue(@string, out AudioClip value))
				{
					NPC_SoundSource.clip = value;
					NPC_SoundSource.Play();
				}
				if (Input.GetKey((KeyCode)99) && Utils.IsDebug_Marketplace)
				{
					MarketplaceHammer.SaveNPC(this);
					return true;
				}
				if (Input.GetKey((KeyCode)308) && Utils.IsDebug_Marketplace)
				{
					NPCUI.ShowFashion(znv.m_zdo);
					return true;
				}
				if (alt && Utils.IsDebug_Marketplace)
				{
					NPCUI.ShowMain(znv.m_zdo);
					return true;
				}
				if (Quests_DataTypes.Quest.TryAddRewardTalk(GetClearNPCName()))
				{
					Quests_UIs.AcceptedQuestsUI.CheckQuests();
					return true;
				}
				if (!string.IsNullOrWhiteSpace(znv.m_zdo.GetString("KGnpcDialogue", "")))
				{
					Dialogues_UI.LoadDialogue(this, znv.m_zdo.GetString("KGnpcDialogue", ""));
					return true;
				}
				OpenUIForType();
				return true;
			}

			public bool UseItem(Humanoid user, ItemData item)
			{
				return false;
			}

			public void FashionApply(long sender, NPC_DataTypes.NPC_Fashion fashion)
			{
				//IL_0846: Unknown result type (might be due to invalid IL or missing references)
				//IL_0866: Unknown result type (might be due to invalid IL or missing references)
				//IL_0873: Unknown result type (might be due to invalid IL or missing references)
				//IL_0878: Unknown result type (might be due to invalid IL or missing references)
				//IL_087d: Unknown result type (might be due to invalid IL or missing references)
				//IL_088a: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_07fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0697: Unknown result type (might be due to invalid IL or missing references)
				//IL_0709: Unknown result type (might be due to invalid IL or missing references)
				if (znv.m_zdo.IsOwner())
				{
					znv.m_zdo.Set("KGleftItem", fashion.LeftItem);
					znv.m_zdo.Set("KGrightItem", fashion.RightItem);
					znv.m_zdo.Set("KGhelmetItem", fashion.HelmetItem);
					znv.m_zdo.Set("KGchestItem", fashion.ChestItem);
					znv.m_zdo.Set("KGlegsItem", fashion.LegsItem);
					znv.m_zdo.Set("KGcapeItem", fashion.CapeItem);
					znv.m_zdo.Set("KGhairItem", fashion.HairItem);
					znv.m_zdo.Set("KGhairItemColor", fashion.HairColor);
					znv.m_zdo.Set("KGLeftItemBack", fashion.LeftItemHidden);
					znv.m_zdo.Set("KGRightItemBack", fashion.RightItemHidden);
					znv.m_zdo.Set("KGinteractAnimation", fashion.InteractAnimation);
					znv.m_zdo.Set("KGgreetingAnimation", fashion.GreetAnimation);
					znv.m_zdo.Set("KGbyeAnimation", fashion.ByeAnimation);
					znv.m_zdo.Set("KGgreetingText", fashion.GreetText);
					znv.m_zdo.Set("KGbyeText", fashion.ByeText);
					znv.m_zdo.Set("KGskinColor", fashion.SkinColor);
					znv.m_zdo.Set("KGcraftingAnimation", int.TryParse(fashion.CraftingAnimation, out var result) ? result : 0);
					znv.m_zdo.Set("KGbeardItem", fashion.BeardItem);
					znv.m_zdo.Set("KGbeardColor", fashion.BeardColor);
					znv.m_zdo.Set("KGinteractSound", fashion.InteractAudioClip);
					znv.m_zdo.Set("KGtextSize", float.TryParse(fashion.TextSize, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result2) ? result2 : 3f);
					znv.m_zdo.Set("KGtextHeight", float.TryParse(fashion.TextHeight, NumberStyles.Any, CultureInfo.InvariantCulture, out var result3) ? result3 : 0f);
					znv.m_zdo.Set("KGperiodicAnimation", fashion.PeriodicAnimation);
					znv.m_zdo.Set("KGperiodicAnimationTime", float.TryParse(fashion.PeriodicAnimationTime, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result4) ? result4 : 0f);
					znv.m_zdo.Set("KGperiodicSound", fashion.PeriodicSound);
					znv.m_zdo.Set("KGperiodicSoundTime", float.TryParse(fashion.PeriodicSoundTime, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result5) ? result5 : 0f);
					if (!float.TryParse(fashion.ModelScale, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result6))
					{
						result6 = 1f;
					}
					znv.m_zdo.Set("KGnpcScale", result6);
				}
				periodicAnimationTimer = 999f;
				periodicSoundTimer = 999f;
				string prefab = znv.m_zdo.GetString("KGnpcModelOverride", "");
				if (TryOverrideModel(ref prefab, out var isFemale, EquipItems: false))
				{
					Animator component = pastOverrideModel.GetComponent<Animator>();
					if (component != null)
					{
						component.SetBool(Wakeup, false);
					}
					if (int.TryParse(fashion.CraftingAnimation, out var result7))
					{
						Animator component2 = pastOverrideModel.GetComponent<Animator>();
						if (component2 != null)
						{
							component2.SetInteger(Crafting, result7);
						}
					}
					VisEquipment component3 = ZNetScene.instance.GetPrefab(prefab).GetComponent<VisEquipment>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						Animator component4 = pastOverrideModel.GetComponent<Animator>();
						if (component4 != null)
						{
							component4.SetBool(Wakeup, false);
						}
						SkinnedMeshRenderer componentInChildren = pastOverrideModel.GetComponentInChildren<SkinnedMeshRenderer>();
						Transform transform = pastOverrideModel.transform;
						Transform leftHand = component3.m_leftHand;
						Transform joint = Utils.FindChild(transform, (leftHand != null) ? ((Object)leftHand).name : null, (IterativeSearchType)0);
						Transform transform2 = pastOverrideModel.transform;
						Transform rightHand = component3.m_rightHand;
						Transform joint2 = Utils.FindChild(transform2, (rightHand != null) ? ((Object)rightHand).name : null, (IterativeSearchType)0);
						Transform transform3 = pastOverrideModel.transform;
						Transform helmet = component3.m_helmet;
						Transform joint3 = Utils.FindChild(transform3, (helmet != null) ? ((Object)helmet).name : null, (IterativeSearchType)0);
						Transform transform4 = pastOverrideModel.transform;
						Transform backShield = component3.m_backShield;
						Transform joint4 = Utils.FindChild(transform4, (backShield != null) ? ((Object)backShield).name : null, (IterativeSearchType)0);
						Transform transform5 = pastOverrideModel.transform;
						Transform backMelee = component3.m_backMelee;
						Transform joint5 = Utils.FindChild(transform5, (backMelee != null) ? ((Object)backMelee).name : null, (IterativeSearchType)0);
						string leftItem = fashion.LeftItem;
						string rightItem = fashion.RightItem;
						string helmetItem = fashion.HelmetItem;
						string leftItemHidden = fashion.LeftItemHidden;
						string rightItemHidden = fashion.RightItemHidden;
						EquipItemsOnModel(joint, leftItem, componentInChildren);
						EquipItemsOnModel(joint2, rightItem, componentInChildren);
						if (Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(leftItemHidden)))
						{
							if (ZNetScene.instance.GetPrefab(leftItemHidden).GetComponent<ItemDrop>().m_itemData.IsWeapon())
							{
								EquipItemsOnModel(joint5, leftItemHidden, componentInChildren, INVERT: true);
							}
							else
							{
								EquipItemsOnModel(joint4, leftItemHidden, componentInChildren);
							}
						}
						EquipItemsOnModel(joint5, rightItemHidden, componentInChildren);
						EquipItemsOnModel(joint3, helmetItem, componentInChildren);
						if ((Object)(object)pastOverrideModel.GetComponent<CustomLookAt>() == (Object)null && result7 == 0)
						{
							pastOverrideModel.AddComponent<CustomLookAt>();
						}
						CapsuleCollider[] capsule = (from x in pastOverrideModel.GetComponentsInChildren<CapsuleCollider>()
							where (Object)(object)x != (Object)(object)pastOverrideModel.GetComponent<CapsuleCollider>()
							select x).ToArray();
						string chestItem = fashion.ChestItem;
						string legsItem = fashion.LegsItem;
						string capeItem = fashion.CapeItem;
						EquipItemsOnModel(componentInChildren, capeItem, capsule);
						EquipItemsOnModel(componentInChildren, chestItem, capsule);
						EquipItemsOnModel(componentInChildren, legsItem, capsule);
						string prefab2 = "Hair" + fashion.HairItem;
						GameObject val = EquipItemsOnModel(joint3, prefab2, componentInChildren);
						Color val2 = default(Color);
						ColorUtility.TryParseHtmlString(fashion.HairColor, ref val2);
						if (Object.op_Implicit((Object)(object)val))
						{
							Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>();
							Renderer[] array = componentsInChildren;
							foreach (Renderer val3 in array)
							{
								val3.material.SetColor(SkinColor, val2);
							}
						}
						string prefab3 = "Beard" + fashion.BeardItem;
						GameObject val4 = EquipItemsOnModel(joint3, prefab3, componentInChildren);
						Color val5 = default(Color);
						ColorUtility.TryParseHtmlString(fashion.BeardColor, ref val5);
						if (Object.op_Implicit((Object)(object)val4))
						{
							Renderer[] componentsInChildren2 = val4.GetComponentsInChildren<Renderer>();
							Renderer[] array2 = componentsInChildren2;
							foreach (Renderer val6 in array2)
							{
								val6.material.SetColor(SkinColor, val5);
							}
						}
						if (isFemale)
						{
							componentInChildren.sharedMesh = component3.m_models[1].m_mesh;
							((Renderer)componentInChildren).materials[0].SetTexture(MainTex, component3.m_models[1].m_baseMaterial.GetTexture(MainTex));
							((Renderer)componentInChildren).materials[0].SetTexture(SkinBumpMap, component3.m_models[1].m_baseMaterial.GetTexture(SkinBumpMap));
						}
						Color val7 = default(Color);
						ColorUtility.TryParseHtmlString(fashion.SkinColor, ref val7);
						((Renderer)componentInChildren).materials[0].SetColor(SkinColor, val7);
					}
				}
				if (Object.op_Implicit((Object)(object)pastOverrideModel))
				{
					if (!float.TryParse(fashion.ModelScale, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result8))
					{
						result8 = 1f;
					}
					if (result8 < 0.1f)
					{
						result8 = 0.1f;
					}
					Transform transform6 = pastOverrideModel.transform;
					transform6.localScale *= result8;
				}
				float.TryParse(fashion.TextSize, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result9);
				float.TryParse(fashion.TextHeight, NumberStyles.Any, CultureInfo.InvariantCulture, out var result10);
				((Component)canvas).gameObject.transform.localScale = new Vector3(result9, result9, result9);
				Vector3 val8 = default(Vector3);
				((Vector3)(ref val8))..ctor(0f, 3.4f, 0f);
				val8 += new Vector3(0f, result10, 0f);
				canvas.transform.localPosition = val8;
			}

			public void ApplyName(string npcName)
			{
				if (string.IsNullOrWhiteSpace(npcName))
				{
					canvas.text = Localization.instance.Localize("$mpasn_" + _currentNpcType);
				}
				else
				{
					canvas.text = npcName;
				}
			}

			public void OverrideModelLocal(string newModelName)
			{
				((Component)((Component)this).transform.Find("NPC")).gameObject.SetActive(false);
				if (!TryOverrideModel(ref newModelName, out var _))
				{
					Transform val = ((Component)this).transform.Find("NPC");
					((Component)val).gameObject.SetActive(true);
					zanim.m_animator = ((Component)val).GetComponentInChildren<Animator>(true);
				}
			}

			public void OverrideModel(long sender, string newModelName)
			{
				LocalModelOverride = newModelName;
				if (znv.IsOwner())
				{
					znv.m_zdo.Set("KGnpcModelOverride", LocalModelOverride);
				}
				OverrideModelLocal(LocalModelOverride);
			}

			public void OverrideName(long sender, string newName)
			{
				if (znv.IsOwner())
				{
					znv.m_zdo.Set("KGnpcNameOverride", newName);
				}
				ApplyName(newName);
				Transform obj = ((Component)this).transform.Find("MPASNquest");
				if (obj != null)
				{
					((Component)obj).gameObject.SetActive(Quests_DataTypes.Quest.IsQuestTarget(newName));
				}
			}

			public void ChangeProfile(long sender, string profile, string dialogue)
			{
				if (znv.IsOwner())
				{
					if (string.IsNullOrWhiteSpace(profile))
					{
						profile = "default";
					}
					znv.m_zdo.Set("KGnpcProfile", profile.ToLower());
					if (string.IsNullOrWhiteSpace(dialogue))
					{
						dialogue = "";
					}
					znv.m_zdo.Set("KGnpcDialogue", dialogue.ToLower());
				}
			}

			private void CleanupInstance(GameObject instance)
			{
				Collider[] componentsInChildren = instance.GetComponentsInChildren<Collider>();
				Collider[] array = componentsInChildren;
				foreach (Collider val in array)
				{
					val.enabled = false;
				}
			}

			private void EnableEquipedEffects(GameObject instance)
			{
				Transform val = instance.transform.Find("equiped");
				if (Object.op_Implicit((Object)(object)val))
				{
					((Component)val).gameObject.SetActive(true);
				}
			}

			private void AttachArmor(int itemHash, SkinnedMeshRenderer m_bodyModel, CapsuleCollider[] capsule, int variant = -1)
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(itemHash);
				if ((Object)(object)itemPrefab == (Object)null)
				{
					return;
				}
				int childCount = itemPrefab.transform.childCount;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = itemPrefab.transform.GetChild(i);
					if (!((Object)((Component)child).gameObject).name.StartsWith("attach_"))
					{
						continue;
					}
					string text = ((Object)((Component)child).gameObject).name.Substring(7);
					GameObject val;
					if (text == "skin")
					{
						Transform transform = ((Component)m_bodyModel).transform;
						Transform parent;
						val = Object.Instantiate<GameObject>(((Component)child).gameObject, transform.position, (parent = transform.parent).rotation, parent);
						val.SetActive(true);
						SkinnedMeshRenderer[] componentsInChildren = val.GetComponentsInChildren<SkinnedMeshRenderer>();
						foreach (SkinnedMeshRenderer val2 in componentsInChildren)
						{
							val2.rootBone = m_bodyModel.rootBone;
							val2.bones = m_bodyModel.bones;
						}
						Cloth[] componentsInChildren2 = val.GetComponentsInChildren<Cloth>();
						foreach (Cloth val3 in componentsInChildren2)
						{
							if (val3.capsuleColliders.Length != 0)
							{
								List<CapsuleCollider> list = new List<CapsuleCollider>(capsule);
								list.AddRange(val3.capsuleColliders);
								val3.capsuleColliders = list.ToArray();
							}
							else
							{
								val3.capsuleColliders = capsule;
							}
						}
					}
					else
					{
						Transform val4 = Utils.FindChild(pastOverrideModel.transform, text, (IterativeSearchType)0);
						if ((Object)(object)val4 == (Object)null)
						{
							break;
						}
						val = Object.Instantiate<GameObject>(((Component)child).gameObject, val4, true);
						val.SetActive(true);
						val.transform.localPosition = Vector3.zero;
						val.transform.localRotation = Quaternion.identity;
					}
					if (variant >= 0)
					{
						IEquipmentVisual componentInChildren = val.GetComponentInChildren<IEquipmentVisual>();
						if (componentInChildren != null)
						{
							componentInChildren.Setup(variant);
						}
					}
					CleanupInstance(val);
					EnableEquipedEffects(val);
				}
			}

			private GameObject AttachItem(GameObject itemPrefab, int variant, Transform joint, SkinnedMeshRenderer m_bodyModel, bool INVERT)
			{
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: 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_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)itemPrefab == (Object)null)
				{
					return null;
				}
				GameObject val = null;
				int childCount = itemPrefab.transform.childCount;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = itemPrefab.transform.GetChild(i);
					string name = ((Object)((Component)child).gameObject).name;
					if ((name == "attach" || name == "attach_skin") ? true : false)
					{
						val = ((Component)child).gameObject;
						break;
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				GameObject val2 = Object.Instantiate<GameObject>(val);
				val2.SetActive(true);
				CleanupInstance(val2);
				EnableEquipedEffects(val2);
				if (((Object)val).name == "attach_skin")
				{
					val2.transform.SetParent(((Component)m_bodyModel).transform.parent);
					val2.transform.localPosition = Vector3.zero;
					val2.transform.localRotation = Quaternion.identity;
					if (INVERT && itemPrefab.GetComponent<ItemDrop>().m_itemData.IsWeapon())
					{
						val2.transform.localPosition = new Vector3(-0.003f, 2E-05f, 0.003f);
						val2.transform.localEulerAngles = new Vector3(0f, 80f, 0f);
					}
					SkinnedMeshRenderer[] componentsInChildren = val2.GetComponentsInChildren<SkinnedMeshRenderer>();
					foreach (SkinnedMeshRenderer val3 in componentsInChildren)
					{
						val3.rootBone = m_bodyModel.rootBone;
						val3.bones = m_bodyModel.bones;
					}
				}
				else
				{
					val2.transform.SetParent(joint);
					val2.transform.localPosition = Vector3.zero;
					val2.transform.localRotation = Quaternion.identity;
					if (INVERT && itemPrefab.GetComponent<ItemDrop>().m_itemData.IsWeapon())
					{
						val2.transform.localPosition = new Vector3(-0.003f, 2E-05f, 0.003f);
						val2.transform.localEulerAngles = new Vector3(0f, 80f, 0f);
					}
				}
				IEquipmentVisual componentInChildren = val2.GetComponentInChildren<IEquipmentVisual>();
				if (componentInChildren != null)
				{
					componentInChildren.Setup(variant);
				}
				return val2;
			}

			private GameObject EquipItemsOnModel(Transform joint, string prefab, SkinnedMeshRenderer mesh, bool INVERT = false)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(prefab));
				if ((Object)(object)joint == (Object)null || (Object)(object)itemPrefab == (Object)null)
				{
					return null;
				}
				return AttachItem(itemPrefab, 0, joint, mesh, INVERT);
			}

			private void EquipItemsOnModel(SkinnedMeshRenderer joint, string prefab, CapsuleCollider[] capsule)
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Invalid comparison between Unknown and I4
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Invalid comparison between Unknown and I4
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(prefab));
				if ((Object)(object)joint == (Object)null || (Object)(object)itemPrefab == (Object)null)
				{
					return;
				}
				ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null))
				{
					if ((int)component.m_itemData.m_shared.m_itemType == 7 && Object.op_Implicit((Object)(object)component.m_itemData.m_shared.m_armorMaterial))
					{
						((Renderer)joint).material.SetTexture(ChestTex, component.m_itemData.m_shared.m_armorMaterial.GetTexture(ChestTex));
						((Renderer)joint).material.SetTexture(ChestBumpMap, component.m_itemData.m_shared.m_armorMaterial.GetTexture(ChestBumpMap));
						((Renderer)joint).material.SetTexture(ChestMetal, component.m_itemData.m_shared.m_armorMaterial.GetTexture(ChestMetal));
					}
					if ((int)component.m_itemData.m_shared.m_itemType == 11 && Object.op_Implicit((Object)(object)component.m_itemData.m_shared.m_armorMaterial))
					{
						((Renderer)joint).material.SetTexture(LegsTex, component.m_itemData.m_shared.m_armorMaterial.GetTexture(LegsTex));
						((Renderer)joint).material.SetTexture(LegsBumpMap, component.m_itemData.m_shared.m_armorMaterial.GetTexture(LegsBumpMap));
						((Renderer)joint).material.SetTexture(LegsMetal, component.m_itemData.m_shared.m_armorMaterial.GetTexture(LegsMetal));
					}
					AttachArmor(StringExtensionMethods.GetStableHashCode(prefab), joint, capsule);
				}
			}

			private bool TryOverrideModel(ref string prefab, out bool isFemale, bool EquipItems = true)
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: 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_0185: 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_019a: Expected O, but got Unknown
				//IL_0336: Unknown result type (might be due to invalid IL or missing references)
				//IL_033b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0380: Unknown result type (might be due to invalid IL or missing references)
				//IL_039b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0288: Unknown result type (might be due to invalid IL or missing references)
				//IL_028f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0932: Unknown result type (might be due to invalid IL or missing references)
				//IL_0939: Unknown result type (might be due to invalid IL or missing references)
				//IL_08fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0849: Unknown result type (might be due to invalid IL or missing references)
				bool flag = false;
				float num = znv.m_zdo.GET_NPC_TextSize();
				float num2 = znv.m_zdo.GET_NPC_TextHeight();
				((Component)canvas).gameObject.transform.localScale = new Vector3(num, num, num);
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(0f, 3.4f, 0f);
				val += new Vector3(0f, num2, 0f);
				canvas.transform.localPosition = val;
				if (Object.op_Implicit((Object)(object)pastOverrideModel))
				{
					Object.Destroy((Object)(object)pastOverrideModel);
				}
				((Behaviour)zanim).enabled = false;
				if (prefab.Contains("@humanoid"))
				{
					flag = true;
					prefab = prefab.Replace("@humanoid", "");
				}
				isFemale = false;
				if (prefab == "Player_Female")
				{
					prefab = "Player";
					isFemale = true;
				}
				GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
				if (!Object.op_Implicit((Object)(object)prefab2))
				{
					return false;
				}
				if ((Object)(object)prefab2.GetComponent<Character>() == (Object)null)
				{
					Collider val2 = (((Object)(object)prefab2.GetComponent<Collider>() != (Object)null) ? prefab2.GetComponent<Collider>() : prefab2.GetComponentInChildren<Collider>());
					if ((Object)(object)val2 == (Object)null)
					{
						return false;
					}
					GameObject val3 = new GameObject("OverrideModel")
					{
						layer = LayerMask.NameToLayer("character")
					};
					val3.transform.parent = ((Component)this).transform;
					val3.transform.localPosition = Vector3.zero;
					val3.transform.localRotation = Quaternion.identity;
					val3.transform.localScale = Vector3.one;
					pastOverrideModel = val3;
					for (int i = 0; i < prefab2.transform.childCount; i++)
					{
						GameObject gameObject = ((Component)prefab2.transform.GetChild(i)).gameObject;
						Object.Instantiate<GameObject>(gameObject, pastOverrideModel.transform);
					}
					Collider[] componentsInChildren = pastOverrideModel.GetComponentsInChildren<Collider>();
					foreach (Collider val4 in componentsInChildren)
					{
						((Component)val4).gameObject.layer = LayerMask.NameToLayer("character");
						if (val4.isTrigger)
						{
							val4.enabled = false;
						}
					}
					if (!Object.op_Implicit((Object)(object)pastOverrideModel.GetComponentInChildren<Collider>()))
					{
						Utils.CopyComponent<Collider>(val2, pastOverrideModel);
					}
					if (EquipItems)
					{
						float num3 = znv.m_zdo.GetFloat("KGnpcScale", 1f);
						if (num3 < 0.1f)
						{
							num3 = 0.1f;
						}
						Transform transform = pastOverrideModel.transform;
						transform.localScale *= num3;
					}
				}
				else
				{
					Collider val5 = (((Object)(object)prefab2.GetComponent<Collider>() != (Object)null) ? prefab2.GetComponent<Collider>() : prefab2.GetComponentInChildren<Collider>());
					if ((Object)(object)val5 == (Object)null)
					{
						return false;
					}
					Animator componentInChildren = prefab2.GetComponentInChildren<Animator>();
					prefab2 = ((componentInChildren != null) ? ((Component)componentInChildren).gameObject : null);
					if (!Object.op_Implicit((Object)(object)prefab2))
					{
						return false;
					}
					pastOverrideModel = Object.Instantiate<GameObject>(prefab2, ((Component)this).transform);
					LODGroup component = pastOverrideModel.GetComponent<LODGroup>();
					if (Object.op_Implicit((Object)(object)component))
					{
						Object.Destroy((Object)(object)component);
					}
					ParticleSystem[] componentsInChildren2 = pastOverrideModel.GetComponentsInChildren<ParticleSystem>();
					foreach (ParticleSystem val6 in componentsInChildren2)
					{
						EmissionModule emission = val6.emission;
						((EmissionModule)(ref emission)).enabled = false;
					}
					pastOverrideModel.layer = LayerMask.NameToLayer("character");
					Utils.CopyComponent<Collider>(val5, pastOverrideModel);
					pastOverrideModel.transform.localPosition = Vector3.zero;
					pastOverrideModel.transform.rotation = ((Component)this).transform.rotation;
					if (flag)
					{
						pastOverrideModel.GetComponent<Animator>().runtimeAnimatorController = ZNetScene.instance.GetPrefab("Player").GetComponentInChildren<Animator>().runtimeAnimatorController;
					}
					zanim.m_animator = pastOverrideModel.GetComponent<Animator>();
					((Behaviour)zanim).enabled = true;
					pastOverrideModel.GetComponent<Animator>().SetBool(Wakeup, false);
					pastOverrideModel.GetComponent<Animator>().SetInteger(Crafting, znv.m_zdo.GetInt("KGcraftingAnimation", 0));
					if (EquipItems)
					{
						VisEquipment component2 = ZNetScene.instance.GetPrefab(prefab).GetComponent<VisEquipment>();
						if (Object.op_Implicit((Object)(object)component2))
						{
							SkinnedMeshRenderer componentInChildren2 = pastOverrideModel.GetComponentInChildren<SkinnedMeshRenderer>();
							Transform transform2 = pastOverrideModel.transform;
							Transform leftHand = component2.m_leftHand;
							Transform joint = Utils.FindChild(transform2, (leftHand != null) ? ((Object)leftHand).name : null, (IterativeSearchType)0);
							Transform transform3 = pastOverrideModel.transform;
							Transform rightHand = component2.m_rightHand;
							Transform joint2 = Utils.FindChild(transform3, (rightHand != null) ? ((Object)rightHand).name : null, (IterativeSearchType)0);
							Transform transform4 = pastOverrideModel.transform;
							Transform helmet = component2.m_helmet;
							Transform joint3 = Utils.FindChild(transform4, (helmet != null) ? ((Object)helmet).name : null, (IterativeSearchType)0);
							Transform transform5 = pastOverrideModel.transform;
							Transform backShield = component2.m_backShield;
							Transform joint4 = Utils.FindChild(transform5, (backShield != null) ? ((Object)backShield).name : null, (IterativeSearchType)0);
							Transform transform6 = pastOverrideModel.transform;
							Transform backMelee = component2.m_backMelee;
							Transform joint5 = Utils.FindChild(transform6, (backMelee != null) ? ((Object)backMelee).name : null, (IterativeSearchType)0);
							string @string = znv.m_zdo.GetString("KGleftItem", "");
							string string2 = znv.m_zdo.GetString("KGrightItem", "");
							string string3 = znv.m_zdo.GetString("KGhelmetItem", "");
							EquipItemsOnModel(joint, @string, componentInChildren2);
							EquipItemsOnModel(joint2, string2, componentInChildren2);
							string string4 = znv.m_zdo.GetString("KGLeftItemBack", "");
							string string5 = znv.m_zdo.GetString("KGRightItemBack", "");
							EquipItemsOnModel(joint, @string, componentInChildren2);
							EquipItemsOnModel(joint2, string2, componentInChildren2);
							EquipItemsOnModel(joint5, string5, componentInChildren2);
							if (Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(string4)))
							{
								if (ZNetScene.instance.GetPrefab(string4).GetComponent<ItemDrop>().m_itemData.IsWeapon())
								{
									EquipItemsOnModel(joint5, string4, componentInChildren2, INVERT: true);
								}
								else
								{
									EquipItemsOnModel(joint4, string4, componentInChildren2);
								}
							}
							_ = (Object)(object)EquipItemsOnModel(joint3, string3, componentInChildren2) != (Object)null;
							if ((Object)(object)pastOverrideModel.GetComponent<CustomLookAt>() == (Object)null && znv.m_zdo.GetInt("KGcraftingAnimation", 0) == 0)
							{
								pastOverrideModel.AddComponent<CustomLookAt>();
							}
							CapsuleCollider[] capsule = (from x in pastOverrideModel.GetComponentsInChildren<CapsuleCollider>()
								where (Object)(object)x != (Object)(object)pastOverrideModel.GetComponent<CapsuleCollider>()
								select x).ToArray();
							string string6 = znv.m_zdo.GetString("KGchestItem", "");
							string string7 = znv.m_zdo.GetString("KGlegsItem", "");
							string string8 = znv.m_zdo.GetString("KGcapeItem", "");
							string prefab3 = "Beard" + znv.m_zdo.GetString("KGbeardItem", "");
							EquipItemsOnModel(componentInChildren2, string8, capsule);
							EquipItemsOnModel(componentInChildren2, string6, capsule);
							EquipItemsOnModel(componentInChildren2, string7, capsule);
							string prefab4 = "Hair" + znv.m_zdo.GetString("KGhairItem", "");
							GameObject val7 = EquipItemsOnModel(joint3, prefab4, componentInChildren2);
							Color val8 = default(Color);
							ColorUtility.TryParseHtmlString(znv.m_zdo.GetString("KGhairItemColor", ""), ref val8);
							if (Object.op_Implicit((Object)(object)val7))
							{
								Renderer[] componentsInChildren3 = val7.GetComponentsInChildren<Renderer>();
								Renderer[] array = componentsInChildren3;
								foreach (Renderer val9 in array)
								{
									val9.material.SetColor(SkinColor, val8);
								}
							}
							GameObject val10 = EquipItemsOnModel(joint3, prefab3, componentInChildren2);
							Color val11 = default(Color);
							ColorUtility.TryParseHtmlString(znv.m_zdo.GetString("KGbeardColor", ""), ref val11);
							if (Object.op_Implicit((Object)(object)val10))
							{
								Renderer[] componentsInChildren4 = val10.GetComponentsInChildren<Renderer>();
								Renderer[] array2 = componentsInChildren4;
								foreach (Renderer val12 in array2)
								{
									val12.material.SetColor(SkinColor, val11);
								}
							}
							if (isFemale)
							{
								componentInChildren2.sharedMesh = component2.m_models[1].m_mesh;
								((Renderer)componentInChildren2).materials[0].SetTexture(MainTex, component2.m_models[1].m_baseMaterial.GetTexture(MainTex));
								((Renderer)componentInChildren2).materials[0].SetTexture(SkinBumpMap, component2.m_models[1].m_baseMaterial.GetTexture(SkinBumpMap));
							}
							Color val13 = default(Color);
							ColorUtility.TryParseHtmlString(znv.m_zdo.GetString("KGskinColor", ""), ref val13);
							((Renderer)componentInChildren2).materials[0].SetColor(SkinColor, val13);
						}
						float num4 = znv.m_zdo.GET_NPC_NPCScale();
						if (num4 < 0.1f)
						{
							num4 = 0.1f;
						}
						Transform transform7 = pastOverrideModel.transform;
						transform7.localScale *= num4;
					}
				}
				return true;
			}

			public void ChangeNpcType(long sender, int index, bool isPinned, string pinIcon)
			{
				if (znv.IsOwner())
				{
					znv.m_zdo.SET_NPC_Type((Marketplace_API.API_NPCType)index);
					znv.m_zdo.SET_NPC_IsPinned(isPinned);
					znv.m_zdo.SET_NPC_PinIcon(pinIcon);
				}
				_currentNpcType = (NPCType)index;
			}

			public void Damage(HitData hit)
			{
				if (znv.IsValid() && Object.op_Implicit((Object)(object)zanim.m_animator))
				{
					zanim.SetTrigger("stagger");
				}
			}

			public DestructibleType GetDestructibleType()
			{
				return (DestructibleType)0;
			}
		}

		public static class NPCUI
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static UnityAction <0>__ApplyMain;

				public static UnityAction <1>__ApplyFashion;
			}

			private static Action _callback;

			private static GameObject UI = null;

			private static ZDO _currentNPC;

			private static GameObject MAIN = null;

			private static GameObject FASHION = null;

			private static Transform NPCTypeButtons = null;

			private static NPCType _currentType;

			private static InputField _npcprofile = null;

			private static InputField _npcname = null;

			private static InputField _npcmodel = null;

			private static InputField _patroldata = null;

			private static InputField _npcdialogue = null;

			private static Toggle _npcpinned = null;

			private static InputField _npcmapicon = null;

			private static InputField LeftItemFashion = null;

			private static InputField RightItemFashion = null;

			private static InputField HelmetItemFashion = null;

			private static InputField ChestItemFashion = null;

			private static InputField LegsItemFashion = null;

			private static InputField RightItemHiddenFashion = null;

			private static InputField LeftItemHiddenFashion = null;

			private static InputField HairItemFashion = null;

			private static InputField SkinColorFashion = null;

			private static InputField HairItemFashionColor = null;

			private static InputField ModelScaleFashion = null;

			private static InputField CapeItemFashion = null;

			private static InputField NPCinteractAnimation = null;

			private static InputField NPCgreetAnimation = null;

			private static InputField NPCgreetText = null;

			private static InputField NPCbyeAnimation = null;

			private static InputField NPCbyeText = null;

			private static InputField NPCcraftingAnimation = null;

			private static InputField BeardItemFashion = null;

			private static InputField BeardItemFashionColor = null;

			private static InputField InteractAudioClip = null;

			private static InputField TextSize = null;

			private static InputField TextHeight = null;

			private static InputField PeriodicAnimation = null;

			private static InputField PeriodicAnimationTime = null;

			private static InputField PeriodicSound = null;

			private static InputField PeriodicSoundTime = null;

			private static bool playSound = true;

			public static void Init()
			{
				//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f1: Expected O, but got Unknown
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0232: Expected O, but got Unknown
				//IL_058f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0594: Unknown result type (might be due to invalid IL or missing references)
				//IL_059a: Expected O, but got Unknown
				UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceNPCUI"));
				Object.DontDestroyOnLoad((Object)(object)UI);
				UI.SetActive(false);
				NPCTypeButtons = UI.transform.Find("Canvas/MAIN/Pergament/NPCTYPE");
				MAIN = ((Component)UI.transform.Find("Canvas/MAIN")).gameObject;
				FASHION = ((Component)UI.transform.Find("Canvas/FASHION")).gameObject;
				_npcprofile = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/NPCPROFILE")).GetComponent<InputField>();
				_npcname = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/NPCNAME")).GetComponent<InputField>();
				_npcmodel = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/NPCMODEL")).GetComponent<InputField>();
				_patroldata = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/PATROLDATA")).GetComponent<InputField>();
				_npcdialogue = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/NPCDIALOGUE")).GetComponent<InputField>();
				_npcpinned = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/ISPINNED")).GetComponent<Toggle>();
				((UnityEvent<bool>)(object)_npcpinned.onValueChanged).AddListener((UnityAction<bool>)delegate
				{
					if (playSound)
					{
						AssetStorage.AUsrc.Play();
					}
				});
				_npcmapicon = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/MAPPINICON")).GetComponent<InputField>();
				MAIN.SetActive(false);
				FASHION.SetActive(false);
				Localization.instance.Localize(UI.transform);
				int childCount = NPCTypeButtons.childCount;
				for (int j = 0; j < childCount; j++)
				{
					Transform child = NPCTypeButtons.GetChild(j);
					int i1 = j;
					((UnityEvent)((Component)child).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						AssetStorage.AUsrc.Play();
						_currentType = (NPCType)i1;
						CheckColors();
					});
				}
				ButtonClickedEvent onClick = ((Component)UI.transform.Find("Canvas/MAIN/Pergament/Apply")).GetComponent<Button>().onClick;
				object obj = <>O.<0>__ApplyMain;
				if (obj == null)
				{
					UnityAction val = ApplyMain;
					<>O.<0>__ApplyMain = val;
					obj = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				LeftItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/LeftItemFashion")).GetComponent<InputField>();
				RightItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/RightItemFashion")).GetComponent<InputField>();
				HelmetItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/HelmetItemFashion")).GetComponent<InputField>();
				ChestItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/ChestItemFashion")).GetComponent<InputField>();
				LegsItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/LegsItemFashion")).GetComponent<InputField>();
				RightItemHiddenFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/RightItemHiddenFashion")).GetComponent<InputField>();
				LeftItemHiddenFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/LeftItemHiddenFashion")).GetComponent<InputField>();
				HairItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/HairItemFashion")).GetComponent<InputField>();
				SkinColorFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/SkinColorFashion")).GetComponent<InputField>();
				HairItemFashionColor = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/HairItemFashionColor")).GetComponent<InputField>();
				ModelScaleFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/ModelScaleFashion")).GetComponent<InputField>();
				CapeItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/CapeItemFashion")).GetComponent<InputField>();
				NPCinteractAnimation = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/NPCinteractAnimation")).GetComponent<InputField>();
				NPCgreetAnimation = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/NPCgreetAnimation")).GetComponent<InputField>();
				NPCgreetText = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/NPCgreetText")).GetComponent<InputField>();
				NPCbyeAnimation = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/NPCbyeAnimation")).GetComponent<InputField>();
				NPCbyeText = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/NPCbyeText")).GetComponent<InputField>();
				NPCcraftingAnimation = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/NPCcraftingAnimation")).GetComponent<InputField>();
				BeardItemFashion = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/BeardItemFashion")).GetComponent<InputField>();
				BeardItemFashionColor = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/BeardItemFashionColor")).GetComponent<InputField>();
				InteractAudioClip = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/InteractAudioClip")).GetComponent<InputField>();
				TextSize = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/TextSize")).GetComponent<InputField>();
				TextHeight = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/TextHeight")).GetComponent<InputField>();
				PeriodicAnimation = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/PeriodicAnimation")).GetComponent<InputField>();
				PeriodicAnimationTime = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/PeriodicAnimationTime")).GetComponent<InputField>();
				PeriodicSound = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/PeriodicSound")).GetComponent<InputField>();
				PeriodicSoundTime = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/PeriodicSoundTime")).GetComponent<InputField>();
				ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("Canvas/FASHION/Pergament/Apply")).GetComponent<Button>().onClick;
				object obj2 = <>O.<1>__ApplyFashion;
				if (obj2 == null)
				{
					UnityAction val2 = ApplyFashion;
					<>O.<1>__ApplyFashion = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			}

			private static void ApplyFashion()
			{
				//IL_0213: Unknown result type (might be due to invalid IL or missing references)
				AssetStorage.AUsrc.Play();
				if (_currentNPC == null || !_currentNPC.IsValid())
				{
					Hide();
					return;
				}
				NPC_DataTypes.NPC_Fashion nPC_Fashion = default(NPC_DataTypes.NPC_Fashion);
				nPC_Fashion.LeftItem = LeftItemFashion.text;
				nPC_Fashion.RightItem = RightItemFashion.text;
				nPC_Fashion.HelmetItem = HelmetItemFashion.text;
				nPC_Fashion.ChestItem = ChestItemFashion.text;
				nPC_Fashion.LegsItem = LegsItemFashion.text;
				nPC_Fashion.CapeItem = CapeItemFashion.text;
				nPC_Fashion.HairItem = HairItemFashion.text;
				nPC_Fashion.HairColor = HairItemFashionColor.text;
				nPC_Fashion.ModelScale = ModelScaleFashion.text;
				nPC_Fashion.LeftItemHidden = LeftItemHiddenFashion.text;
				nPC_Fashion.RightItemHidden = RightItemHiddenFashion.text;
				nPC_Fashion.InteractAnimation = NPCinteractAnimation.text;
				nPC_Fashion.GreetAnimation = NPCgreetAnimation.text;
				nPC_Fashion.ByeAnimation = NPCbyeAnimation.text;
				nPC_Fashion.GreetText = NPCgreetText.text;
				nPC_Fashion.ByeText = NPCbyeText.text;
				nPC_Fashion.SkinColor = SkinColorFashion.text;
				nPC_Fashion.CraftingAnimation = NPCcraftingAnimation.text;
				nPC_Fashion.BeardItem = BeardItemFashion.text;
				nPC_Fashion.BeardColor = BeardItemFashionColor.text;
				nPC_Fashion.InteractAudioClip = InteractAudioClip.text;
				nPC_Fashion.TextSize = TextSize.text;
				nPC_Fashion.TextHeight = TextHeight.text;
				nPC_Fashion.PeriodicAnimation = PeriodicAnimation.text;
				nPC_Fashion.PeriodicAnimationTime = PeriodicAnimationTime.text;
				nPC_Fashion.PeriodicSound = PeriodicSound.text;
				nPC_Fashion.PeriodicSoundTime = PeriodicSoundTime.text;
				NPC_DataTypes.NPC_Fashion nPC_Fashion2 = nPC_Fashion;
				if (_currentNPC.HasOwner())
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZNetView.Everybody, _currentNPC.m_uid, "KGmarket fashion", new object[1] { nPC_Fashion2 });
				}
				else
				{
					_currentNPC.SET_NPC_LeftItem(nPC_Fashion2.LeftItem);
					_currentNPC.SET_NPC_RightItem(nPC_Fashion2.RightItem);
					_currentNPC.SET_NPC_HelmetItem(nPC_Fashion2.HelmetItem);
					_currentNPC.SET_NPC_ChestItem(nPC_Fashion2.ChestItem);
					_currentNPC.SET_NPC_LegsItem(nPC_Fashion2.LegsItem);
					_currentNPC.SET_NPC_CapeItem(nPC_Fashion2.CapeItem);
					_currentNPC.SET_NPC_HairItem(nPC_Fashion2.HairItem);
					_currentNPC.SET_NPC_HairColor(nPC_Fashion2.HairColor);
					_currentNPC.SET_NPC_NPCScale(nPC_Fashion2.ModelScale);
					_currentNPC.SET_NPC_LeftItemBack(nPC_Fashion2.LeftItemHidden);
					_currentNPC.SET_NPC_RightItemBack(nPC_Fashion2.RightItemHidden);
					_currentNPC.SET_NPC_InteractAnimation(nPC_Fashion2.InteractAnimation);
					_currentNPC.SET_NPC_GreetingAnimation(nPC_Fashion2.GreetAnimation);
					_currentNPC.SET_NPC_ByeAnimation(nPC_Fashion2.ByeAnimation);
					_currentNPC.SET_NPC_GreetingText(nPC_Fashion2.GreetText);
					_currentNPC.SET_NPC_ByeText(nPC_Fashion2.ByeText);
					_currentNPC.SET_NPC_SkinColor(nPC_Fashion2.SkinColor);
					_currentNPC.SET_NPC_CraftingAnimation(nPC_Fashion2.CraftingAnimation);
					_currentNPC.SET_NPC_BeardItem(nPC_Fashion2.BeardItem);
					_currentNPC.SET_NPC_BeardColor(nPC_Fashion2.BeardColor);
					_currentNPC.SET_NPC_InteractSound(nPC_Fashion2.InteractAudioClip);
					_currentNPC.SET_NPC_TextSize(nPC_Fashion2.TextSize);
					_currentNPC.SET_NPC_TextHeight(nPC_Fashion2.TextHeight);
					_currentNPC.SET_NPC_PeriodicAnimation(nPC_Fashion2.PeriodicAnimation);
					_currentNPC.SET_NPC_PeriodicAnimationTime(nPC_Fashion2.PeriodicAnimationTime);
					_currentNPC.SET_NPC_PeriodicSound(nPC_Fashion2.PeriodicSound);
					_currentNPC.SET_NPC_PeriodicSoundTime(nPC_Fashion2.PeriodicSoundTime);
				}
				_callback?.Invoke();
				Hide();
			}

			private static void ApplyMain()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				AssetStorage.AUsrc.Play();
				if (_currentNPC == null || !_currentNPC.IsValid())
				{
					Hide();
					return;
				}
				if (_currentNPC.HasOwner())
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, _currentNPC.m_uid, "KGMarket changeNpcType", new object[3]
					{
						(int)_currentType,
						_npcpinned.isOn,
						_npcmapicon.text
					});
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, _currentNPC.m_uid, "KGmarket overridename", new object[1] { _npcname.text });
					ZRoutedRpc.instance.InvokeRoutedRPC(_currentNPC.GetOwner(), _currentNPC.m_uid, "KGmarket changeprofile", new object[2] { _npcprofile.text, _npcdialogue.text });
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, _currentNPC.m_uid, "KGmarket overridemodel", new object[1] { _npcmodel.text });
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, _currentNPC.m_uid, "KGmarket GetPatrolData", new object[1] { _patroldata.text });
				}
				else
				{
					_currentNPC.SET_NPC_Type((Marketplace_API.API_NPCType)_currentType);
					_currentNPC.SET_NPC_IsPinned(_npcpinned.isOn);
					_currentNPC.SET_NPC_Name(_npcname.text);
					_currentNPC.SET_NPC_Profile(_npcprofile.text);
					_currentNPC.SET_NPC_Dialogue(_npcdialogue.text);
					_currentNPC.SET_NPC_Model(_npcmodel.text);
					_currentNPC.SET_NPC_PatrolData(_patroldata.text);
					_currentNPC.SET_NPC_PinIcon(_npcmapicon.text);
				}
				_callback?.Invoke();
				Hide();
			}

			public static bool IsVisible()
			{
				if ((Object)(object)UI != (Object)null)
				{
					return UI.activeSelf;
				}
				return false;
			}

			public static void Hide()
			{
				UI.SetActive(false);
			}

			private static void CheckColors()
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				int childCount = NPCTypeButtons.childCount;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = NPCTypeButtons.GetChild(i);
					((Graphic)((Component)child).GetComponent<Image>()).color = ((i == (int)_currentType) ? Color.green : Color.white);
				}
			}

			public static void ShowFashion(ZDO _npc, Action callback = null)
			{
				FASHION.SetActive(true);
				MAIN.SetActive(false);
				_currentNPC = _npc;
				LeftItemFashion.text = _npc.GetString("KGleftItem", "");
				LeftItemHiddenFashion.text = _npc.GetString("KGLeftItemBack", "");
				RightItemHiddenFashion.text = _npc.GetString("KGRightItemBack", "");
				RightItemFashion.text = _npc.GetString("KGrightItem", "");
				HelmetItemFashion.text = _npc.GetString("KGhelmetItem", "");
				ChestItemFashion.text = _npc.GetString("KGchestItem", "");
				LegsItemFashion.text = _npc.GetString("KGlegsItem", "");
				HairItemFashion.text = _npc.GetString("KGhairItem", "");
				HairItemFashionColor.text = _npc.GetString("KGhairItemColor", "");
				CapeItemFashion.text = _npc.GetString("KGcapeItem", "");
				ModelScaleFashion.text = _npc.GetFloat("KGnpcScale", 1f).ToString(CultureInfo.InvariantCulture);
				NPCinteractAnimation.text = _npc.GetString("KGinteractAnimation", "");
				NPCgreetAnimation.text = _npc.GetString("KGgreetingAnimation", "");
				NPCbyeAnimation.text = _npc.GetString("KGbyeAnimation", "");
				NPCgreetText.text = _npc.GetString("KGgreetingText", "");
				NPCbyeText.text = _npc.GetString("KGbyeText", "");
				SkinColorFashion.text = _npc.GetString("KGskinColor", "");
				NPCcraftingAnimation.text = _npc.GetInt("KGcraftingAnimation", 0).ToString();
				BeardItemFashion.text = _npc.GetString("KGbeardItem", "");
				BeardItemFashionColor.text = _npc.GetString("KGbeardColor", "");
				InteractAudioClip.text = _npc.GetString("KGinteractSound", "");
				TextSize.text = _npc.GetFloat("KGtextSize", 3f).ToString(CultureInfo.InvariantCulture);
				TextHeight.text = _npc.GetFloat("KGtextHeight", 0f).ToString(CultureInfo.InvariantCulture);
				PeriodicAnimation.text = _npc.GetString("KGperiodicAnimation", "");
				PeriodicAnimationTime.text = _npc.GetFloat("KGperiodicAnimationTime", 0f).ToString(CultureInfo.InvariantCulture);
				PeriodicSound.text = _npc.GetString("KGperiodicSound", "");
				PeriodicSoundTime.text = _npc.GetFloat("KGperiodicSoundTime", 0f).ToString(CultureInfo.InvariantCulture);
				UI.SetActive(true);
				_callback = callback;
			}

			public static void ShowMain(ZDO _npc, Action callback = null)
			{
				FASHION.SetActive(false);
				MAIN.SetActive(true);
				int num = _npc.GetInt("KGmarketNPC", 0);
				if (num >= TypeNames.Length)
				{
					num = 0;
				}
				_currentType = (NPCType)num;
				_npcprofile.text = _npc.GET_NPC_Profile();
				_npcname.text = _npc.GET_NPC_Name();
				_npcmodel.text = _npc.GET_NPC_Model();
				_patroldata.text = _npc.GET_NPC_PatrolData();
				_npcdialogue.text = _npc.GET_NPC_Dialogue();
				_npcmapicon.text = _npc.GET_NPC_PinIcon();
				playSound = false;
				_npcpinned.isOn = _npc.GET_NPC_IsPinned();
				playSound = true;
				_currentNPC = _npc;
				CheckColors();
				UI.SetActive(true);
				_callback = callback;
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		[ClientOnlyPatch]
		private static class DebugModeBuildCheck
		{
			[UsedImplicitly]
			private static bool Prefix(Piece piece)
			{
				if (Object.op_Implicit((Object)(object)((Component)piece).GetComponent<NPCcomponent>()) && !Utils.IsDebug_Marketplace)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "<color=#00ff00>" + Localization.instance.Localize("$mpasn_enabledebugmode") + "</color>", 0, (Sprite)null, false);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		[ClientOnlyPatch]
		private static class Player_OnDeath_Patch
		{
			private static void Prefix(Player __instance)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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)
				Vector3 position = ((Component)__instance).transform.position;
				foreach (NPCcomponent item in NPCcomponent.ALL)
				{
					float num = Vector3.Distance(position, ((Component)item).transform.position);
					if (num > 12f)
					{
						continue;
					}
					string text = item.znv.m_zdo.GET_NPC_Dialogue();
					if (string.IsNullOrEmpty(text) || !Dialogues_DataTypes.ClientReadyDialogues.TryGetValue(text, out Dialogues_DataTypes.Dialogue value))
					{
						continue;
					}
					Dialogues_DataTypes.Dialogue.PlayerInteraction[] interactions = value.Interactions;
					foreach (Dialogues_DataTypes.Dialogue.PlayerInteraction playerInteraction in interactions)
					{
						if (playerInteraction.Type == Dialogues_DataTypes.RawDialogue.InteractionType.OutRange && playerInteraction.CheckCondition(item, out string _))
						{
							playerInteraction.CallCommands(item);
						}
					}
				}
			}
		}

		public static GameObject NPC = null;

		private static readonly string[] TypeNames = Enum.GetNames(typeof(NPCType));

		private static readonly int SkinColor = Shader.PropertyToID("_SkinColor");

		private static readonly int MainTex = Shader.PropertyToID("_MainTex");

		private static readonly int SkinBumpMap = Shader.PropertyToID("_SkinBumpMap");

		private static readonly int ChestTex = Shader.PropertyToID("_ChestTex");

		private static readonly int ChestBumpMap = Shader.PropertyToID("_ChestBumpMap");

		private static readonly int ChestMetal = Shader.PropertyToID("_ChestMetal");

		private static readonly int LegsTex = Shader.PropertyToID("_LegsTex");

		private static readonly int LegsBumpMap = Shader.PropertyToID("_LegsBumpMap");

		private static readonly int LegsMetal = Shader.PropertyToID("_LegsMetal");

		private static readonly int Wakeup = Animator.StringToHash("wakeup");

		private static readonly int Crafting = Animator.StringToHash("crafting");

		[UsedImplicitly]
		private static void OnInit()
		{
			NPC = AssetStorage.asset.LoadAsset<GameObject>("MarketPlaceNPC");
			NPC.AddComponent<NPCcomponent>();
			if (Marketplace.WorkingAsType != Marketplace.WorkingAs.Server)
			{
				((Component)NPC.transform.Find("TMP")).gameObject.AddComponent<TextComponent>();
				NPCUI.Init();
				Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(UpdateNPCGUI));
			}
		}

		private static void UpdateNPCGUI(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && NPCUI.IsVisible())
			{
				NPCUI.Hide();
				Menu.instance.OnClose();
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Both, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class NPC_MapPins
	{
		[HarmonyPatch(typeof(Minimap), "GetSprite")]
		[ClientOnlyPatch]
		private static class Minimap_GetSprite_Patch
		{
			[UsedImplicitly]
			private static void Postfix(PinType type, ref Sprite __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				if ((int)type == 175)
				{
					__result = AssetStorage.PlaceholderGamblerIcon;
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		[ClientOnlyPatch]
		private static class NPC_MapControllerPatch
		{
			[UsedImplicitly]
			private static void Prefix(Minimap __instance, MapMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 2 || !Utils.IsDebug_Strict || !NPC_MapController.EnableMapControl.Value)
				{
					return;
				}
				foreach (PinData tempNPCpin in TempNPCpins)
				{
					__instance.RemovePin(tempNPCpin);
				}
				TempNPCpins.Clear();
			}
		}

		[CompilerGenerated]
		private sealed class <SendNPCsToClients>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private int <index>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					goto IL_0083;
				case 2:
					{
						<>1__state = -1;
						goto IL_0022;
					}
					IL_0022:
					if (!Object.op_Implicit((Object)(object)Game.instance) || ZDOMan.instance == null || !Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
					{
						break;
					}
					TempNPCList.Clear();
					<index>5__2 = 0;
					goto IL_0083;
					IL_0083:
					if (!ZDOMan.instance.GetAllZDOsWithPrefabIterative("MarketPlaceNPC", TempNPCList, ref <index>5__2))
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					foreach (ZDO tempNPC in TempNPCList)
					{
						ZDOMan.instance.ForceSendZDO(tempNPC.m_uid);
					}
					break;
				}
				<>2__current = (object)new WaitForSeconds(10f);
				<>1__state = 2;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <UpdateNPCpins>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private List<ZDO> <AllNPCs>5__2;

			private int <index>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0302: Unknown result type (might be due to invalid IL or missing references)
				//IL_030c: Expected O, but got Unknown
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Invalid comparison between Unknown and I4
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Expected O, but got Unknown
				//IL_0210: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: 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
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0026;
				case 1:
					<>1__state = -1;
					goto IL_0026;
				case 2:
					<>1__state = -1;
					goto IL_0119;
				case 3:
					{
						<>1__state = -1;
						goto IL_0026;
					}
					IL_0026:
					if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || ZDOMan.instance == null || !Object.op_Implicit((Object)(object)Minimap.instance))
					{
						break;
					}
					foreach (PinData tempNPCpin in TempNPCpins)
					{
						Minimap.instance.RemovePin(tempNPCpin);
					}
					TempNPCpins.Clear();
					if ((int)Minimap.instance.m_mode == 2 && Utils.IsDebug_Strict && NPC_MapController.EnableMapControl.Value)
					{
						<>2__current = (object)new WaitForSecondsRealtime(1f);
						<>1__state = 1;
						return true;
					}
					<AllNPCs>5__2 = new List<ZDO>();
					<index>5__3 = 0;
					goto IL_0119;
					IL_0119:
					if (!ZDOMan.instance.GetAllZDOsWithPrefabIterative("MarketPlaceNPC", <AllNPCs>5__2, ref <index>5__3) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Minimap.instance))
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<AllNPCs>5__2.RemoveAll((ZDO zdo) => !zdo.GET_NPC_IsPinned());
					foreach (ZDO item in <AllNPCs>5__2)
					{
						if (item.IsValid())
						{
							string text = item.GET_NPC_Name();
							int num = (int)item.GET_NPC_Type();
							bool flag = Quests_DataTypes.Quest.IsQuestTarget(text);
							if (string.IsNullOrWhiteSpace(text))
							{
								Localization instance = Localization.instance;
								Market_NPC.NPCType nPCType = (Market_NPC.NPCType)num;
								text = instance.Localize("$" + nPCType);
							}
							PinData val = new PinData
							{
								m_type = (PinType)175,
								m_name = Utils.RichTextFormatting(text),
								m_pos = item.GetPosition()
							};
							if (!string.IsNullOrEmpty(val.m_name))
							{
								val.m_NamePinData = new PinNameData(val);
							}
							Sprite icon = Utils.TryFindIcon(item.GET_NPC_PinIcon(), AssetStorage.PlaceholderGamblerIcon);
							if (flag)
							{
								icon = AssetStorage.QuestCompleteIcon;
								val.m_animate = true;
								val.m_doubleSize = true;
							}
							val.m_icon = icon;
							val.m_save = false;
							val.m_checked = false;
							val.m_ownerID = 0L;
							TempNPCpins.Add(val);
						}
					}
					foreach (PinData item2 in TempNPCpins.OrderBy((PinData pin) => pin.m_animate))
					{
						Minimap.instance.m_pins.Add(item2);
					}
					<AllNPCs>5__2 = null;
					break;
				}
				<>2__current = (object)new WaitForSecondsRealtime(10f);
				<>1__state = 3;
				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();
			}
		}

		private const string npcToSearchPrefabName = "MarketPlaceNPC";

		private static readonly List<ZDO> TempNPCList = new List<ZDO>();

		private static readonly List<PinData> TempNPCpins = new List<PinData>();

		public const PinType PINTYPENPC = 175;

		[UsedImplicitly]
		private static void OnInit()
		{
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(SendNPCsToClients());
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(UpdateNPCpins());
		}

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

		[IteratorStateMachine(typeof(<SendNPCsToClients>d__8))]
		private static IEnumerator SendNPCsToClients()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendNPCsToClients>d__8(0);
		}
	}
}
namespace Marketplace.Modules.Leaderboard
{
	public static class Leaderboard_DataTypes
	{
		public enum TriggerType
		{
			MonstersKilled = 0,
			ItemsCrafted = 1,
			StructuresBuilt = 2,
			Died = 3,
			KilledBy = 4,
			Explored = 5,
			Harvested = 6,
			PlayersKilled = 100
		}

		public class Achievement
		{
			public int ID;

			public string Name;

			public string Description;

			public string Prefab;

			public int MinAmount;

			public Color32 Color;

			public int Score;

			public TriggerType Type;

			public bool Check(global::Marketplace.DB.DB.Player_Leaderboard lb)
			{
				int value;
				int value2;
				int value3;
				int value4;
				int value5;
				return Type switch
				{
					TriggerType.MonstersKilled => lb.KilledCreatures.TryGetValue(Prefab, out value) && value >= MinAmount, 
					TriggerType.ItemsCrafted => lb.ItemsCrafted.TryGetValue(Prefab, out value2) && value2 >= MinAmount, 
					TriggerType.StructuresBuilt => lb.BuiltStructures.TryGetValue(Prefab, out value3) && value3 >= MinAmount, 
					TriggerType.KilledBy => lb.KilledBy.TryGetValue(Prefab, out value4) && value4 >= MinAmount, 
					TriggerType.Explored => lb.MapExplored >= (float)MinAmount, 
					TriggerType.Died => lb.DeathAmount >= MinAmount, 
					TriggerType.PlayersKilled => lb.KilledPlayers >= MinAmount, 
					TriggerType.Harvested => lb.Harvested.TryGetValue(Prefab, out value5) && value5 >= MinAmount, 
					_ => false, 
				};
			}
		}

		internal class Client_Leaderboard : ISerializableParameter
		{
			public string PlayerName;

			public int KilledCreatures;

			public int KilledPlayers;

			public int BuiltStructures;

			public int ItemsCrafted;

			public int Died;

			public int Harvested;

			public float MapExplored;

			public List<int> Achievements = new List<int>();

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(PlayerName ?? "");
				pkg.Write(KilledCreatures);
				pkg.Write(KilledPlayers);
				pkg.Write(BuiltStructures);
				pkg.Write(ItemsCrafted);
				pkg.Write(Died);
				pkg.Write(MapExplored);
				pkg.Write(Harvested);
				pkg.Write(Achievements.Count);
				foreach (int achievement in Achievements)
				{
					pkg.Write(achievement);
				}
			}

			public void Deserialize(ref ZPackage pkg)
			{
				PlayerName = pkg.ReadString();
				KilledCreatures = pkg.ReadInt();
				KilledPlayers = pkg.ReadInt();
				BuiltStructures = pkg.ReadInt();
				ItemsCrafted = pkg.ReadInt();
				Died = pkg.ReadInt();
				MapExplored = pkg.ReadSingle();
				Harvested = pkg.ReadInt();
				int num = pkg.ReadInt();
				Achievements = new List<int>();
				for (int i = 0; i < num; i++)
				{
					Achievements.Add(pkg.ReadInt());
				}
			}
		}

		internal class Client_Achievement : ISerializableParameter
		{
			public int ID;

			public string Name;

			public int Score;

			public string Description;

			public Color32 Color;

			public void Serialize(ref ZPackage pkg)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				pkg.Write(Name ?? "");
				pkg.Write(Score);
				pkg.Write(Description ?? "");
				pkg.Write(Utils.ColorToVec3(Color32.op_Implicit(Color)));
				pkg.Write(ID);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				Name = pkg.ReadString();
				Score = pkg.ReadInt();
				Description = pkg.ReadString();
				Color = Color32.op_Implicit(Utils.Vec3ToColor(pkg.ReadVector3()));
				ID = pkg.ReadInt();
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, Client_Leaderboard>> SyncedClientLeaderboard = new CustomSyncedValue<Dictionary<string, Client_Leaderboard>>(Marketplace.configSync, "clientLeaderboard", new Dictionary<string, Client_Leaderboard>());

		internal static readonly CustomSyncedValue<List<Client_Achievement>> SyncedClientAchievements = new CustomSyncedValue<List<Client_Achievement>>(Marketplace.configSync, "clientAchievements", new List<Client_Achievement>());

		public static List<Achievement> AllAchievements = new List<Achievement>();
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class LeaderBoard_Main_Client
	{
		[HarmonyPatch(typeof(Player), "Update")]
		[ClientOnlyPatch]
		private static class Player_Update_Patch
		{
			private static float _time;

			[UsedImplicitly]
			private static void Postfix(Player __instance)
			{
				if (!Object.op_Implicit((Object)(object)Minimap.instance) || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !Global_Configs.SyncedGlobalOptions.Value._useLeaderboard)
				{
					return;
				}
				_time += Time.deltaTime;
				if (!(_time >= 180f))
				{
					return;
				}
				_time = 0f;
				int toExclusive = Minimap.instance.m_explored.Length;
				int trueAmount = 0;
				Parallel.ForEach(Partitioner.Create(0, toExclusive), new ParallelOptions
				{
					MaxDegreeOfParallelism = Environment.ProcessorCount / 2
				}, delegate(Tuple<int, int> range)
				{
					int num2 = 0;
					for (int i = range.Item1; i < range.Item2; i++)
					{
						if (Minimap.instance.m_explored[i])
						{
							num2++;
						}
					}
					Interlocked.Add(ref trueAmount, num2);
				});
				float num = (float)trueAmount / (float)Minimap.instance.m_explored.Length;
				num = Mathf.Min(1f, num * (4f / (float)Math.PI));
				num = (float)Math.Round(num * 100f, 2);
				SendToServer(Leaderboard_DataTypes.TriggerType.Explored, num);
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			Leaderboard_DataTypes.SyncedClientLeaderboard.Value.Count();
			Leaderboard_DataTypes.SyncedClientAchievements.Value.Count();
			GameEvents.OnPlayerDeath = (Action)Delegate.Combine(GameEvents.OnPlayerDeath, (Action)delegate
			{
				SendToServer(Leaderboard_DataTypes.TriggerType.Died);
			});
			GameEvents.OnCreatureKilled = (Action<string, int>)Delegate.Combine(GameEvents.OnCreatureKilled, (Action<string, int>)delegate(string prefab, int _)
			{
				SendToServer(Leaderboard_DataTypes.TriggerType.MonstersKilled, prefab);
			});
			GameEvents.OnStructureBuilt = (Action<string>)Delegate.Combine(GameEvents.OnStructureBuilt, (Action<string>)delegate(string prefab)
			{
				SendToServer(Leaderboard_DataTypes.TriggerType.StructuresBuilt, prefab);
			});
			GameEvents.OnItemCrafted = (Action<string, int>)Delegate.Combine(GameEvents.OnItemCrafted, (Action<string, int>)delegate(string prefab, int _)
			{
				SendToServer(Leaderboard_DataTypes.TriggerType.ItemsCrafted, prefab);
			});
			GameEvents.KilledBy = (Action<string>)Delegate.Combine(GameEvents.KilledBy, (Action<string>)delegate(string prefab)
			{
				SendToServer(Leaderboard_DataTypes.TriggerType.KilledBy, prefab);
			});
			GameEvents.OnHarvest = (Action<string>)Delegate.Combine(GameEvents.OnHarvest, (Action<string>)delegate(string prefab)
			{
				SendToServer(Leaderboard_DataTypes.TriggerType.Harvested, prefab);
			});
			Leaderboard_UI.Init();
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
		}

		private static void Update(float dt)
		{
			if (Input.GetKeyDown((KeyCode)27) && Leaderboard_UI.IsVisible())
			{
				Leaderboard_UI.Hide();
				Menu.instance.OnClose();
			}
			if (Input.GetKey((KeyCode)308) && Input.GetKeyDown((KeyCode)108))
			{
				if (Leaderboard_UI.IsVisible())
				{
					Leaderboard_UI.Hide();
				}
				else
				{
					Leaderboard_UI.Show();
				}
			}
		}

		public static bool HasAchievement(string achievementID)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(achievementID.Replace(" ", "").ToLower());
			if (Leaderboard_DataTypes.SyncedClientLeaderboard.Value.TryGetValue(Global_Configs._localUserID + "_" + Game.instance.m_playerProfile.m_playerName, out Leaderboard_DataTypes.Client_Leaderboard value))
			{
				return value.Achievements.Contains(stableHashCode);
			}
			return false;
		}

		public static string GetAchievementName(string achievementID)
		{
			int toId = StringExtensionMethods.GetStableHashCode(achievementID.Replace(" ", "").ToLower());
			return Leaderboard_DataTypes.SyncedClientAchievements.Value.Find((Leaderboard_DataTypes.Client_Achievement x) => x.ID == toId)?.Name ?? achievementID;
		}

		private static void SendToServer(Leaderboard_DataTypes.TriggerType type, params object[] args)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			if (Global_Configs.SyncedGlobalOptions.Value._useLeaderboard)
			{
				switch (type)
				{
				case Leaderboard_DataTypes.TriggerType.MonstersKilled:
				case Leaderboard_DataTypes.TriggerType.ItemsCrafted:
				case Leaderboard_DataTypes.TriggerType.StructuresBuilt:
				case Leaderboard_DataTypes.TriggerType.KilledBy:
				case Leaderboard_DataTypes.TriggerType.Harvested:
				{
					ZPackage val = new ZPackage();
					val.Write((string)args[0]);
					ZRoutedRpc.instance.InvokeRoutedRPC("Marketplace_Leaderboard_Receive", new object[2]
					{
						(int)type,
						val
					});
					break;
				}
				case Leaderboard_DataTypes.TriggerType.Died:
					ZRoutedRpc.instance.InvokeRoutedRPC("Marketplace_Leaderboard_Receive", new object[2]
					{
						(int)type,
						(object)new ZPackage()
					});
					break;
				case Leaderboard_DataTypes.TriggerType.Explored:
				{
					ZPackage val = new ZPackage();
					val.Write((float)args[0]);
					ZRoutedRpc.instance.InvokeRoutedRPC("Marketplace_Leaderboard_Receive", new object[2]
					{
						(int)type,
						val
					});
					break;
				}
				}
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Last, "OnInit", new string[] { "LA" }, new string[] { "OnAchievementsFileChange" })]
	public static class Leaderboard_Server_Main
	{
		[CompilerGenerated]
		private sealed class <UpdateLB>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer() && Global_Configs.SyncedGlobalOptions.Value._useLeaderboard)
					{
						SendToPlayers();
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = (object)new WaitForSecondsRealtime(300f);
				<>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();
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			ReadAchievementsProfiles();
			SendToPlayers();
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(UpdateLB());
		}

		[MarketplaceRPC("Marketplace_Leaderboard_Receive", Market_Autoload.Type.Server)]
		private static void RPC_ReceiveLeaderboardEvent(long sender, int type, ZPackage pkg)
		{
			if (!Global_Configs.SyncedGlobalOptions.Value._useLeaderboard)
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null)
			{
				return;
			}
			string hostName = peer.m_socket.GetHostName();
			if (hostName == "0")
			{
				return;
			}
			hostName = hostName + "_" + peer.m_playerName;
			global::Marketplace.DB.DB.Player_Leaderboard orCreateLeaderboard = global::Marketplace.DB.DB._context.GetOrCreateLeaderboard(hostName.Trim(), peer.m_playerName);
			if (orCreateLeaderboard.PlayerName == null)
			{
				orCreateLeaderboard.PlayerName = peer.m_playerName;
			}
			switch (type)
			{
			case 0:
			{
				string text = pkg.ReadString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				if (!orCreateLeaderboard.KilledCreatures.ContainsKey(text))
				{
					orCreateLeaderboard.KilledCreatures.Add(text, 1);
				}
				else
				{
					orCreateLeaderboard.KilledCreatures[text]++;
				}
				break;
			}
			case 1:
			{
				string text = pkg.ReadString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				if (!orCreateLeaderboard.ItemsCrafted.ContainsKey(text))
				{
					orCreateLeaderboard.ItemsCrafted.Add(text, 1);
				}
				else
				{
					orCreateLeaderboard.ItemsCrafted[text]++;
				}
				break;
			}
			case 2:
			{
				string text = pkg.ReadString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				if (!orCreateLeaderboard.BuiltStructures.ContainsKey(text))
				{
					orCreateLeaderboard.BuiltStructures.Add(text, 1);
				}
				else
				{
					orCreateLeaderboard.BuiltStructures[text]++;
				}
				break;
			}
			case 4:
			{
				string text = pkg.ReadString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				if (!orCreateLeaderboard.KilledBy.ContainsKey(text))
				{
					orCreateLeaderboard.KilledBy.Add(text, 1);
				}
				else
				{
					orCreateLeaderboard.KilledBy[text]++;
				}
				break;
			}
			case 3:
				orCreateLeaderboard.DeathAmount++;
				break;
			case 5:
				orCreateLeaderboard.MapExplored = pkg.ReadSingle();
				break;
			case 6:
			{
				string text = pkg.ReadString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				if (!orCreateLeaderboard.Harvested.ContainsKey(text))
				{
					orCreateLeaderboard.Harvested.Add(text, 1);
				}
				else
				{
					orCreateLeaderboard.Harvested[text]++;
				}
				break;
			}
			}
			global::Marketplace.DB.DB._context.UpdateLeaderboard(orCreateLeaderboard);
		}

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

		private static void SendToPlayers()
		{
			Leaderboard_DataTypes.SyncedClientLeaderboard.Value.Clear();
			foreach (KeyValuePair<string, global::Marketplace.DB.DB.Player_Leaderboard> allLeaderboard in global::Marketplace.DB.DB._context.GetAllLeaderboards())
			{
				Leaderboard_DataTypes.Client_Leaderboard client_Leaderboard = new Leaderboard_DataTypes.Client_Leaderboard
				{
					PlayerName = allLeaderboard.Value.PlayerName,
					ItemsCrafted = allLeaderboard.Value.ItemsCrafted.Sum<KeyValuePair<string, int>>((KeyValuePair<string, int> x) => x.Value),
					KilledCreatures = allLeaderboard.Value.KilledCreatures.Sum<KeyValuePair<string, int>>((KeyValuePair<string, int> x) => x.Value),
					BuiltStructures = allLeaderboard.Value.BuiltStructures.Sum<KeyValuePair<string, int>>((KeyValuePair<string, int> x) => x.Value),
					Harvested = allLeaderboard.Value.Harvested.Sum<KeyValuePair<string, int>>((KeyValuePair<string, int> x) => x.Value),
					KilledPlayers = allLeaderboard.Value.KilledPlayers,
					Died = allLeaderboard.Value.DeathAmount,
					MapExplored = allLeaderboard.Value.MapExplored,
					Achievements = new List<int>()
				};
				foreach (Leaderboard_DataTypes.Achievement allAchievement in Leaderboard_DataTypes.AllAchievements)
				{
					if (allAchievement.Check(allLeaderboard.Value))
					{
						client_Leaderboard.Achievements.Add(allAchievement.ID);
					}
				}
				Leaderboard_DataTypes.SyncedClientLeaderboard.Value.Add(allLeaderboard.Key, client_Leaderboard);
			}
			Leaderboard_DataTypes.SyncedClientLeaderboard.Update();
		}

		private static void ProcessAchievementsProfile(string fPath, IReadOnlyList<string> profiles)
		{
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			Leaderboard_DataTypes.Achievement achievement = null;
			for (int i = 0; i < profiles.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(profiles[i]) || profiles[i].StartsWith("#"))
				{
					continue;
				}
				if (profiles[i].StartsWith("["))
				{
					achievement = new Leaderboard_DataTypes.Achievement
					{
						ID = StringExtensionMethods.GetStableHashCode(profiles[i].Replace("[", "").Replace("]", "").ToLower())
					};
				}
				else
				{
					if (achievement == null)
					{
						continue;
					}
					try
					{
						string value = profiles[i];
						string name = profiles[i + 1];
						string description = profiles[i + 2];
						string text = profiles[i + 3];
						string text2 = profiles[i + 4];
						string s = profiles[i + 5];
						if (!Enum.TryParse<Leaderboard_DataTypes.TriggerType>(value, ignoreCase: true, out var result))
						{
							i += 5;
							continue;
						}
						achievement.Type = result;
						achievement.Name = name;
						achievement.Description = description;
						if ((result != Leaderboard_DataTypes.TriggerType.Died && result != Leaderboard_DataTypes.TriggerType.Explored && result != Leaderboard_DataTypes.TriggerType.PlayersKilled) || 1 == 0)
						{
							string[] array = text.Replace(" ", "").Split(new char[1] { ',' });
							achievement.Prefab = array[0];
							achievement.MinAmount = int.Parse(array[1]);
						}
						else
						{
							achievement.MinAmount = int.Parse(text);
						}
						string[] array2 = text2.Replace(" ", "").Split(new char[1] { ',' });
						achievement.Color = new Color32(byte.Parse(array2[0]), byte.Parse(array2[1]), byte.Parse(array2[2]), byte.MaxValue);
						achievement.Score = int.Parse(s);
						Leaderboard_DataTypes.AllAchievements.Add(achievement);
						achievement = null;
					}
					catch (Exception ex)
					{
						Utils.print("Failed to parse achievement " + fPath + " " + achievement?.Name + ": " + ex.Message, ConsoleColor.Red);
						i += 5;
					}
				}
			}
			Leaderboard_DataTypes.AllAchievements = Leaderboard_DataTypes.AllAchievements.OrderByDescending((Leaderboard_DataTypes.Achievement x) => x.Score).ToList();
			Leaderboard_DataTypes.SyncedClientAchievements.Value.Clear();
			foreach (Leaderboard_DataTypes.Achievement allAchievement in Leaderboard_DataTypes.AllAchievements)
			{
				Leaderboard_DataTypes.SyncedClientAchievements.Value.Add(new Leaderboard_DataTypes.Client_Achievement
				{
					ID = allAchievement.ID,
					Name = allAchievement.Name,
					Description = allAchievement.Description,
					Color = allAchievement.Color,
					Score = allAchievement.Score
				});
			}
		}

		private static void ReadAchievementsProfiles()
		{
			Leaderboard_DataTypes.AllAchievements.Clear();
			string leaderboardAchievementsFolder = Market_Paths.LeaderboardAchievementsFolder;
			string[] files = Directory.GetFiles(leaderboardAchievementsFolder, "*.cfg", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				IReadOnlyList<string> profiles = File.ReadAllLines(text).ToList();
				ProcessAchievementsProfile(text, profiles);
			}
			Leaderboard_DataTypes.SyncedClientAchievements.Update();
		}

		[UsedImplicitly]
		private static void OnAchievementsFileChange()
		{
			ReadAchievementsProfiles();
			Utils.print("Achievements Changed. Sending new info to all clients");
		}
	}
	public static class Leaderboard_UI
	{
		private enum SortBy
		{
			CreaturesKilled,
			BuiltStructures,
			ItemsCrafted,
			PlayersKilled,
			Died,
			MapExplored,
			TotalAchievements,
			Harvested
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class Menu_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= IsVisible();
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class Menu_OnLogoutYes_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				HideTF();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__NextPage;

			public static UnityAction <1>__PrevPage;

			public static Action <2>__OnChange;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__16_0;

			public static Func<KeyValuePair<string, Leaderboard_DataTypes.Client_Leaderboard>, Leaderboard_DataTypes.Client_Leaderboard> <>9__21_0;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_1;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_2;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_3;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_4;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, float> <>9__21_5;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_6;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_7;

			public static Func<Leaderboard_DataTypes.Client_Leaderboard, int> <>9__21_8;

			public static Action<UIInputHandler> <>9__23_1;

			internal void <Init>b__16_0()
			{
				AssetStorage.AUsrc.Play();
				if (IsVisible())
				{
					Hide();
				}
				else
				{
					Show();
				}
			}

			internal Leaderboard_DataTypes.Client_Leaderboard <SetSortBy>b__21_0(KeyValuePair<string, Leaderboard_DataTypes.Client_Leaderboard> x)
			{
				return x.Value;
			}

			internal int <SetSortBy>b__21_1(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.KilledCreatures;
			}

			internal int <SetSortBy>b__21_2(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.BuiltStructures;
			}

			internal int <SetSortBy>b__21_3(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.ItemsCrafted;
			}

			internal int <SetSortBy>b__21_4(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.Died;
			}

			internal float <SetSortBy>b__21_5(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.MapExplored;
			}

			internal int <SetSortBy>b__21_6(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return GetAchievementScore(x.Achievements);
			}

			internal int <SetSortBy>b__21_7(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.KilledPlayers;
			}

			internal int <SetSortBy>b__21_8(Leaderboard_DataTypes.Client_Leaderboard x)
			{
				return x.Harvested;
			}

			internal void <CreateElements>b__23_1(UIInputHandler _)
			{
				OnHoverEnd();
			}
		}

		private static GameObject UI = null;

		private static GameObject Main = null;

		private static SortBy CurrentSort;

		private static GameObject Element = null;

		private static Transform Content = null;

		private static GameObject Achievements = null;

		private static GameObject AchievementsElement = null;

		private static Transform AchievementContent = null;

		private static Text PageText = null;

		private static readonly Dictionary<SortBy, Button> SortButtons = new Dictionary<SortBy, Button>();

		private static int CurrentPage = 1;

		private const int MaxPerPage = 10;

		private static GameObject CurrentSelectedElement;

		private static List<Leaderboard_DataTypes.Client_Leaderboard> SortedList = new List<Leaderboard_DataTypes.Client_Leaderboard>();

		public static bool IsVisible()
		{
			if (Object.op_Implicit((Object)(object)Main))
			{
				return Main.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceLeaderboardUI"));
			Main = ((Component)UI.transform.Find("GO")).gameObject;
			Element = AssetStorage.asset.LoadAsset<GameObject>("MarketplaceLB_PlayerElement");
			Object.DontDestroyOnLoad((Object)(object)UI);
			Transform val = UI.transform.Find("GO/Header_Buttons");
			SortButtons.Add(SortBy.CreaturesKilled, ((Component)val.Find("CreaturesKilled")).GetComponent<Button>());
			SortButtons.Add(SortBy.BuiltStructures, ((Component)val.Find("BuiltStructures")).GetComponent<Button>());
			SortButtons.Add(SortBy.ItemsCrafted, ((Component)val.Find("ItemsCrafted")).GetComponent<Button>());
			SortButtons.Add(SortBy.Died, ((Component)val.Find("Died")).GetComponent<Button>());
			SortButtons.Add(SortBy.MapExplored, ((Component)val.Find("MapExplored")).GetComponent<Button>());
			SortButtons.Add(SortBy.TotalAchievements, ((Component)val.Find("TotalAchievements")).GetComponent<Button>());
			SortButtons.Add(SortBy.PlayersKilled, ((Component)val.Find("PlayersKilled")).GetComponent<Button>());
			SortButtons.Add(SortBy.Harvested, ((Component)val.Find("Harvested")).GetComponent<Button>());
			foreach (KeyValuePair<SortBy, Button> button in SortButtons)
			{
				((UnityEvent)button.Value.onClick).AddListener((UnityAction)delegate
				{
					AssetStorage.AUsrc.Play();
					SetSortBy(button.Key);
					CreateElements();
				});
			}
			Content = UI.transform.Find("GO/LB");
			PageText = ((Component)UI.transform.Find("GO/Page/Text")).GetComponent<Text>();
			ButtonClickedEvent onClick = ((Component)UI.transform.Find("GO/PageRight")).GetComponent<Button>().onClick;
			object obj = <>O.<0>__NextPage;
			if (obj == null)
			{
				UnityAction val2 = NextPage;
				<>O.<0>__NextPage = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("GO/PageLeft")).GetComponent<Button>().onClick;
			object obj2 = <>O.<1>__PrevPage;
			if (obj2 == null)
			{
				UnityAction val3 = PrevPage;
				<>O.<1>__PrevPage = val3;
				obj2 = (object)val3;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			Achievements = ((Component)UI.transform.Find("Achievements")).gameObject;
			AchievementsElement = AssetStorage.asset.LoadAsset<GameObject>("Marketplace_Achievement_Element");
			AchievementContent = Achievements.transform.Find("Scroll Rect/Viewport/Content");
			ButtonClickedEvent onClick3 = ((Component)UI.transform.Find("Open")).GetComponent<Button>().onClick;
			object obj3 = <>c.<>9__16_0;
			if (obj3 == null)
			{
				UnityAction val4 = delegate
				{
					AssetStorage.AUsrc.Play();
					if (IsVisible())
					{
						Hide();
					}
					else
					{
						Show();
					}
				};
				<>c.<>9__16_0 = val4;
				obj3 = (object)val4;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			UI.SetActive(false);
			Main.SetActive(false);
			Achievements.SetActive(false);
			SetSortBy(SortBy.TotalAchievements);
			Global_Configs.SyncedGlobalOptions.ValueChanged += OnChange;
			Localization.instance.Localize(UI.transform);
		}

		private static void OnChange()
		{
			if (Global_Configs.SyncedGlobalOptions.Value._useLeaderboard)
			{
				ShowTF();
			}
			else
			{
				HideTF();
			}
		}

		private static void NextPage()
		{
			AssetStorage.AUsrc.Play();
			int num = Mathf.CeilToInt((float)SortedList.Count / 10f);
			if (CurrentPage + 1 <= num)
			{
				CurrentPage++;
				if (num == 0)
				{
					num = 1;
				}
				PageText.text = $"{CurrentPage}/{num}";
				CreateElements();
			}
		}

		private static void PrevPage()
		{
			AssetStorage.AUsrc.Play();
			if (CurrentPage - 1 >= 1)
			{
				CurrentPage--;
				int num = Mathf.CeilToInt((float)SortedList.Count / 10f);
				if (num == 0)
				{
					num = 1;
				}
				PageText.text = $"{CurrentPage}/{num}";
				CreateElements();
			}
		}

		public static int GetAchievementScore(List<int> achievements)
		{
			int num = 0;
			foreach (int achievement in achievements)
			{
				num += Leaderboard_DataTypes.SyncedClientAchievements.Value.Find((Leaderboard_DataTypes.Client_Achievement x) => x.ID == achievement)?.Score ?? 0;
			}
			return num;
		}

		private static void SetSortBy(SortBy sort)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			CurrentSort = sort;
			foreach (KeyValuePair<SortBy, Button> sortButton in SortButtons)
			{
				((Graphic)((Component)sortButton.Value).GetComponent<Text>()).color = new Color(0.9137256f, 0.8627452f, 0.007843138f);
			}
			((Graphic)((Component)SortButtons[sort]).GetComponent<Text>()).color = Color.green;
			List<Leaderboard_DataTypes.Client_Leaderboard> source = Leaderboard_DataTypes.SyncedClientLeaderboard.Value.Select<KeyValuePair<string, Leaderboard_DataTypes.Client_Leaderboard>, Leaderboard_DataTypes.Client_Leaderboard>((KeyValuePair<string, Leaderboard_DataTypes.Client_Leaderboard> x) => x.Value).ToList();
			SortedList = sort switch
			{
				SortBy.CreaturesKilled => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.KilledCreatures).ToList(), 
				SortBy.BuiltStructures => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.BuiltStructures).ToList(), 
				SortBy.ItemsCrafted => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.ItemsCrafted).ToList(), 
				SortBy.Died => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.Died).ToList(), 
				SortBy.MapExplored => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.MapExplored).ToList(), 
				SortBy.TotalAchievements => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => GetAchievementScore(x.Achievements)).ToList(), 
				SortBy.PlayersKilled => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.KilledPlayers).ToList(), 
				SortBy.Harvested => source.OrderByDescending((Leaderboard_DataTypes.Client_Leaderboard x) => x.Harvested).ToList(), 
				_ => new List<Leaderboard_DataTypes.Client_Leaderboard>(), 
			};
			int num = Mathf.CeilToInt((float)SortedList.Count / 10f);
			if (num == 0)
			{
				num = 1;
			}
			PageText.text = $"{CurrentPage}/{num}";
		}

		private static void Default()
		{
			Main.SetActive(false);
			Achievements.SetActive(false);
			CurrentPage = 1;
			CurrentSelectedElement = null;
			SetSortBy(SortBy.TotalAchievements);
		}

		private static void CreateElements()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in Content)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			Achievements.SetActive(false);
			CurrentSelectedElement = null;
			int num = (CurrentPage - 1) * 10;
			int num2 = num + 10;
			for (int i = num; i < num2; i++)
			{
				if (i < SortedList.Count)
				{
					GameObject element = Object.Instantiate<GameObject>(Element, Content);
					Leaderboard_DataTypes.Client_Leaderboard data = SortedList[i];
					Transform val2 = element.transform.Find("Rank");
					string text = (i + 1).ToString();
					if (i + 1 <= 3)
					{
						((Component)val2.Find(text)).gameObject.SetActive(true);
					}
					else
					{
						((Component)val2.Find("etc")).gameObject.SetActive(true);
					}
					((Component)val2.Find("Text")).GetComponent<Text>().text = text;
					((Component)element.transform.Find("PlayerName")).GetComponent<Text>().text = data.PlayerName;
					((Component)element.transform.Find("CreaturesKilled")).GetComponent<Text>().text = data.KilledCreatures.ToString();
					((Component)element.transform.Find("BuiltStructures")).GetComponent<Text>().text = data.BuiltStructures.ToString();
					((Component)element.transform.Find("ItemsCrafted")).GetComponent<Text>().text = data.ItemsCrafted.ToString();
					((Component)element.transform.Find("Died")).GetComponent<Text>().text = data.Died.ToString();
					((Component)element.transform.Find("PlayersKilled")).GetComponent<Text>().text = data.KilledPlayers.ToString();
					((Component)element.transform.Find("Harvested")).GetComponent<Text>().text = data.Harvested.ToString();
					((Component)element.transform.Find("MapExplored")).GetComponent<Text>().text = data.MapExplored + "%";
					((Component)element.transform.Find("TotalAchievements")).GetComponent<Text>().text = GetAchievementScore(data.Achievements).ToString();
					((Graphic)((Component)element.transform.Find(CurrentSort.ToString())).GetComponent<Text>()).color = Color.green;
					UIInputHandler component = element.GetComponent<UIInputHandler>();
					component.m_onPointerEnter = (Action<UIInputHandler>)Delegate.Combine(component.m_onPointerEnter, (Action<UIInputHandler>)delegate
					{
						OnHoverStart(element);
					});
					UIInputHandler component2 = element.GetComponent<UIInputHandler>();
					component2.m_onPointerExit = (Action<UIInputHandler>)Delegate.Combine(component2.m_onPointerExit, (Action<UIInputHandler>)delegate
					{
						OnHoverEnd();
					});
					UIInputHandler component3 = element.GetComponent<UIInputHandler>();
					component3.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(component3.m_onLeftClick, (Action<UIInputHandler>)delegate
					{
						OnElementClick(element, data);
					});
					continue;
				}
				break;
			}
		}

		private static void OnHoverStart(GameObject go)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in Content)
			{
				Transform val = item;
				if ((Object)(object)((Component)val).gameObject != (Object)(object)CurrentSelectedElement)
				{
					((Graphic)((Component)val.Find("fill")).GetComponent<Image>()).color = Color.white;
				}
			}
			if ((Object)(object)go != (Object)(object)CurrentSelectedElement)
			{
				((Graphic)((Component)go.transform.Find("fill")).GetComponent<Image>()).color = new Color(0.44f, 1f, 0.51f);
			}
		}

		private static void OnHoverEnd()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in Content)
			{
				Transform val = item;
				if ((Object)(object)((Component)val).gameObject != (Object)(object)CurrentSelectedElement)
				{
					((Graphic)((Component)val.Find("fill")).GetComponent<Image>()).color = Color.white;
				}
			}
		}

		private static void OnElementClick(GameObject go, Leaderboard_DataTypes.Client_Leaderboard board)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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)
			AssetStorage.AUsrc.Play();
			if ((Object)(object)CurrentSelectedElement == (Object)(object)go)
			{
				((Graphic)((Component)CurrentSelectedElement.transform.Find("fill")).GetComponent<Image>()).color = Color.white;
				CurrentSelectedElement = null;
				Achievements.SetActive(false);
				return;
			}
			if ((Object)(object)CurrentSelectedElement != (Object)null)
			{
				((Graphic)((Component)CurrentSelectedElement.transform.Find("fill")).GetComponent<Image>()).color = Color.white;
			}
			CurrentSelectedElement = go;
			((Graphic)((Component)go.transform.Find("fill")).GetComponent<Image>()).color = Color.green;
			InitAchievements(board);
		}

		private static void InitAchievements(Leaderboard_DataTypes.Client_Leaderboard board)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			Achievements.SetActive(true);
			foreach (Transform item in AchievementContent)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			((Component)Achievements.transform.Find("Achievements")).GetComponent<Text>().text = board.PlayerName + "$mpasn_LeaderboardAchievements".Localize();
			foreach (int achievement in board.Achievements)
			{
				Leaderboard_DataTypes.Client_Achievement client_Achievement = Leaderboard_DataTypes.SyncedClientAchievements.Value.Find((Leaderboard_DataTypes.Client_Achievement x) => x.ID == achievement);
				if (client_Achievement != null)
				{
					GameObject val2 = Object.Instantiate<GameObject>(AchievementsElement, AchievementContent);
					((Graphic)((Component)val2.transform.Find("color")).GetComponent<Image>()).color = Color32.op_Implicit(client_Achievement.Color);
					((Component)val2.transform.Find("Name")).GetComponent<Text>().text = client_Achievement.Name;
					((Graphic)((Component)val2.transform.Find("Name")).GetComponent<Text>()).color = Color32.op_Implicit(client_Achievement.Color);
					((Component)val2.transform.Find("Description")).GetComponent<Text>().text = "(" + client_Achievement.Description + ")";
				}
			}
		}

		public static void Show()
		{
			if (Global_Configs.SyncedGlobalOptions.Value._useLeaderboard)
			{
				Default();
				Main.SetActive(true);
				CreateElements();
			}
		}

		public static void Hide()
		{
			Main.SetActive(false);
			Achievements.SetActive(false);
		}

		private static void ShowTF()
		{
			UI.SetActive(true);
			Default();
		}

		private static void HideTF()
		{
			UI.SetActive(false);
			Default();
		}
	}
}
namespace Marketplace.Modules.Factions
{
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class Factions_Client
	{
		[HarmonyPatch(typeof(Player), "Load")]
		[ClientOnlyPatch]
		private static class Player_Load_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Player __instance)
			{
				if (((Character)__instance).m_nview.IsValid())
				{
					FindMyFaction(notify: false);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		[ClientOnlyPatch]
		private static class Player_Awake_Patch
		{
			private static void Postfix(Player __instance)
			{
				Player __instance2 = __instance;
				if (((Character)__instance2).m_nview.IsValid())
				{
					((Character)__instance2).m_nview.Register<int>("MPASN_FactionChanged", (Action<long, int>)delegate(long _, int index)
					{
						FactionChanged(_, index, __instance2);
					});
					FactionChanged(0L, ((Character)__instance2).m_nview.GetZDO().GetInt("MPASN_Faction", -1), __instance2);
				}
			}

			private static void FactionChanged(long _, int index, Player p)
			{
				if (index < 0 || index >= Factions.Count)
				{
					EnemyHud_ShowHud_Patch.ModifyGui((Character)(object)p, null);
				}
				else
				{
					EnemyHud_ShowHud_Patch.ModifyGui((Character)(object)p, Factions[index]);
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		[ClientOnlyPatch]
		private static class ItemDescriptionPatch
		{
			private static void Postfix(ItemData item, bool crafting, ref string __result)
			{
				if (!Object.op_Implicit((Object)(object)item.m_dropPrefab))
				{
					return;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item.m_dropPrefab).name);
				if (FastSpecificUseItemsLookup.TryGetValue(stableHashCode, out HashSet<int> value) && !value.Contains(MyFactionIndex))
				{
					string text = string.Join(", ", value.Select((int i) => Factions[i].Name));
					__result = __result + "\n<color=orange>" + Localization.instance.Localize("$mpasn_faction_usableonly") + text + "</color>";
				}
				if (crafting && FastSpecificCraftItemsLookup.TryGetValue(stableHashCode, out HashSet<int> value2) && !value2.Contains(MyFactionIndex))
				{
					string text2 = string.Join(", ", value2.Select((int i) => Factions[i].Name));
					__result = __result + "\n<color=orange>" + Localization.instance.Localize("$mpasn_faction_craftableonly") + text2 + "</color>";
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UseItem")]
		[ClientOnlyPatch]
		private static class Humanoid_UseItem_Patch
		{
			private static bool Prefix(Humanoid __instance, ItemData item)
			{
				if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
				{
					return true;
				}
				if (!Object.op_Implicit((Object)(object)item.m_dropPrefab))
				{
					return true;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item.m_dropPrefab).name);
				if (!FastSpecificUseItemsLookup.TryGetValue(stableHashCode, out HashSet<int> value) || value.Contains(MyFactionIndex))
				{
					return true;
				}
				string text = string.Join(", ", value.Select((int i) => Factions[i].Name));
				MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_faction_usableonly") + text + "</color>", 0, (Sprite)null, false);
				return false;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "CanPickup")]
		[ClientOnlyPatch]
		private static class ItemDrop_CanPickup_Patch
		{
			private static bool Prefix(ItemDrop __instance, ref bool __result)
			{
				if (!Object.op_Implicit((Object)(object)__instance.m_itemData.m_dropPrefab))
				{
					return true;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)__instance.m_itemData.m_dropPrefab).name);
				if (!FastBlockPickupItemsLookup.TryGetValue(stableHashCode, out HashSet<int> value) || !value.Contains(MyFactionIndex))
				{
					return true;
				}
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Interact")]
		[ClientOnlyPatch]
		private static class ItemDrop_Interact_Patch
		{
			private static void Prefix(ItemDrop __instance, ref bool __result)
			{
				if (!Object.op_Implicit((Object)(object)__instance.m_itemData.m_dropPrefab))
				{
					return;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)__instance.m_itemData.m_dropPrefab).name);
				if (FastBlockPickupItemsLookup.TryGetValue(stableHashCode, out HashSet<int> value) && value.Contains(MyFactionIndex))
				{
					string text = string.Join(", ", value.Select((int i) => Factions[i].Name));
					MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_faction_availablefor") + text + "</color>", 0, (Sprite)null, false);
					__result = false;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[ClientOnlyPatch]
		private static class InventoryGui_DoCrafting_Patch
		{
			private static bool Prefix(InventoryGui __instance)
			{
				if ((Object)(object)__instance.m_craftRecipe != (Object)null)
				{
					ItemDrop item = __instance.m_craftRecipe.m_item;
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item).name);
					if (FastSpecificCraftItemsLookup.TryGetValue(stableHashCode, out HashSet<int> value) && !value.Contains(MyFactionIndex))
					{
						string text = string.Join(", ", value.Select((int i) => Factions[i].Name));
						MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_faction_craftableonly") + text + "</color>", 0, (Sprite)null, false);
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "GetAvailableRecipes")]
		[ClientOnlyPatch]
		private static class Player_GetAvailableRecipes_Patch
		{
			private static void Postfix(ref List<Recipe> available)
			{
				available.RemoveAll(delegate(Recipe recipe)
				{
					ItemDrop item = recipe.m_item;
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item).name);
					HashSet<int> value;
					return FastSpecificCraftItemsLookup.TryGetValue(stableHashCode, out value) && !value.Contains(MyFactionIndex);
				});
			}
		}

		[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
		[ClientOnlyPatch]
		private static class PieceTable_UpdateAvailable_Patch
		{
			private static void Postfix(PieceTable __instance)
			{
				foreach (List<Piece> availablePiece in __instance.m_availablePieces)
				{
					availablePiece?.RemoveAll(delegate(Piece piece)
					{
						int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)piece).name);
						HashSet<int> value;
						return FastSpecificBuildingsLookup.TryGetValue(stableHashCode, out value) && !value.Contains(MyFactionIndex);
					});
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "SetupPieceInfo")]
		[ClientOnlyPatch]
		private static class Hud_SetupPieceInfo_Patch
		{
			private static void Postfix(Hud __instance, Piece piece)
			{
				if (!Object.op_Implicit((Object)(object)piece))
				{
					return;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)piece).name);
				if (FastSpecificBuildingsLookup.TryGetValue(stableHashCode, out HashSet<int> value) && !value.Contains(MyFactionIndex))
				{
					string text = string.Join(", ", value.Select((int i) => Factions[i].Name));
					TMP_Text pieceDescription = __instance.m_pieceDescription;
					pieceDescription.text = pieceDescription.text + "\n<color=orange>" + Localization.instance.Localize("$mpasn_faction_buildableonly") + text + "</color>";
				}
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece")]
		[ClientOnlyPatch]
		private static class Player_TryPlacePiece_Patch
		{
			private static bool Prefix(Piece piece)
			{
				if (!Object.op_Implicit((Object)(object)piece))
				{
					return true;
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)piece).name);
				if (FastSpecificBuildingsLookup.TryGetValue(stableHashCode, out HashSet<int> value) && !value.Contains(MyFactionIndex))
				{
					string text = string.Join(", ", value.Select((int i) => Factions[i].Name));
					MessageHud.instance.ShowMessage((MessageType)2, "<color=red>" + Localization.instance.Localize("$mpasn_faction_buildableonly") + text + "</color>", 0, (Sprite)null, false);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(BaseAI), "IsEnemy", new Type[]
		{
			typeof(Character),
			typeof(Character)
		})]
		[ClientOnlyPatch]
		private static class BaseAI_IsEnemy_Patch
		{
			private static bool Prefix(Character a, Character b, ref bool __result)
			{
				if (!Object.op_Implicit((Object)(object)a) || !Object.op_Implicit((Object)(object)b) || (Object)(object)a == (Object)(object)b)
				{
					return false;
				}
				if (!b.IsPlayer())
				{
					return true;
				}
				if (Object.op_Implicit((Object)(object)a.m_baseAI) && a.m_baseAI.m_alerted)
				{
					return true;
				}
				if (!b.m_nview.IsValid())
				{
					return true;
				}
				int @int = b.m_nview.m_zdo.GetInt("MPASN_Faction", -1);
				if (@int < 0 || @int >= Factions.Count)
				{
					return true;
				}
				Factions_DataTypes.Faction faction = Factions[@int];
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)a).name.Replace("(Clone)", ""));
				if (faction.FriendlyMonsters.Contains(stableHashCode))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(EnemyHud), "Awake")]
		[ClientOnlyPatch]
		private static class EnemyHud_Awake_Patch
		{
			private static Vector2 _origPos;

			private static RectTransform _rect;

			public static void ResetPos()
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: 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_002d: Unknown result type (might be due to invalid IL or missing references)
				_rect.anchoredPosition = _origPos + new Vector2(-3f, 12f) + Global_Configs.SyncedGlobalOptions.Value._factionNameplateOffset;
			}

			private static void Postfix(EnemyHud __instance)
			{
				//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_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: 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: Expected O, but got Unknown
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				GameObject baseHudPlayer = __instance.m_baseHudPlayer;
				Transform val = baseHudPlayer.transform.Find("Name");
				_origPos = ((Component)val).GetComponent<RectTransform>().anchoredPosition;
				_rect = new GameObject("MPASN_FactionBackground", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Component)_rect).transform.SetParent(baseHudPlayer.transform);
				ResetPos();
				_rect.sizeDelta = new Vector2(400f, 20f);
				HorizontalLayoutGroup val2 = ((Component)_rect).gameObject.AddComponent<HorizontalLayoutGroup>();
				((LayoutGroup)val2).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
				((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = false;
				((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)val2).spacing = 2f;
				Transform val3 = Object.Instantiate<Transform>(val);
				((Component)val3).transform.SetParent(((Component)_rect).transform);
				((Object)val3).name = "MPASN_Faction";
				((Component)val3).transform.localPosition = Vector3.zero;
				TextMeshProUGUI component = ((Component)val3).GetComponent<TextMeshProUGUI>();
				((TMP_Text)component).fontSizeMin = 16f;
				((TMP_Text)component).fontSizeMax = 18f;
				((Component)val3).GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 20f);
				((Component)val3).gameObject.AddComponent<ContentSizeFitter>().horizontalFit = (FitMode)2;
				GameObject val4 = new GameObject("MPASN_FactionImage", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				((Object)val4).name = "MPASN_FactionImage";
				val4.transform.SetParent(((Component)_rect).transform);
				val4.transform.SetAsFirstSibling();
				val4.GetComponent<RectTransform>().sizeDelta = new Vector2(20f, 20f);
				((Component)val3).gameObject.SetActive(false);
				val4.gameObject.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(EnemyHud), "ShowHud")]
		[ClientOnlyPatch]
		private static class EnemyHud_ShowHud_Patch
		{
			private static void Postfix(Character c)
			{
				if (c.IsPlayer())
				{
					int @int = c.m_nview.m_zdo.GetInt("MPASN_Faction", -1);
					if (@int != -1)
					{
						Factions_DataTypes.Faction faction = Factions[@int];
						ModifyGui(c, faction);
					}
				}
			}

			public static void ModifyGui(Character c, Factions_DataTypes.Faction? faction)
			{
				HudData value;
				HudData val = (EnemyHud.instance.m_huds.TryGetValue(c, out value) ? value : null);
				if (val == null)
				{
					return;
				}
				GameObject gui = val.m_gui;
				if (faction == null)
				{
					((TMP_Text)((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_Faction")).GetComponent<TextMeshProUGUI>()).text = "";
					((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_Faction")).gameObject.SetActive(false);
					((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_FactionImage")).gameObject.SetActive(false);
					((Component)gui.transform.Find("MPASN_FactionBackground")).gameObject.SetActive(false);
					return;
				}
				if (faction.Icon != null)
				{
					Sprite val2 = Utils.TryFindIcon(faction.Icon);
					if (val2 != null)
					{
						((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_FactionImage")).GetComponent<Image>().sprite = val2;
						((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_FactionImage")).gameObject.SetActive(true);
						goto IL_0103;
					}
				}
				((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_FactionImage")).gameObject.SetActive(false);
				goto IL_0103;
				IL_0103:
				((TMP_Text)((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_Faction")).GetComponent<TextMeshProUGUI>()).text = faction.Name;
				((Component)gui.transform.Find("MPASN_FactionBackground/MPASN_Faction")).gameObject.SetActive(true);
				((Component)gui.transform.Find("MPASN_FactionBackground")).gameObject.SetActive(true);
				List<ContentSizeFitter> list = gui.GetComponentsInChildren<ContentSizeFitter>().ToList();
				list.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = false;
				});
				list.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = true;
				});
				list.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = false;
				});
				list.ForEach(delegate(ContentSizeFitter filter)
				{
					((Behaviour)filter).enabled = true;
				});
			}
		}

		[HarmonyPatch(typeof(EnemyHud), "LateUpdate")]
		[ClientOnlyPatch]
		private static class EnemyHud_LateUpdate_Patch
		{
			private static void Postfix(EnemyHud __instance)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Utils.IsDebug_Strict)
				{
					__instance.ShowHud((Character)(object)Player.m_localPlayer, false);
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifySkillLevel")]
		[ClientOnlyPatch]
		private static class SEMan_ModifySkillLevel_Patch
		{
			private static void Postfix(SEMan __instance, SkillType skill, ref float level)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				if (MyFactionIndex != -1 && !((Object)(object)__instance.m_character != (Object)(object)Player.m_localPlayer) && Factions[MyFactionIndex].BonusSkills.TryGetValue(skill, out var value))
				{
					level += value;
				}
			}
		}

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

				public static ConsoleEvent <>9__0_0;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_0056: 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_0068: Unknown result type (might be due to invalid IL or missing references)
					//IL_006e: Expected O, but got Unknown
					//IL_0081: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)Chat.instance == (Object)null) && args.FullLine.Length > 2)
					{
						if (MyFactionIndex == -1)
						{
							args.Context.AddString(Localization.instance.Localize("$mpasn_faction_notinfaction"));
							return;
						}
						string text = args.FullLine.Substring(2);
						Player localPlayer = Player.m_localPlayer;
						Vector3 val = ((localPlayer != null) ? ((Component)localPlayer).transform.position : Vector3.zero);
						ZPackage val2 = new ZPackage();
						val2.Write(MyFactionIndex);
						val2.Write(text);
						val2.Write(val);
						ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "MPASN_FactionMessage", new object[2]
						{
							UserInfo.GetLocalUser(),
							val2
						});
					}
				}
			}

			private static void Postfix()
			{
				//IL_0032: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						//IL_0062: Unknown result type (might be due to invalid IL or missing references)
						//IL_0056: 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_0068: Unknown result type (might be due to invalid IL or missing references)
						//IL_006e: Expected O, but got Unknown
						//IL_0081: Unknown result type (might be due to invalid IL or missing references)
						if (!((Object)(object)Chat.instance == (Object)null) && args.FullLine.Length > 2)
						{
							if (MyFactionIndex == -1)
							{
								args.Context.AddString(Localization.instance.Localize("$mpasn_faction_notinfaction"));
							}
							else
							{
								string text = args.FullLine.Substring(2);
								Player localPlayer = Player.m_localPlayer;
								Vector3 val2 = ((localPlayer != null) ? ((Component)localPlayer).transform.position : Vector3.zero);
								ZPackage val3 = new ZPackage();
								val3.Write(MyFactionIndex);
								val3.Write(text);
								val3.Write(val2);
								ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "MPASN_FactionMessage", new object[2]
								{
									UserInfo.GetLocalUser(),
									val3
								});
							}
						}
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("f", "write message in faction chat", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		private static class Character_RPC_Damage_Patch
		{
			private static void Prefix(Character __instance, HitData hit)
			{
				if (MyFactionIndex == -1 || !__instance.IsPlayer())
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if (Object.op_Implicit((Object)(object)attacker) && attacker.IsPlayer())
				{
					int @int = attacker.m_nview.m_zdo.GetInt("MPASN_Faction", -1);
					if (MyFactionIndex == @int && !Factions[MyFactionIndex].CanDamageSameFaction)
					{
						((DamageTypes)(ref hit.m_damage)).Modify(0f);
					}
				}
			}
		}

		private static List<Factions_DataTypes.Faction> Factions = new List<Factions_DataTypes.Faction>();

		private static readonly Dictionary<int, HashSet<int>> FastSpecificUseItemsLookup = new Dictionary<int, HashSet<int>>();

		private static readonly Dictionary<int, HashSet<int>> FastBlockPickupItemsLookup = new Dictionary<int, HashSet<int>>();

		private static readonly Dictionary<int, HashSet<int>> FastFriendlyMonstersLookup = new Dictionary<int, HashSet<int>>();

		private static readonly Dictionary<int, HashSet<int>> FastSpecificBuildingsLookup = new Dictionary<int, HashSet<int>>();

		private static readonly Dictionary<int, HashSet<int>> FastSpecificCraftItemsLookup = new Dictionary<int, HashSet<int>>();

		private static int MyFactionIndex = -1;

		[UsedImplicitly]
		private static void OnInit()
		{
			Factions_DataTypes.SyncedFactions.ValueChanged += SyncedFactionsUpdate;
			Global_Configs.SyncedGlobalOptions.ValueChanged += SyncedGlobalOptionsUpdate;
		}

		private static void SyncedGlobalOptionsUpdate()
		{
			if (!Object.op_Implicit((Object)(object)EnemyHud.instance))
			{
				return;
			}
			EnemyHud_Awake_Patch.ResetPos();
			foreach (Character item in EnemyHud.instance.m_huds.Keys.Where((Character h) => h.IsPlayer()).ToList())
			{
				EnemyHud.instance.RemoveCharacterHud(item);
			}
		}

		public static bool IsMyFaction(string faction)
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || string.IsNullOrWhiteSpace(faction))
			{
				return false;
			}
			return GeneralExtensions.GetValueSafe<string, string>(Player.m_localPlayer.m_customData, "MPASN_Faction") == faction;
		}

		private static void SyncedFactionsUpdate()
		{
			FastSpecificUseItemsLookup.Clear();
			FastBlockPickupItemsLookup.Clear();
			FastFriendlyMonstersLookup.Clear();
			FastSpecificBuildingsLookup.Clear();
			FastSpecificCraftItemsLookup.Clear();
			Factions = Factions_DataTypes.SyncedFactions.Value.Values.ToList();
			for (int i = 0; i < Factions.Count; i++)
			{
				Factions_DataTypes.Faction faction = Factions[i];
				foreach (int specificUseItem in faction.SpecificUseItems)
				{
					if (!FastSpecificUseItemsLookup.ContainsKey(specificUseItem))
					{
						FastSpecificUseItemsLookup[specificUseItem] = new HashSet<int>();
					}
					FastSpecificUseItemsLookup[specificUseItem].Add(i);
				}
				foreach (int blockPickupItem in faction.BlockPickupItems)
				{
					if (!FastBlockPickupItemsLookup.ContainsKey(blockPickupItem))
					{
						FastBlockPickupItemsLookup[blockPickupItem] = new HashSet<int>();
					}
					FastBlockPickupItemsLookup[blockPickupItem].Add(i);
				}
				foreach (int friendlyMonster in faction.FriendlyMonsters)
				{
					if (!FastFriendlyMonstersLookup.ContainsKey(friendlyMonster))
					{
						FastFriendlyMonstersLookup[friendlyMonster] = new HashSet<int>();
					}
					FastFriendlyMonstersLookup[friendlyMonster].Add(i);
				}
				foreach (int specificBuilding in faction.SpecificBuildings)
				{
					if (!FastSpecificBuildingsLookup.ContainsKey(specificBuilding))
					{
						FastSpecificBuildingsLookup[specificBuilding] = new HashSet<int>();
					}
					FastSpecificBuildingsLookup[specificBuilding].Add(i);
				}
				foreach (int specificCraftItem in faction.SpecificCraftItems)
				{
					if (!FastSpecificCraftItemsLookup.ContainsKey(specificCraftItem))
					{
						FastSpecificCraftItemsLookup[specificCraftItem] = new HashSet<int>();
					}
					FastSpecificCraftItemsLookup[specificCraftItem].Add(i);
				}
			}
			FindMyFaction(notify: true);
		}

		public static void FindMyFaction(bool notify)
		{
			MyFactionIndex = -1;
			if (!Object.op_Implicit((Object)(object)Game.instance) || Game.instance.m_shuttingDown || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			((Character)Player.m_localPlayer).m_seman.RemoveStatusEffect(StringExtensionMethods.GetStableHashCode("MPASN_FactionBuff"), true);
			string valueSafe = GeneralExtensions.GetValueSafe<string, string>(Player.m_localPlayer.m_customData, "MPASN_Faction");
			if (valueSafe != null)
			{
				Factions_DataTypes.Faction value;
				Factions_DataTypes.Faction faction = ((Factions_DataTypes.SyncedFactions.Value.TryGetValue(valueSafe, out value) && value != null) ? value : null);
				if (faction != null)
				{
					MyFactionIndex = Factions.IndexOf(faction);
					if (!string.IsNullOrWhiteSpace(faction.Buff))
					{
						Buffer_DataTypes.BufferBuffData bufferBuffData = Buffer_DataTypes.SyncedBufferBuffs.Value.FirstOrDefault((Buffer_DataTypes.BufferBuffData b) => b.UniqueName.ToLower() == faction.Buff);
						if (bufferBuffData != null && (bufferBuffData.IsValid ?? false))
						{
							Buffer_DataTypes.BufferMain bufferMain = Object.Instantiate<Buffer_DataTypes.BufferMain>(bufferBuffData.GetMain());
							((Object)bufferMain).name = "MPASN_FactionBuff";
							bufferMain.Data = bufferBuffData.GetMain().Data;
							((StatusEffect)bufferMain).m_ttl = 0f;
							((Character)Player.m_localPlayer).m_seman.AddStatusEffect((StatusEffect)(object)bufferMain, true, 0, 0f);
						}
					}
				}
			}
			((Character)Player.m_localPlayer).m_nview.m_zdo.Set("MPASN_Faction", MyFactionIndex);
			if (notify)
			{
				((Character)Player.m_localPlayer).m_nview.InvokeRPC(ZNetView.Everybody, "MPASN_FactionChanged", new object[1] { MyFactionIndex });
			}
			TerritorySystem_DataTypes.SyncedTerritoriesData.Value.Territories.ForEach(delegate(TerritorySystem_DataTypes.Territory t)
			{
				t.ClearOwnerCache();
			});
		}

		[MarketplaceRPC("MPASN_FactionMessage", Market_Autoload.Type.Client)]
		[UsedImplicitly]
		private static void OnChatMessageReceived(long senderId, UserInfo name, ZPackage pkg)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			int num = pkg.ReadInt();
			if (num != -1 && num == MyFactionIndex)
			{
				string text = pkg.ReadString();
				Vector3 val = pkg.ReadVector3();
				((Terminal)Chat.instance).AddString("<color=orange>" + name.Name + "</color>: <color=green>" + text + "</color>");
				Chat.instance.m_hideTimer = 0f;
				if (!(val == Vector3.zero) && (!Object.op_Implicit((Object)(object)Minimap.instance) || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || (int)Minimap.instance.m_mode != 0 || !(Vector3.Distance(((Component)Player.m_localPlayer).transform.position, val) > Minimap.instance.m_nomapPingDistance)))
				{
					Chat.instance.AddInworldText((GameObject)null, senderId, val, (Type)1, name, "<color=green>" + text + "</color>");
				}
			}
		}
	}
	public static class Factions_DataTypes
	{
		public class Faction : ISerializableParameter
		{
			public string Name;

			public string? Icon;

			public HashSet<int> SpecificUseItems = new HashSet<int>();

			public HashSet<int> BlockPickupItems = new HashSet<int>();

			public HashSet<int> SpecificBuildings = new HashSet<int>();

			public HashSet<int> SpecificCraftItems = new HashSet<int>();

			public HashSet<int> FriendlyMonsters = new HashSet<int>();

			public Dictionary<SkillType, int> BonusSkills = new Dictionary<SkillType, int>();

			public string? Buff;

			public bool CanDamageSameFaction;

			public void Serialize(ref ZPackage pkg)
			{
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Expected I4, but got Unknown
				pkg.Write(Name);
				bool flag = !string.IsNullOrEmpty(Icon);
				pkg.Write(flag);
				if (flag)
				{
					pkg.Write(Icon);
				}
				pkg.Write(SpecificUseItems.Count);
				foreach (int specificUseItem in SpecificUseItems)
				{
					pkg.Write(specificUseItem);
				}
				pkg.Write(FriendlyMonsters.Count);
				foreach (int friendlyMonster in FriendlyMonsters)
				{
					pkg.Write(friendlyMonster);
				}
				pkg.Write(SpecificBuildings.Count);
				foreach (int specificBuilding in SpecificBuildings)
				{
					pkg.Write(specificBuilding);
				}
				pkg.Write(BlockPickupItems.Count);
				foreach (int blockPickupItem in BlockPickupItems)
				{
					pkg.Write(blockPickupItem);
				}
				pkg.Write(SpecificCraftItems.Count);
				foreach (int specificCraftItem in SpecificCraftItems)
				{
					pkg.Write(specificCraftItem);
				}
				pkg.Write(BonusSkills.Count);
				foreach (KeyValuePair<SkillType, int> bonusSkill in BonusSkills)
				{
					pkg.Write((int)bonusSkill.Key);
					pkg.Write(bonusSkill.Value);
				}
				pkg.Write(Buff ?? "");
				pkg.Write(CanDamageSameFaction);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				Name = pkg.ReadString();
				if (pkg.ReadBool())
				{
					Icon = pkg.ReadString();
				}
				int num = pkg.ReadInt();
				SpecificUseItems = new HashSet<int>(num);
				for (int i = 0; i < num; i++)
				{
					SpecificUseItems.Add(pkg.ReadInt());
				}
				int num2 = pkg.ReadInt();
				FriendlyMonsters = new HashSet<int>(num2);
				for (int j = 0; j < num2; j++)
				{
					FriendlyMonsters.Add(pkg.ReadInt());
				}
				int num3 = pkg.ReadInt();
				SpecificBuildings = new HashSet<int>(num3);
				for (int k = 0; k < num3; k++)
				{
					SpecificBuildings.Add(pkg.ReadInt());
				}
				int num4 = pkg.ReadInt();
				BlockPickupItems = new HashSet<int>(num4);
				for (int l = 0; l < num4; l++)
				{
					BlockPickupItems.Add(pkg.ReadInt());
				}
				int num5 = pkg.ReadInt();
				SpecificCraftItems = new HashSet<int>(num5);
				for (int m = 0; m < num5; m++)
				{
					SpecificCraftItems.Add(pkg.ReadInt());
				}
				int num6 = pkg.ReadInt();
				BonusSkills = new Dictionary<SkillType, int>(num6);
				for (int n = 0; n < num6; n++)
				{
					SkillType key = (SkillType)pkg.ReadInt();
					int value = pkg.ReadInt();
					BonusSkills[key] = value;
				}
				Buff = pkg.ReadString();
				CanDamageSameFaction = pkg.ReadBool();
			}
		}

		internal static readonly CustomSyncedValue<Dictionary<string, Faction>> SyncedFactions = new CustomSyncedValue<Dictionary<string, Faction>>(Marketplace.configSync, "SyncedFactions", new Dictionary<string, Faction>());
	}
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Last, "OnInit", new string[] { "Factions.yml" }, new string[] { "OnChange" })]
	public static class Factions_Server
	{
		[Serializable]
		public class FactionYaml
		{
			public string Name;

			public string? Icon;

			public HashSet<string> SpecificUseItems = new HashSet<string>();

			public HashSet<string> BlockPickupItems = new HashSet<string>();

			public HashSet<string> SpecificBuildings = new HashSet<string>();

			public HashSet<string> SpecificCraftItems = new HashSet<string>();

			public HashSet<string> FriendlyMonsters = new HashSet<string>();

			public Dictionary<SkillType, int> BonusSkills = new Dictionary<SkillType, int>();

			public string? Buff;

			public bool CanDamageSameFaction = true;
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			Load();
		}

		private static HashSet<int> Convert(HashSet<string> input)
		{
			HashSet<int> hashSet = new HashSet<int>();
			foreach (int item in from s in input
				where !string.IsNullOrWhiteSpace(s)
				select StringExtensionMethods.GetStableHashCode(s))
			{
				hashSet.Add(item);
			}
			return hashSet;
		}

		private static void Load()
		{
			try
			{
				string text = File.ReadAllText(Market_Paths.FactionsFile);
				if (!string.IsNullOrWhiteSpace(text))
				{
					Dictionary<string, FactionYaml> dictionary = new DeserializerBuilder().Build().Deserialize<Dictionary<string, FactionYaml>>(text);
					Dictionary<string, Factions_DataTypes.Faction> dictionary2 = new Dictionary<string, Factions_DataTypes.Faction>();
					foreach (KeyValuePair<string, FactionYaml> item in dictionary)
					{
						FactionYaml value = item.Value;
						if (string.IsNullOrWhiteSpace(value.Name))
						{
							Utils.print("Faction with key " + item.Key + " has no name, skipping.");
							continue;
						}
						dictionary2[item.Key.ToLower()] = new Factions_DataTypes.Faction
						{
							Name = value.Name,
							Icon = value.Icon,
							SpecificUseItems = Convert(value.SpecificUseItems),
							BlockPickupItems = Convert(value.BlockPickupItems),
							SpecificBuildings = Convert(value.SpecificBuildings),
							SpecificCraftItems = Convert(value.SpecificCraftItems),
							FriendlyMonsters = Convert(value.FriendlyMonsters),
							BonusSkills = value.BonusSkills,
							Buff = value.Buff?.ToLower(),
							CanDamageSameFaction = value.CanDamageSameFaction
						};
					}
					Factions_DataTypes.SyncedFactions.Value = dictionary2;
				}
				else
				{
					Factions_DataTypes.SyncedFactions.Value = new Dictionary<string, Factions_DataTypes.Faction>();
				}
			}
			catch (Exception ex)
			{
				Factions_DataTypes.SyncedFactions.Value = new Dictionary<string, Factions_DataTypes.Faction>();
				Utils.print("Error while loading factions data: " + ex.Message);
			}
		}

		[UsedImplicitly]
		private static void OnChange()
		{
			Utils.print("Reloading factions data...");
			Load();
		}
	}
}
namespace Marketplace.Modules.CMS
{
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class CentralizedMailSystem_Client
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			CentralizedMailSystem_UI.Init();
			CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value = new List<global::Marketplace.DB.DB.CMS_User>();
			CentralizedMailSystem_DataTypes.SyncedServerTime.Value = DateTime.Now.Ticks;
		}

		public static void SendMail_Admin(string sender, string subject, string message, string userID, Marketplace_DataTypes.ClientMarketSendData[] attachments = null, int minutesDuration = 10080)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			if (userID == "0")
			{
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(sender ?? "");
			val.Write(userID ?? "");
			val.Write(subject ?? "");
			val.Write(message ?? "");
			val.Write(minutesDuration);
			val.Write((attachments != null) ? attachments.Length : 0);
			if (attachments != null)
			{
				foreach (Marketplace_DataTypes.ClientMarketSendData clientMarketSendData in attachments)
				{
					val.Write(clientMarketSendData.ItemPrefab);
					val.Write(clientMarketSendData.Count);
					val.Write(clientMarketSendData.Quality);
				}
			}
			val.Compress();
			ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS SendMail_Admin", new object[1] { val });
		}

		public static void SendMail_User(string subject, string message, string userID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			if (!(userID == "0"))
			{
				ZPackage val = new ZPackage();
				val.Write(userID);
				val.Write(subject ?? "");
				val.Write(message ?? "");
				val.Compress();
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS SendMail_User", new object[1] { val });
			}
		}
	}
	public static class CentralizedMailSystem_DataTypes
	{
		public static CustomSyncedValue<List<global::Marketplace.DB.DB.CMS_User>> SyncedCMSUsers = new CustomSyncedValue<List<global::Marketplace.DB.DB.CMS_User>>(Marketplace.configSync, "SyncedCMSUSers", new List<global::Marketplace.DB.DB.CMS_User>());

		public static readonly CustomSyncedValue<long> SyncedServerTime = new CustomSyncedValue<long>(Marketplace.configSync, "SyncedServerTime", 0L);

		public const int MaxPerPage = 7;
	}
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class CentralizedMailSystem_Server
	{
		private static float _timer;

		[UsedImplicitly]
		private static void OnInit()
		{
			CentralizedMailSystem_DataTypes.SyncedServerTime.Value = DateTime.Now.Ticks;
			CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value = global::Marketplace.DB.DB._context.GetAllCMSUsers();
			Marketplace.Global_FixedUpdator = (Action<float>)Delegate.Combine(Marketplace.Global_FixedUpdator, new Action<float>(FixedUpdate));
		}

		private static void FixedUpdate(float dt)
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
			{
				_timer -= dt;
				if (!(_timer > 0f))
				{
					_timer = 60f;
					CentralizedMailSystem_DataTypes.SyncedServerTime.Value = DateTime.Now.Ticks;
					PeriodicCheck();
				}
			}
		}

		public static void PeriodicCheck()
		{
			foreach (global::Marketplace.DB.DB.CMS_User item in CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value)
			{
				item.IsOnline = false;
			}
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return;
			}
			bool[] a2 = CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.Select((global::Marketplace.DB.DB.CMS_User u) => u.IsOnline).ToArray();
			foreach (ZNetPeer peer in ZNet.instance.m_peers)
			{
				string userID = peer.m_socket.GetHostName();
				if (peer.IsReady() && !(userID == "0"))
				{
					global::Marketplace.DB.DB.CMS_User cMS_User = CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.Find((global::Marketplace.DB.DB.CMS_User u) => u.UserID == userID);
					if (cMS_User == null)
					{
						cMS_User = new global::Marketplace.DB.DB.CMS_User
						{
							Name = peer.m_playerName,
							UserID = userID,
							LastOnline = DateTime.Now.Ticks,
							IsOnline = true
						};
						global::Marketplace.DB.DB._context.AddCMSUser(cMS_User);
						CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.Add(cMS_User);
					}
					cMS_User.IsOnline = true;
					cMS_User.LastOnline = DateTime.Now.Ticks;
					int unreadMailCountForUser = global::Marketplace.DB.DB._context.GetUnreadMailCountForUser(userID);
					if (unreadMailCountForUser > 0)
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "CMS_ReceiveUnreadMailAmount", new object[1] { unreadMailCountForUser });
					}
				}
			}
			bool[] b2 = CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.Select((global::Marketplace.DB.DB.CMS_User u) => u.IsOnline).ToArray();
			if (AnythingChanged(a2, b2))
			{
				CentralizedMailSystem_DataTypes.SyncedCMSUsers.Update();
			}
			static bool AnythingChanged(bool[] a, bool[] b)
			{
				if (a.Length != b.Length)
				{
					return true;
				}
				for (int i = 0; i < a.Length; i++)
				{
					if (a[i] != b[i])
					{
						return true;
					}
				}
				return false;
			}
		}

		[MarketplaceRPC("KGmarket CMS WithdrawMailAttachments", Market_Autoload.Type.Server)]
		public static void WithdrawMail_Attachments(long sender, int mailUID)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null)
			{
				return;
			}
			string hostName = peer.m_socket.GetHostName();
			global::Marketplace.DB.DB.CMS_Entry mailByUID = global::Marketplace.DB.DB._context.GetMailByUID(hostName, mailUID);
			if (mailByUID == null || mailByUID.Attachments.Count == 0 || mailByUID.AttachmentsTaken)
			{
				return;
			}
			global::Marketplace.DB.DB._context.Mail_SetAttachmentTaken(hostName, mailUID);
			foreach (Marketplace_DataTypes.ClientMarketSendData attachment in mailByUID.Attachments)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "KGmarket BuyItemAnswer", new object[1] { JSON.ToJSON(attachment) });
			}
		}

		[MarketplaceRPC("KGmarket CMS DeleteMail", Market_Autoload.Type.Server)]
		public static void DeleteMail(long sender, int mailUID)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				global::Marketplace.DB.DB._context.RemoveMailFromUser(hostName, mailUID);
			}
		}

		[MarketplaceRPC("KGmarket CMS ReadMail", Market_Autoload.Type.Server)]
		public static void ReadMail(long sender, int mailUID)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				global::Marketplace.DB.DB._context.SetMailRead(hostName, mailUID);
			}
		}

		[MarketplaceRPC("KGmarket CMS RequestMailAmount", Market_Autoload.Type.Server)]
		public static void RequestMailAmount(long sender)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_socket.GetHostName();
				int totalMailCountForUser = global::Marketplace.DB.DB._context.GetTotalMailCountForUser(hostName);
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "CMS_ReceiveMailAmount", new object[1] { totalMailCountForUser });
			}
		}

		[MarketplaceRPC("KGmarket CMS SendMail_Admin", Market_Autoload.Type.Server)]
		public static void SendMail_Admin(long sender, ZPackage pkg)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null)
			{
				return;
			}
			pkg.Decompress();
			string senderName = pkg.ReadString();
			string text = pkg.ReadString();
			if (text == "0")
			{
				return;
			}
			string topic = pkg.ReadString();
			string message = pkg.ReadString();
			int minutesDuration = pkg.ReadInt();
			int num = pkg.ReadInt();
			Marketplace_DataTypes.ClientMarketSendData[] attachments = ((num > 0) ? new Marketplace_DataTypes.ClientMarketSendData[num] : null);
			for (int i = 0; i < num; i++)
			{
				string itemPrefab = pkg.ReadString();
				int count = pkg.ReadInt();
				int quality = pkg.ReadInt();
				attachments[i] = new Marketplace_DataTypes.ClientMarketSendData
				{
					ItemPrefab = itemPrefab,
					Count = count,
					Quality = quality
				};
			}
			if (text.ToLower() != "all")
			{
				AddMail(senderName, topic, message, text, attachments, null, minutesDuration);
				return;
			}
			CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.ForEach(delegate(global::Marketplace.DB.DB.CMS_User u)
			{
				AddMail(senderName, topic, message, u.UserID, attachments, null, minutesDuration);
			});
		}

		[MarketplaceRPC("KGmarket CMS SendMail_User", Market_Autoload.Type.Server)]
		public static void SendMail_User(long sender, ZPackage pkg)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				pkg.Decompress();
				string playerName = peer.m_playerName;
				string text = pkg.ReadString();
				if (!(text == "0"))
				{
					string topic = pkg.ReadString();
					string message = pkg.ReadString();
					AddMail(playerName, topic, message, text);
				}
			}
		}

		[MarketplaceRPC("KGmarket CMS RequestMailData", Market_Autoload.Type.Server)]
		public static void RequestMail(long sender, int page, int revision)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null)
			{
				return;
			}
			string hostName = peer.m_socket.GetHostName();
			List<global::Marketplace.DB.DB.CMS_Entry> userMails = global::Marketplace.DB.DB._context.GetUserMails(hostName);
			int index = Math.Max(0, userMails.Count - (page + 1) * 7);
			int count = ((page == userMails.Count / 7) ? (userMails.Count % 7) : 7);
			userMails = userMails.GetRange(index, count);
			userMails.Reverse();
			ZPackage pkg = new ZPackage();
			pkg.Write(revision);
			pkg.Write(userMails.Count);
			foreach (global::Marketplace.DB.DB.CMS_Entry item in userMails)
			{
				item.Serialize(ref pkg);
			}
			pkg.Compress();
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "CMS_ReceiveMailData", new object[1] { pkg });
		}

		public static void AddMail(string sender, string topic, string message, string userID, Marketplace_DataTypes.ClientMarketSendData[] attachments = null, Marketplace_DataTypes.ClientMarketSendData[] links = null, int minutesDuration = 10080)
		{
			if (userID == "0")
			{
				return;
			}
			global::Marketplace.DB.DB.CMS_Entry mail = new global::Marketplace.DB.DB.CMS_Entry
			{
				Created = DateTime.Now.Ticks,
				Sender = sender,
				Owner = userID,
				Topic = topic,
				Message = message,
				Attachments = ((attachments != null && attachments.Length > 0) ? attachments.ToList() : null),
				Links = ((links != null && links.Length > 0) ? links.ToList() : null),
				ExpireAfterMinutes = minutesDuration
			};
			global::Marketplace.DB.DB._context.AddMail(mail);
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				ZNetPeer peerByHostName = ZNet.instance.GetPeerByHostName(userID);
				if (peerByHostName != null)
				{
					int unreadMailCountForUser = global::Marketplace.DB.DB._context.GetUnreadMailCountForUser(userID);
					ZRoutedRpc.instance.InvokeRoutedRPC(peerByHostName.m_uid, "CMS_ReceiveUnreadMailAmount", new object[1] { unreadMailCountForUser });
				}
			}
		}
	}
	public static class CentralizedMailSystem_UI
	{
		public class DragUI_CMS : MonoBehaviour, IDragHandler, IEventSystemHandler, IBeginDragHandler
		{
			private static List<DragUI_CMS> Instances = new List<DragUI_CMS>();

			private readonly Transform[] Markers = (Transform[])(object)new Transform[4];

			private RectTransform dragRect;

			private Vector2 startPos;

			public static void Ensure()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				foreach (DragUI_CMS instance in Instances)
				{
					if (CheckMarkersOutsideScreen(new Vector2((float)Screen.width, (float)Screen.height), instance.Markers))
					{
						instance.dragRect.anchoredPosition = instance.startPos;
					}
				}
			}

			public void Init(RectTransform target)
			{
				//IL_0019: 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)
				Instances.Add(this);
				dragRect = target;
				startPos = dragRect.anchoredPosition;
				Markers[0] = ((Component)this).transform.Find("LeftTop");
				Markers[1] = ((Component)this).transform.Find("RightTop");
				Markers[2] = ((Component)this).transform.Find("LeftBottom");
				Markers[3] = ((Component)this).transform.Find("RightBottom");
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: 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)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				Vector2 anchoredPosition = dragRect.anchoredPosition;
				Vector2 val = anchoredPosition + eventData.delta * Vector2.op_Implicit(((Transform)dragRect).lossyScale) * Vector2.op_Implicit(((Transform)dragRect).localScale);
				Vector2 anchoredPosition2 = anchoredPosition;
				anchoredPosition = val;
				dragRect.anchoredPosition = anchoredPosition;
				if (CheckMarkersOutsideScreen(new Vector2((float)Screen.width, (float)Screen.height), Markers))
				{
					dragRect.anchoredPosition = anchoredPosition2;
				}
			}

			private static bool CheckMarkersOutsideScreen(Vector2 screen, Transform[] Markers)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: 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_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				foreach (Transform val in Markers)
				{
					Vector3 position = val.position;
					float x = position.x;
					float y = position.y;
					if (x < 0f || x > screen.x || y < 0f || y > screen.y)
					{
						return true;
					}
				}
				return false;
			}

			public void OnBeginDrag(PointerEventData eventData)
			{
				((Transform)dragRect).SetAsLastSibling();
			}
		}

		private class CMS_UI_Entry
		{
			private Transform Data;

			private Image Icon;

			private Text Sender;

			private Text Topic;

			private Text TimeLeft;

			private Transform IsRead;

			private Button OpenMail;

			private GameObject Selected;

			private GameObject Taken;

			public CMS_UI_Entry(Transform t)
			{
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Expected O, but got Unknown
				Data = t.Find("Data");
				Icon = ((Component)Data.Find("Icon/Img")).GetComponent<Image>();
				Sender = ((Component)Data.Find("Sender")).GetComponent<Text>();
				Topic = ((Component)Data.Find("Topic")).GetComponent<Text>();
				TimeLeft = ((Component)Data.Find("TimeLeft")).GetComponent<Text>();
				IsRead = Data.Find("NewMail");
				int index = t.GetSiblingIndex();
				OpenMail = ((Component)t.Find("bg")).GetComponent<Button>();
				((UnityEvent)OpenMail.onClick).AddListener((UnityAction)delegate
				{
					ClickedOnEntry(index);
				});
				Selected = ((Component)t.Find("Selected")).gameObject;
				Taken = ((Component)t.Find("Data/Icon/Taken")).gameObject;
				((Component)Data).gameObject.SetActive(false);
			}

			public void SetSelected(bool selected)
			{
				Selected.SetActive(selected);
			}

			public void SetRead()
			{
				((Component)IsRead).gameObject.SetActive(false);
			}

			public void SetTaken()
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)Icon).color = new Color(0f, 1f, 1f);
				Taken.SetActive(true);
			}

			private static void ClickedOnEntry(int index)
			{
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Expected O, but got Unknown
				//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
				AssetStorage.AUsrc.Play();
				if (index >= Mails.Count || Mails[index] == null)
				{
					return;
				}
				global::Marketplace.DB.DB.CMS_Entry cMS_Entry = Mails[index];
				if (!cMS_Entry.WasRead)
				{
					cMS_Entry.WasRead = true;
					UnreadMail--;
					CheckUnreadMail();
					ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS ReadMail", new object[1] { cMS_Entry._id });
					Entries[index].SetRead();
				}
				if (CurrentSelectedMail == index)
				{
					HideOpenMail();
					return;
				}
				CurrentSelectedMail = index;
				foreach (CMS_UI_Entry entry in Entries)
				{
					entry.SetSelected(selected: false);
				}
				Entries[index].SetSelected(selected: true);
				OpenMail_From.text = Localization.instance.Localize("$mpasn_CMS_From: ") + Localization.instance.Localize(cMS_Entry.Sender);
				OpenMail_Subject.text = Localization.instance.Localize("$mpasn_CMS_Subject: ") + Localization.instance.Localize(cMS_Entry.Topic);
				OpenMail_Message.text = Localization.instance.Localize(cMS_Entry.Message);
				CMSLinkController.SetItemLinks(cMS_Entry.Links, cMS_Entry.Attachments);
				foreach (Transform item in AttachmentsContent)
				{
					Transform val = item;
					((Component)val).gameObject.SetActive(false);
				}
				List<Marketplace_DataTypes.ClientMarketSendData> attachments = cMS_Entry.Attachments;
				if (attachments != null && attachments.Count > 0)
				{
					for (int i = 0; i < attachments.Count; i++)
					{
						if (i >= AttachmentsContent.childCount)
						{
							break;
						}
						Transform t = AttachmentsContent.GetChild(i);
						GameObject prefab = ZNetScene.instance.GetPrefab(cMS_Entry.Attachments[i].ItemPrefab);
						if (Object.op_Implicit((Object)(object)prefab))
						{
							((Component)t).gameObject.SetActive(true);
							Marketplace_DataTypes.ClientMarketSendData clientMarketSendData = cMS_Entry.Attachments[i];
							Utils.GetItemForTooltip(clientMarketSendData.ItemPrefab, clientMarketSendData.Count, clientMarketSendData.Quality, clientMarketSendData.Variant, clientMarketSendData.CrafterID, clientMarketSendData.CrafterName, clientMarketSendData.CUSTOMdata, clientMarketSendData.DurabilityPercent, delegate(ItemData item)
							{
								InventoryGui.instance.m_playerGrid.CreateItemTooltip(item, ((Component)t).GetComponent<UITooltip>());
								((Component)t).GetComponent<Image>().sprite = item.GetIcon();
							});
							((Graphic)((Component)t).GetComponent<Image>()).color = (Color)(cMS_Entry.AttachmentsTaken ? new Color(0f, 1f, 1f) : Color.white);
							((Component)t.Find("AttachmentsText")).GetComponent<Text>().text = ((cMS_Entry.Attachments[i].Count > 1) ? $"{cMS_Entry.Attachments[i].Count}" : "");
						}
					}
				}
				GameObject gameObject = ((Component)TakeAttachments).gameObject;
				int active;
				if (!cMS_Entry.AttachmentsTaken)
				{
					List<Marketplace_DataTypes.ClientMarketSendData> attachments2 = cMS_Entry.Attachments;
					active = ((attachments2 != null && attachments2.Count > 0) ? 1 : 0);
				}
				else
				{
					active = 0;
				}
				gameObject.SetActive((byte)active != 0);
				OpenedMail.gameObject.SetActive(true);
			}

			public void SetData(global::Marketplace.DB.DB.CMS_Entry mail)
			{
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: 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)
				if (mail == null)
				{
					((Component)Data).gameObject.SetActive(false);
					Icon.sprite = null;
					Sender.text = "";
					Topic.text = "";
					TimeLeft.text = "";
					((Component)IsRead).gameObject.SetActive(false);
					((Selectable)OpenMail).interactable = false;
					Selected.SetActive(false);
					Taken.SetActive(false);
					return;
				}
				((Component)Data).gameObject.SetActive(true);
				((Selectable)OpenMail).interactable = true;
				List<Marketplace_DataTypes.ClientMarketSendData> attachments = mail.Attachments;
				if (attachments != null && attachments.Count > 0)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(mail.Attachments[0].ItemPrefab);
					Sprite sprite = (Sprite)(Object.op_Implicit((Object)(object)prefab) ? ((object)prefab.GetComponent<ItemDrop>().m_itemData.GetIcon()) : ((object)AssetStorage.PlaceholderGamblerIcon));
					Icon.sprite = sprite;
					((Graphic)Icon).color = (Color)(mail.AttachmentsTaken ? new Color(0f, 1f, 1f) : Color.white);
				}
				else
				{
					Icon.sprite = AssetStorage.PlaceholderMailIcon;
					((Graphic)Icon).color = Color.white;
				}
				Sender.text = Localization.instance.Localize(mail.Sender);
				Topic.text = Localization.instance.Localize(mail.Topic);
				long num = CentralizedMailSystem_DataTypes.SyncedServerTime.Value - mail.Created;
				long value = mail.ExpireAfterMinutes.MinutesToTicks() - num;
				TimeSpan timeSpan = TimeSpan.FromTicks(value);
				TimeLeft.text = ((mail.ExpireAfterMinutes > 0) ? Localization.instance.Localize(FormatTime(timeSpan)) : "");
				((Component)IsRead).gameObject.SetActive(!mail.WasRead);
				GameObject taken = Taken;
				int active;
				if (mail.AttachmentsTaken)
				{
					attachments = mail.Attachments;
					active = ((attachments != null && attachments.Count > 0) ? 1 : 0);
				}
				else
				{
					active = 0;
				}
				taken.SetActive((byte)active != 0);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		[ClientOnlyPatch]
		private static class InventoryGui_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGui __instance)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				foreach (Transform item in AttachmentsContent)
				{
					Transform val = item;
					((Component)val).GetComponent<UITooltip>().m_tooltipPrefab = __instance.m_playerGrid.m_elementPrefab.GetComponent<UITooltip>().m_tooltipPrefab;
				}
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			private static bool done;

			[UsedImplicitly]
			private static void Postfix(FejdStartup __instance)
			{
				if (!done)
				{
					done = true;
					Transform obj = ((Component)__instance).transform.Find("StartGame/Panel/JoinPanel/serverCount");
					TextMeshProUGUI val = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
					if (val != null)
					{
						OpenMail_Message.font = ((TMP_Text)val).font;
						OpenMail_Message.outlineWidth = 0.075f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class TextInput_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(TextInput __instance, ref bool __result)
			{
				__result |= IsMainVisible;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "IsVisible")]
		[ClientOnlyPatch]
		private static class StoreGui_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(TextInput __instance, ref bool __result)
			{
				__result |= IsMainVisible;
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class Menu_OnLogoutYes_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				HaveUnreadMail.SetActive(false);
				Hide();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__PrevPageClick;

			public static UnityAction <1>__NextPageClick;

			public static UnityAction <2>__RemoveMail;

			public static UnityAction <3>__SendMail;

			public static Action<float> <4>__Update;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__45_0;

			public static UnityAction <>9__45_1;

			public static UnityAction <>9__45_2;

			public static UnityAction <>9__45_3;

			public static UnityAction <>9__45_4;

			public static UnityAction <>9__45_5;

			public static Func<global::Marketplace.DB.DB.CMS_User, string> <>9__58_0;

			public static Func<global::Marketplace.DB.DB.CMS_User, string> <>9__59_0;

			internal void <Init>b__45_0()
			{
				AssetStorage.AUsrc.Play();
				Hide();
			}

			internal void <Init>b__45_1()
			{
				AssetStorage.AUsrc.Play();
				if (!IsLoading)
				{
					ShowMyMail();
				}
			}

			internal void <Init>b__45_2()
			{
				AssetStorage.AUsrc.Play();
				ShowSendMail();
			}

			internal void <Init>b__45_3()
			{
				TakeAllAttachments();
			}

			internal void <Init>b__45_4()
			{
				AssetStorage.AUsrc.Play();
				HideOpenMail();
			}

			internal void <Init>b__45_5()
			{
				AssetStorage.AUsrc.Play();
				HideOpenMail();
			}

			internal string <ShowSendMail_User>b__58_0(global::Marketplace.DB.DB.CMS_User u)
			{
				return u.Name;
			}

			internal string <ShowSendMail_Admin>b__59_0(global::Marketplace.DB.DB.CMS_User u)
			{
				return u.Name;
			}
		}

		private static bool CanTakeAttachments = false;

		private static int MaxPages = 1;

		private static int UnreadMail = 0;

		private static int TotalMail = 0;

		private static int CurrentPage = 1;

		public static List<global::Marketplace.DB.DB.CMS_Entry> Mails = new List<global::Marketplace.DB.DB.CMS_Entry>();

		private static GameObject UI;

		private static GameObject MAIN;

		private static GameObject MyMailsPage;

		private static GameObject SendMailPage;

		private static GameObject OpenedMail;

		private static GameObject LOADING;

		private static Text PageNumber;

		private static List<CMS_UI_Entry> Entries = new List<CMS_UI_Entry>();

		private static Text OpenMail_From;

		private static Text OpenMail_Subject;

		private static TMP_Text OpenMail_Message;

		private static CMS_Links.CMS_LinkController CMSLinkController;

		private static Transform AttachmentsContent;

		private static Button TakeAttachments;

		private static GameObject SendMail_Admin;

		private static GameObject SendMail_User;

		private static Dropdown SendMail_Target_Dropdown;

		private static InputField SendMail_Subject_User;

		private static InputField SendMail_Message_User;

		private static InputField SendMail_SenderName_Admin;

		private static InputField SendMail_Subject_Admin;

		private static InputField SendMail_Message_Admin;

		private static InputField SendMail_Attachments_Admin;

		private static InputField SendMail_ExpireTime_Admin;

		private static Button SendMail_Send;

		private static GameObject HaveUnreadMail;

		private static Text UnreadMailAmount_Text;

		private static int CurrentSelectedMail = -1;

		private static List<global::Marketplace.DB.DB.CMS_User> _tempUsers = new List<global::Marketplace.DB.DB.CMS_User>();

		private static int _mailDataRevision = -1;

		public static bool IsMainVisible
		{
			get
			{
				if (Object.op_Implicit((Object)(object)MAIN))
				{
					return MAIN.activeSelf;
				}
				return false;
			}
		}

		private static bool IsOpenVisible => OpenedMail.activeSelf;

		private static bool IsLoading
		{
			get
			{
				if (IsMainVisible)
				{
					return LOADING.activeInHierarchy;
				}
				return false;
			}
		}

		public static string FormatTime(TimeSpan timeSpan)
		{
			if (timeSpan.Days > 0)
			{
				return $"{timeSpan.Days} $mpasn_CMS_Days\n{timeSpan.Hours} $mpasn_CMS_Hours";
			}
			if (timeSpan.Hours > 0)
			{
				return $"{timeSpan.Hours} $mpasn_CMS_Hours";
			}
			if (timeSpan.Minutes > 0)
			{
				return $"{timeSpan.Minutes} $mpasn_CMS_Minutes";
			}
			if (timeSpan.Seconds > 0)
			{
				return $"{timeSpan.Seconds} $mpasn_CMS_Seconds";
			}
			return "$mpasn_CMS_Expired";
		}

		public static void Init()
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			//IL_0224: 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)
			//IL_022f: Expected O, but got Unknown
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Expected O, but got Unknown
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Expected O, but got Unknown
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Expected O, but got Unknown
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Expected O, but got Unknown
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Expected O, but got Unknown
			UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketplaceCMS_UI"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			MAIN = ((Component)UI.transform.Find("Canvas/Mails")).gameObject;
			MAIN.SetActive(false);
			MyMailsPage = ((Component)UI.transform.Find("Canvas/Mails/MyMail")).gameObject;
			MyMailsPage.SetActive(false);
			OpenedMail = ((Component)UI.transform.Find("Canvas/OpenMail")).gameObject;
			OpenedMail.gameObject.SetActive(false);
			SendMailPage = ((Component)UI.transform.Find("Canvas/Mails/SendMail")).gameObject;
			SendMailPage.SetActive(false);
			LOADING = ((Component)MAIN.transform.Find("LOADING")).gameObject;
			LOADING.SetActive(false);
			PageNumber = ((Component)MyMailsPage.transform.Find("PageText")).GetComponent<Text>();
			((Component)PageNumber).gameObject.SetActive(false);
			ButtonClickedEvent onClick = ((Component)MAIN.transform.Find("Close")).GetComponent<Button>().onClick;
			object obj = <>c.<>9__45_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					AssetStorage.AUsrc.Play();
					Hide();
				};
				<>c.<>9__45_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			foreach (Transform item in UI.transform.Find("Canvas/Mails/MyMail/Content"))
			{
				Transform t = item;
				Entries.Add(new CMS_UI_Entry(t));
			}
			ButtonClickedEvent onClick2 = ((Component)MyMailsPage.transform.Find("Button_Left")).GetComponent<Button>().onClick;
			object obj2 = <>O.<0>__PrevPageClick;
			if (obj2 == null)
			{
				UnityAction val2 = PrevPageClick;
				<>O.<0>__PrevPageClick = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			ButtonClickedEvent onClick3 = ((Component)MyMailsPage.transform.Find("Button_Right")).GetComponent<Button>().onClick;
			object obj3 = <>O.<1>__NextPageClick;
			if (obj3 == null)
			{
				UnityAction val3 = NextPageClick;
				<>O.<1>__NextPageClick = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = ((Component)MAIN.transform.Find("Button_MyMail")).GetComponent<Button>().onClick;
			object obj4 = <>c.<>9__45_1;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					AssetStorage.AUsrc.Play();
					if (!IsLoading)
					{
						ShowMyMail();
					}
				};
				<>c.<>9__45_1 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			ButtonClickedEvent onClick5 = ((Component)MAIN.transform.Find("Button_SendMail")).GetComponent<Button>().onClick;
			object obj5 = <>c.<>9__45_2;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					AssetStorage.AUsrc.Play();
					ShowSendMail();
				};
				<>c.<>9__45_2 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			OpenMail_From = ((Component)OpenedMail.transform.Find("From")).GetComponent<Text>();
			OpenMail_Subject = ((Component)OpenedMail.transform.Find("Subject")).GetComponent<Text>();
			OpenMail_Message = ((Component)OpenedMail.transform.Find("Message")).GetComponent<TMP_Text>();
			CMSLinkController = ((Component)OpenMail_Message).gameObject.AddComponent<CMS_Links.CMS_LinkController>();
			AttachmentsContent = OpenedMail.transform.Find("AttachmentsContent");
			TakeAttachments = ((Component)OpenedMail.transform.Find("TakeAll")).GetComponent<Button>();
			ButtonClickedEvent onClick6 = TakeAttachments.onClick;
			object obj6 = <>c.<>9__45_3;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					TakeAllAttachments();
				};
				<>c.<>9__45_3 = val6;
				obj6 = (object)val6;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			ButtonClickedEvent onClick7 = ((Component)OpenedMail.transform.Find("Bottom_Close")).GetComponent<Button>().onClick;
			object obj7 = <>c.<>9__45_4;
			if (obj7 == null)
			{
				UnityAction val7 = delegate
				{
					AssetStorage.AUsrc.Play();
					HideOpenMail();
				};
				<>c.<>9__45_4 = val7;
				obj7 = (object)val7;
			}
			((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			ButtonClickedEvent onClick8 = ((Component)OpenedMail.transform.Find("Close")).GetComponent<Button>().onClick;
			object obj8 = <>c.<>9__45_5;
			if (obj8 == null)
			{
				UnityAction val8 = delegate
				{
					AssetStorage.AUsrc.Play();
					HideOpenMail();
				};
				<>c.<>9__45_5 = val8;
				obj8 = (object)val8;
			}
			((UnityEvent)onClick8).AddListener((UnityAction)obj8);
			ButtonClickedEvent onClick9 = ((Component)OpenedMail.transform.Find("Bottom_Remove")).GetComponent<Button>().onClick;
			object obj9 = <>O.<2>__RemoveMail;
			if (obj9 == null)
			{
				UnityAction val9 = RemoveMail;
				<>O.<2>__RemoveMail = val9;
				obj9 = (object)val9;
			}
			((UnityEvent)onClick9).AddListener((UnityAction)obj9);
			SendMail_Target_Dropdown = ((Component)SendMailPage.transform.Find("TargetDropdown")).GetComponent<Dropdown>();
			SendMail_Admin = ((Component)SendMailPage.transform.Find("ADMIN")).gameObject;
			SendMail_User = ((Component)SendMailPage.transform.Find("NON_ADMIN")).gameObject;
			SendMail_Subject_User = ((Component)SendMail_User.transform.Find("SubjectInput")).GetComponent<InputField>();
			SendMail_Message_User = ((Component)SendMail_User.transform.Find("MessageInput")).GetComponent<InputField>();
			SendMail_SenderName_Admin = ((Component)SendMail_Admin.transform.Find("SenderInput")).GetComponent<InputField>();
			SendMail_Subject_Admin = ((Component)SendMail_Admin.transform.Find("SubjectInput")).GetComponent<InputField>();
			SendMail_Message_Admin = ((Component)SendMail_Admin.transform.Find("MessageInput")).GetComponent<InputField>();
			SendMail_ExpireTime_Admin = ((Component)SendMail_Admin.transform.Find("TimeInput")).GetComponent<InputField>();
			SendMail_Attachments_Admin = ((Component)SendMail_Admin.transform.Find("AttachmentsInput")).GetComponent<InputField>();
			SendMail_Send = ((Component)SendMailPage.transform.Find("Confirm")).GetComponent<Button>();
			ButtonClickedEvent onClick10 = SendMail_Send.onClick;
			object obj10 = <>O.<3>__SendMail;
			if (obj10 == null)
			{
				UnityAction val10 = SendMail;
				<>O.<3>__SendMail = val10;
				obj10 = (object)val10;
			}
			((UnityEvent)onClick10).AddListener((UnityAction)obj10);
			DragUI_CMS dragUI_CMS = ((Component)MAIN.transform.Find("BG")).gameObject.AddComponent<DragUI_CMS>();
			Transform transform = MAIN.transform;
			dragUI_CMS.Init((RectTransform)(object)((transform is RectTransform) ? transform : null));
			DragUI_CMS dragUI_CMS2 = ((Component)OpenedMail.transform.Find("BG")).gameObject.AddComponent<DragUI_CMS>();
			Transform transform2 = OpenedMail.transform;
			dragUI_CMS2.Init((RectTransform)(object)((transform2 is RectTransform) ? transform2 : null));
			HaveUnreadMail = ((Component)UI.transform.Find("Canvas/UnreadMailNofitication")).gameObject;
			HaveUnreadMail.SetActive(false);
			UnreadMailAmount_Text = ((Component)HaveUnreadMail.transform.Find("Text")).GetComponent<Text>();
			Marketplace.Global_Updator = (Action<float>)Delegate.Combine(Marketplace.Global_Updator, new Action<float>(Update));
			Localization.instance.Localize(UI.transform);
		}

		private static void RemoveMail()
		{
			if (IsMainVisible && IsOpenVisible && CurrentSelectedMail != -1)
			{
				AssetStorage.AUsrc.Play();
				global::Marketplace.DB.DB.CMS_Entry cMS_Entry = Mails[CurrentSelectedMail];
				HideOpenMail();
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS DeleteMail", new object[1] { cMS_Entry._id });
				SetPage(CurrentPage);
			}
		}

		private static void HideOpenMail()
		{
			foreach (CMS_UI_Entry entry in Entries)
			{
				entry.SetSelected(selected: false);
			}
			OpenedMail.gameObject.SetActive(false);
			CurrentSelectedMail = -1;
		}

		public static void Hide()
		{
			HideOpenMail();
			MAIN.SetActive(false);
			LOADING.SetActive(false);
		}

		private static void CheckUnreadMail()
		{
			if (UnreadMail > 0)
			{
				HaveUnreadMail.SetActive(true);
				UnreadMailAmount_Text.text = UnreadMail.ToString();
			}
			else
			{
				HaveUnreadMail.SetActive(false);
			}
		}

		private static void PrevPageClick()
		{
			AssetStorage.AUsrc.Play();
			if (!IsLoading && CurrentPage - 1 >= 1)
			{
				SetPage(CurrentPage - 1);
			}
		}

		private static void NextPageClick()
		{
			AssetStorage.AUsrc.Play();
			if (!IsLoading && CurrentPage + 1 <= MaxPages)
			{
				SetPage(CurrentPage + 1);
			}
		}

		private static void TakeAllAttachments()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (!IsMainVisible || !IsOpenVisible || CurrentSelectedMail == -1 || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			AssetStorage.AUsrc.Play();
			if (!CanTakeAttachments)
			{
				return;
			}
			global::Marketplace.DB.DB.CMS_Entry cMS_Entry = Mails[CurrentSelectedMail];
			if (cMS_Entry.AttachmentsTaken)
			{
				return;
			}
			((Component)TakeAttachments).gameObject.SetActive(false);
			cMS_Entry.AttachmentsTaken = true;
			Entries[CurrentSelectedMail].SetTaken();
			ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS WithdrawMailAttachments", new object[1] { cMS_Entry._id });
			foreach (Transform item in AttachmentsContent)
			{
				Transform val = item;
				((Graphic)((Component)val).GetComponent<Image>()).color = new Color(0f, 1f, 1f);
			}
		}

		private static void SendMail()
		{
			if (!IsMainVisible || !SendMailPage.activeSelf)
			{
				return;
			}
			AssetStorage.AUsrc.Play();
			int num = SendMail_Target_Dropdown.value - 1;
			if (num < 0 || _tempUsers.Count <= num)
			{
				return;
			}
			global::Marketplace.DB.DB.CMS_User cMS_User = _tempUsers[num];
			if (cMS_User == null)
			{
				return;
			}
			if (!Utils.IsDebug_Strict)
			{
				if (string.IsNullOrEmpty(SendMail_Subject_User.text))
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Subject cannot be empty", 0, (Sprite)null, false);
					return;
				}
				string text = SendMail_Subject_User.text;
				string text2 = SendMail_Message_User.text;
				ShowSendMail();
				CentralizedMailSystem_Client.SendMail_User(text, text2, cMS_User.UserID);
				return;
			}
			if (string.IsNullOrEmpty(SendMail_ExpireTime_Admin.text))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Expire time cannot be empty", 0, (Sprite)null, false);
				return;
			}
			if (!int.TryParse(SendMail_ExpireTime_Admin.text, out var result))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Expire time must be a number", 0, (Sprite)null, false);
				return;
			}
			if (result < 1)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Expire time must be greater than 0", 0, (Sprite)null, false);
				return;
			}
			result *= 60;
			string sender = (string.IsNullOrWhiteSpace(SendMail_SenderName_Admin.text) ? "Admin" : SendMail_SenderName_Admin.text);
			string subject = SendMail_Subject_Admin.text ?? "";
			string message = SendMail_Message_Admin.text ?? "";
			Marketplace_DataTypes.ClientMarketSendData[] array = null;
			if (!string.IsNullOrWhiteSpace(SendMail_Attachments_Admin.text))
			{
				string[] array2 = SendMail_Attachments_Admin.text.Replace(" ", "").Split(new char[1] { ',' });
				if (array2.Length % 3 != 0)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Invalid attachment format", 0, (Sprite)null, false);
					return;
				}
				array = new Marketplace_DataTypes.ClientMarketSendData[array2.Length / 3];
				for (int i = 0; i < array2.Length; i += 3)
				{
					string text3 = array2[i];
					if (!Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(text3)))
					{
						MessageHud.instance.ShowMessage((MessageType)2, "Invalid item prefab: " + text3, 0, (Sprite)null, false);
						return;
					}
					if (!int.TryParse(array2[i + 1], out var result2) || result2 < 1)
					{
						MessageHud.instance.ShowMessage((MessageType)2, "Invalid item count: " + array2[i + 1], 0, (Sprite)null, false);
						return;
					}
					if (!int.TryParse(array2[i + 2], out var result3) || result3 < 1)
					{
						MessageHud.instance.ShowMessage((MessageType)2, "Invalid item quality: " + array2[i + 2], 0, (Sprite)null, false);
						return;
					}
					array[i / 3] = new Marketplace_DataTypes.ClientMarketSendData
					{
						ItemPrefab = text3,
						Count = result2,
						Quality = result3
					};
				}
			}
			ShowSendMail();
			CentralizedMailSystem_Client.SendMail_Admin(sender, subject, message, cMS_User.UserID, array, result);
		}

		private static void Update(float obj)
		{
			if (Input.GetKeyDown((KeyCode)27) && IsOpenVisible)
			{
				HideOpenMail();
			}
			else if (Input.GetKeyDown((KeyCode)27) && IsMainVisible)
			{
				Hide();
			}
		}

		public static void Show(bool canTakeAttachments)
		{
			DragUI_CMS.Ensure();
			CanTakeAttachments = canTakeAttachments;
			MAIN.SetActive(true);
			ShowMyMail();
		}

		private static void ShowMyMail()
		{
			MyMailsPage.SetActive(true);
			SendMailPage.SetActive(false);
			SetPage(1);
		}

		private static void ShowSendMail_User()
		{
			SendMail_Admin.SetActive(false);
			SendMail_User.SetActive(true);
			SendMail_Target_Dropdown.ClearOptions();
			List<string> list = new List<string>(1) { "Select a player" };
			_tempUsers = CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.OrderBy((global::Marketplace.DB.DB.CMS_User u) => u.Name).ToList();
			foreach (global::Marketplace.DB.DB.CMS_User tempUser in _tempUsers)
			{
				string name = tempUser.Name;
				string text = (tempUser.IsOnline ? "(<color=lime>Online</color>)" : "(<color=red>Offline</color>)");
				list.Add(name + " " + text);
			}
			SendMail_Target_Dropdown.AddOptions(list);
			SendMail_Target_Dropdown.value = 0;
			SendMail_Subject_User.text = "";
			SendMail_Message_User.text = "";
		}

		private static void ShowSendMail_Admin()
		{
			SendMail_Admin.SetActive(true);
			SendMail_User.SetActive(false);
			SendMail_Target_Dropdown.ClearOptions();
			List<string> list = new List<string>(1) { "Select a player" };
			_tempUsers = CentralizedMailSystem_DataTypes.SyncedCMSUsers.Value.OrderBy((global::Marketplace.DB.DB.CMS_User u) => u.Name).ToList();
			_tempUsers.Insert(0, new global::Marketplace.DB.DB.CMS_User
			{
				Name = "All <color=lime>[Send to all users in database]</color>",
				UserID = "All"
			});
			foreach (global::Marketplace.DB.DB.CMS_User tempUser in _tempUsers)
			{
				string name = tempUser.Name;
				string text = (tempUser.IsOnline ? "(<color=lime>Online</color>)" : "(<color=red>Offline</color>)");
				if (tempUser.UserID == "All")
				{
					text = "";
				}
				list.Add(name + " " + text);
			}
			SendMail_Target_Dropdown.AddOptions(list);
			SendMail_Target_Dropdown.value = 0;
			SendMail_SenderName_Admin.text = "";
			SendMail_Subject_Admin.text = "";
			SendMail_Message_Admin.text = "";
			SendMail_ExpireTime_Admin.text = "168";
			SendMail_Attachments_Admin.text = "";
		}

		private static void ShowSendMail()
		{
			HideOpenMail();
			MyMailsPage.SetActive(false);
			SendMailPage.SetActive(true);
			LOADING.SetActive(false);
			if (Utils.IsDebug_Strict)
			{
				ShowSendMail_Admin();
			}
			else
			{
				ShowSendMail_User();
			}
		}

		private static void SetPage(int page)
		{
			HideOpenMail();
			CurrentPage = page;
			Mails.Clear();
			foreach (CMS_UI_Entry entry in Entries)
			{
				entry.SetData(null);
			}
			LOADING.SetActive(true);
			((Component)PageNumber).gameObject.SetActive(false);
			_mailDataRevision++;
			ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS RequestMailAmount", Array.Empty<object>());
		}

		[MarketplaceRPC("CMS_ReceiveMailAmount", Market_Autoload.Type.Client)]
		public static void GetMailAmount(long sender, int totalMails)
		{
			if (IsMainVisible && IsLoading)
			{
				TotalMail = totalMails;
				MaxPages = (TotalMail - 1) / 7 + 1;
				if (CurrentPage > MaxPages)
				{
					CurrentPage = MaxPages;
				}
				PageNumber.text = $"{CurrentPage}/{MaxPages}";
				((Component)PageNumber).gameObject.SetActive(true);
				ZRoutedRpc.instance.InvokeRoutedRPC("KGmarket CMS RequestMailData", new object[2]
				{
					CurrentPage - 1,
					_mailDataRevision
				});
			}
		}

		[MarketplaceRPC("CMS_ReceiveMailData", Market_Autoload.Type.Client)]
		public static void GetMailData(long sender, ZPackage pkg)
		{
			if (!IsMainVisible || !IsLoading)
			{
				return;
			}
			pkg.Decompress();
			int num = pkg.ReadInt();
			if (num == _mailDataRevision)
			{
				int num2 = pkg.ReadInt();
				Mails.Clear();
				for (int i = 0; i < num2; i++)
				{
					global::Marketplace.DB.DB.CMS_Entry cMS_Entry = new global::Marketplace.DB.DB.CMS_Entry();
					cMS_Entry.Deserialize(ref pkg);
					Mails.Add(cMS_Entry);
				}
				for (int j = 0; j < Mails.Count && j < Entries.Count; j++)
				{
					Entries[j].SetData(Mails[j]);
				}
				LOADING.SetActive(false);
			}
		}

		[MarketplaceRPC("CMS_ReceiveUnreadMailAmount", Market_Autoload.Type.Client)]
		public static void GetUnreadMailAmount(long sender, int unreadMails)
		{
			UnreadMail = unreadMails;
			CheckUnreadMail();
		}
	}
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class CMS_Links
	{
		public class CMS_LinkController : MonoBehaviour
		{
			private static readonly Dictionary<int, Marketplace_DataTypes.ClientMarketSendData> _itemLinks = new Dictionary<int, Marketplace_DataTypes.ClientMarketSendData>();

			private int _lastLinkIndex = -1;

			private int linkStartTextIndex = -1;

			private int linkTextLength;

			private static GameObject CurrentTooltip;

			private TMP_Text _text;

			private List<Color> _oldColors;

			private Color defaultHoverColor = new Color(0.34f, 1f, 0.31f);

			private bool changeColor
			{
				get
				{
					if (linkStartTextIndex != -1)
					{
						return linkTextLength != 0;
					}
					return false;
				}
			}

			private void Awake()
			{
				_text = ((Component)this).GetComponent<TMP_Text>();
				((Graphic)_text).raycastTarget = true;
			}

			private void OnDisable()
			{
				if (changeColor)
				{
					ChangeVertexColors(isHover: false);
				}
				linkStartTextIndex = -1;
				linkTextLength = 0;
				_lastLinkIndex = -1;
				if (Object.op_Implicit((Object)(object)CurrentTooltip))
				{
					Object.Destroy((Object)(object)CurrentTooltip);
				}
			}

			public void SetItemLinks(List<Marketplace_DataTypes.ClientMarketSendData> itemLinks, List<Marketplace_DataTypes.ClientMarketSendData> itemAttachments)
			{
				OnDisable();
				_itemLinks.Clear();
				if (itemLinks != null && itemLinks.Count > 0)
				{
					int num = 0;
					foreach (Marketplace_DataTypes.ClientMarketSendData itemLink in itemLinks)
					{
						_itemLinks[num++] = itemLink;
					}
				}
				if (itemAttachments == null || itemAttachments.Count <= 0)
				{
					return;
				}
				int num2 = 100;
				foreach (Marketplace_DataTypes.ClientMarketSendData itemAttachment in itemAttachments)
				{
					_itemLinks[num2++] = itemAttachment;
				}
			}

			private void ProcessTMP(int tryFindLink)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: 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)
				TMP_LinkInfo val = _text.textInfo.linkInfo[tryFindLink];
				string linkID = ((TMP_LinkInfo)(ref val)).GetLinkID();
				if (!linkID.Contains("kg.CMSLINK:"))
				{
					return;
				}
				try
				{
					int num = int.Parse(linkID.Split(new char[1] { ':' })[1]);
					if (!_itemLinks.ContainsKey(num))
					{
						OnDisable();
						return;
					}
					Marketplace_DataTypes.ClientMarketSendData clientMarketSendData = _itemLinks[num];
					if (clientMarketSendData != null && _lastLinkIndex != num)
					{
						if (changeColor)
						{
							ChangeVertexColors(isHover: false);
						}
						if (Object.op_Implicit((Object)(object)CurrentTooltip))
						{
							Object.Destroy((Object)(object)CurrentTooltip);
						}
						_lastLinkIndex = num;
						linkStartTextIndex = val.linkTextfirstCharacterIndex;
						linkTextLength = val.linkTextLength;
						CurrentTooltip = CreateTooltipForItemLinkData(clientMarketSendData);
						ChangeVertexColors(isHover: true);
					}
				}
				catch (Exception arg)
				{
					linkStartTextIndex = -1;
					linkTextLength = 0;
					Utils.print($"[CMS] Error: {arg}", ConsoleColor.Red);
				}
			}

			private void LateUpdate()
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				if (!((Component)this).gameObject.IsHovering())
				{
					OnDisable();
					return;
				}
				int num = TMP_TextUtilities.FindIntersectingLink(_text, Input.mousePosition, (Camera)null);
				if (num == -1)
				{
					OnDisable();
				}
				else
				{
					ProcessTMP(num);
				}
			}

			private GameObject CreateTooltipForItemLinkData(Marketplace_DataTypes.ClientMarketSendData itemLinkData, string additionalText = "")
			{
				GetItemData(itemLinkData, out string topic, out string text, out Sprite icon, out ItemData item);
				GameObject val = Object.Instantiate<GameObject>(TooltipPrefab, ((Component)this).transform.parent);
				((Component)val.transform.Find("Bkg/Icon")).GetComponent<Image>().sprite = icon;
				((Component)val.transform.Find("Bkg/Icon")).GetComponent<Image>().type = (Type)1;
				((Component)val.transform.Find("Bkg/Topic")).GetComponent<Text>().text = Localization.instance.Localize(topic) + additionalText;
				((Component)val.transform.Find("Bkg/Text")).GetComponent<Text>().text = Localization.instance.Localize(text);
				Transform val2 = val.transform.Find("Bkg/TrannyHoles");
				bool active = Jewelcrafting.API.FillItemContainerTooltip(item, val2.parent, showInteract: false);
				((Component)val2).gameObject.SetActive(active);
				Transform transform = ((Component)val.transform.GetChild(0)).transform;
				AdjustPosition((RectTransform)(object)((transform is RectTransform) ? transform : null));
				return val;
			}

			public static void GetItemData(Marketplace_DataTypes.ClientMarketSendData itemLinkData, out string topic, out string text, out Sprite icon, out ItemData item)
			{
				item = ObjectDB.instance.m_itemByHash[StringExtensionMethods.GetStableHashCode(itemLinkData.ItemPrefab)].GetComponent<ItemDrop>().m_itemData.Clone();
				item.m_customData = JSON.ToObject<Dictionary<string, string>>(itemLinkData.CUSTOMdata);
				item.m_stack = itemLinkData.Count;
				item.m_quality = itemLinkData.Quality;
				item.m_variant = itemLinkData.Variant;
				item.m_crafterID = itemLinkData.CrafterID;
				item.m_crafterName = itemLinkData.CrafterName;
				item.m_durability = item.GetMaxDurability() * (float)(int)itemLinkData.DurabilityPercent / 100f;
				UITooltip component = TooltipTrick.GetComponent<UITooltip>();
				bool canBeReparied = item.m_shared.m_canBeReparied;
				item.m_shared.m_canBeReparied = false;
				InventoryGui.instance.m_playerGrid.CreateItemTooltip(item, component);
				item.m_shared.m_canBeReparied = canBeReparied;
				topic = Localization.instance.Localize(component.m_topic);
				text = Localization.instance.Localize(component.m_text);
				icon = item.GetIcon();
			}

			private void ChangeVertexColors(bool isHover)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: 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_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: 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_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				if (isHover)
				{
					_oldColors = new List<Color>(linkTextLength);
				}
				for (int i = 0; i < linkTextLength; i++)
				{
					int num = linkStartTextIndex + i;
					if (_text.textInfo.characterInfo[num].character == ' ')
					{
						_oldColors.Add(defaultHoverColor);
						_oldColors.Add(defaultHoverColor);
						_oldColors.Add(defaultHoverColor);
						_oldColors.Add(defaultHoverColor);
						continue;
					}
					int materialReferenceIndex = _text.textInfo.characterInfo[num].materialReferenceIndex;
					int vertexIndex = _text.textInfo.characterInfo[num].vertexIndex;
					Color32[] colors = _text.textInfo.meshInfo[materialReferenceIndex].colors32;
					if (isHover)
					{
						_oldColors.Add(Color32.op_Implicit(colors[vertexIndex]));
						_oldColors.Add(Color32.op_Implicit(colors[vertexIndex + 1]));
						_oldColors.Add(Color32.op_Implicit(colors[vertexIndex + 2]));
						_oldColors.Add(Color32.op_Implicit(colors[vertexIndex + 3]));
						colors[vertexIndex] = Color32.op_Implicit(defaultHoverColor);
						colors[vertexIndex + 1] = Color32.op_Implicit(defaultHoverColor);
						colors[vertexIndex + 2] = Color32.op_Implicit(defaultHoverColor);
						colors[vertexIndex + 3] = Color32.op_Implicit(defaultHoverColor);
					}
					else
					{
						colors[vertexIndex] = Color32.op_Implicit(_oldColors[i * 4]);
						colors[vertexIndex + 1] = Color32.op_Implicit(_oldColors[i * 4 + 1]);
						colors[vertexIndex + 2] = Color32.op_Implicit(_oldColors[i * 4 + 2]);
						colors[vertexIndex + 3] = Color32.op_Implicit(_oldColors[i * 4 + 3]);
					}
				}
				_text.UpdateVertexData((TMP_VertexDataUpdateFlags)16);
			}

			private void AdjustPosition(RectTransform bkg, float minusX = 5f)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: 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)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: 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_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				ContentSizeFitter component = ((Component)bkg).GetComponent<ContentSizeFitter>();
				((Behaviour)component).enabled = false;
				((Behaviour)component).enabled = true;
				Canvas.ForceUpdateCanvases();
				Vector3 val = _text.transform.TransformPoint(_text.textInfo.characterInfo[linkStartTextIndex + linkTextLength - 1].topRight);
				Vector3 val2 = _text.transform.TransformPoint(_text.textInfo.characterInfo[linkStartTextIndex + linkTextLength - 1].bottomRight);
				Vector3 position = default(Vector3);
				((Vector3)(ref position))..ctor(val.x, (val.y + val2.y) / 2f, 0f);
				((Component)bkg).transform.parent.position = position;
				Transform parent = ((Component)bkg).transform.parent;
				Transform obj = ((parent is RectTransform) ? parent : null);
				((RectTransform)obj).anchoredPosition = ((RectTransform)obj).anchoredPosition + new Vector2(116.25f + minusX, bkg.sizeDelta.y / 2f * 0.75f);
			}
		}

		public const string KEY = "kg.CMSLINK:";

		public static GameObject TooltipPrefab;

		public static GameObject TooltipTrick;

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_0019: 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_002b: Expected O, but got Unknown
			TooltipPrefab = AssetStorage.asset.LoadAsset<GameObject>("TooltipPrefab_CMS");
			TooltipTrick = new GameObject("kg_CMS_TooltipTrick")
			{
				hideFlags = (HideFlags)61
			};
			TooltipTrick.AddComponent<UITooltip>();
			TooltipTrick.SetActive(false);
		}
	}
}
namespace Marketplace.Hammer
{
	[Market_Autoload(Market_Autoload.Type.Client, Market_Autoload.Priority.Last, "OnInit", null, null)]
	public static class MarketplaceHammer
	{
		public class NPC_FadeCopy : MonoBehaviour
		{
			private GameObject pastOverrideModel;

			private void Awake()
			{
				//IL_010c: 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_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				Piece component = ((Component)this).GetComponent<Piece>();
				string name = component.m_name;
				if (!_npcData.ContainsKey(name))
				{
					return;
				}
				Wrapper wrapper = _npcData[name];
				string text = wrapper.main.Prefab;
				float num = Convert.ToSingle(wrapper.fashion.ModelScale, CultureInfo.InvariantCulture);
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				bool flag = false;
				if (text.Contains("@humanoid"))
				{
					flag = true;
					text = text.Replace("@humanoid", "");
				}
				text = text.Replace("_Female", "");
				GameObject prefab = ZNetScene.instance.GetPrefab(text);
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					return;
				}
				Animator componentInChildren = prefab.GetComponentInChildren<Animator>();
				GameObject val = ((componentInChildren != null) ? ((Component)componentInChildren).gameObject : null);
				if (Object.op_Implicit((Object)(object)val))
				{
					pastOverrideModel = Object.Instantiate<GameObject>(val, ((Component)this).transform);
					LODGroup component2 = pastOverrideModel.GetComponent<LODGroup>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						Object.Destroy((Object)(object)component2);
					}
					ParticleSystem[] componentsInChildren = pastOverrideModel.GetComponentsInChildren<ParticleSystem>();
					foreach (ParticleSystem val2 in componentsInChildren)
					{
						EmissionModule emission = val2.emission;
						((EmissionModule)(ref emission)).enabled = false;
					}
					Collider[] componentsInChildren2 = pastOverrideModel.GetComponentsInChildren<Collider>(true);
					Collider[] array = componentsInChildren2;
					foreach (Collider val3 in array)
					{
						val3.enabled = false;
					}
					Transform transform = pastOverrideModel.transform;
					transform.localScale *= num;
					if (flag)
					{
						pastOverrideModel.GetComponent<Animator>().runtimeAnimatorController = ZNetScene.instance.GetPrefab("Player").GetComponentInChildren<Animator>().runtimeAnimatorController;
					}
					pastOverrideModel.GetComponent<Animator>().SetBool(Animator.StringToHash("wakeup"), false);
					pastOverrideModel.GetComponent<Animator>().Update(0f);
				}
			}

			private void OnEnable()
			{
				if (Object.op_Implicit((Object)(object)pastOverrideModel))
				{
					pastOverrideModel.GetComponent<Animator>().SetBool(Animator.StringToHash("wakeup"), false);
				}
			}
		}

		[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
		[ClientOnlyPatch]
		private static class PieceTable_UpdateAvailable_Patch
		{
			[UsedImplicitly]
			private static void Postfix(PieceTable __instance)
			{
				Hud_Awake_Patch.UI.SetActive(false);
				if (((Object)__instance).name != "_MarketplacePieceTable")
				{
					return;
				}
				List<Piece> list = __instance.m_availablePieces[0];
				Hud_Awake_Patch.UI.SetActive(true);
				if (!Utils.IsDebug_Marketplace)
				{
					return;
				}
				list.Add(Market_NPC.NPC.GetComponent<Piece>());
				int count = (Hud_Awake_Patch.CurrentPage - 1) * 89;
				foreach (Piece item in _pieces.Skip(count).Take(89))
				{
					list.Add(item);
				}
			}
		}

		public struct Wrapper
		{
			public bool isPinned;

			public NPC_DataTypes.NPC_Main main;

			public NPC_DataTypes.NPC_Fashion fashion;
		}

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

				public static ConsoleEvent <>9__0_0;

				internal void <Postfix>b__0_0(ConsoleEventArgs _)
				{
					Reload();
				}
			}

			[UsedImplicitly]
			private static void Postfix(Terminal __instance)
			{
				//IL_0032: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate
					{
						Reload();
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("mreloadnpcs", "Reloads all saved NPCs", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		[ClientOnlyPatch]
		private static class HookBuild
		{
			[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;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private MethodInfo <method>5__2;

				private IEnumerator<CodeInstruction> <>7__wrap2;

				private CodeInstruction <instruction>5__4;

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

				object IEnumerator.Current
				{
					[DebuggerHidden]
					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) <= 2u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<method>5__2 = null;
					<>7__wrap2 = null;
					<instruction>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
					//IL_0100: Expected O, but got Unknown
					//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d7: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<method>5__2 = AccessTools.Method(typeof(HookBuild), "PlacedPiece", new Type[1] { typeof(GameObject) }, (Type[])null);
							<>7__wrap2 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							if (<instruction>5__4.opcode == OpCodes.Stloc_0)
							{
								<>2__current = new CodeInstruction(OpCodes.Ldloc_S, (object)0);
								<>1__state = 2;
								return true;
							}
							goto IL_0113;
						case 2:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)<method>5__2);
							<>1__state = 3;
							return true;
						case 3:
							{
								<>1__state = -3;
								goto IL_0113;
							}
							IL_0113:
							<instruction>5__4 = null;
							break;
						}
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							<>2__current = <instruction>5__4;
							<>1__state = 1;
							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__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]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			public static void PlacedPiece(GameObject obj)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				Piece val = ((obj != null) ? obj.GetComponent<Piece>() : null);
				if (val == null)
				{
					return;
				}
				string name = ((Object)val).name;
				if (!name.Contains("MARKETNPC_HAMMER_BUILDED"))
				{
					return;
				}
				Wrapper value;
				bool flag = _npcData.TryGetValue(val.m_name, out value);
				Vector3 position = ((Component)val).transform.position;
				Quaternion rotation = ((Component)val).transform.rotation;
				Object.Destroy((Object)(object)obj);
				if (flag)
				{
					GameObject val2 = Object.Instantiate<GameObject>(Market_NPC.NPC, position, rotation);
					Market_NPC.NPCcomponent component = val2.GetComponent<Market_NPC.NPCcomponent>();
					component.ChangeNpcType(0L, (int)value.main.Type, value.isPinned, value.main.PinIcon);
					component.ChangeProfile(0L, value.main.Profile, value.main.Dialogue);
					component.OverrideName(0L, value.main.NameOverride);
					if (!string.IsNullOrWhiteSpace(value.main.Prefab))
					{
						component.OverrideModel(0L, value.main.Prefab.RandomSplitSpace());
					}
					value.fashion.ApplyRandom();
					component.FashionApply(0L, value.fashion);
				}
			}

			[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
				};
			}
		}

		[HarmonyPatch(typeof(Piece), "CanBeRemoved")]
		[ClientOnlyPatch]
		private static class Piece_CanBeRemoved_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Piece __instance, ref bool __result)
			{
				if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<Market_NPC.NPCcomponent>()) && !Utils.IsDebug_Marketplace)
				{
					__result = false;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		[ClientOnlyPatch]
		private static class Player_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Player __instance)
			{
				int mask = LayerMask.GetMask(new string[1] { "character" });
				__instance.m_removeRayMask |= mask;
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		[ClientOnlyPatch]
		private static class Hud_Awake_Patch
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static UnityAction <0>__OnPageLeft;

				public static UnityAction <1>__OnPageRight;
			}

			public static GameObject UI;

			private static Text _text;

			public static int CurrentPage = 1;

			public const int MaxPerPage = 89;

			private static int MaxPages => Mathf.CeilToInt((float)_pieces.Count / 89f);

			[UsedImplicitly]
			private static void Postfix(Hud __instance)
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				CurrentPage = 1;
				UI = Object.Instantiate<GameObject>(AssetStorage.asset.LoadAsset<GameObject>("MarketHammer_Pages"), __instance.m_buildHud.transform.Find("bar/SelectionWindow"));
				UI.transform.SetAsLastSibling();
				UI.SetActive(false);
				_text = ((Component)UI.transform.Find("Page/Text")).GetComponent<Text>();
				ButtonClickedEvent onClick = ((Component)UI.transform.Find("PageLeft")).GetComponent<Button>().onClick;
				object obj = <>O.<0>__OnPageLeft;
				if (obj == null)
				{
					UnityAction val = OnPageLeft;
					<>O.<0>__OnPageLeft = val;
					obj = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				ButtonClickedEvent onClick2 = ((Component)UI.transform.Find("PageRight")).GetComponent<Button>().onClick;
				object obj2 = <>O.<1>__OnPageRight;
				if (obj2 == null)
				{
					UnityAction val2 = OnPageRight;
					<>O.<1>__OnPageRight = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				_text.text = $"{CurrentPage} / {MaxPages}";
			}

			public static void SetPage(int page)
			{
				CurrentPage = Mathf.Clamp(page, 1, MaxPages);
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					localPlayer.UpdateAvailablePiecesList();
				}
				if (Object.op_Implicit((Object)(object)_text))
				{
					_text.text = $"{CurrentPage} / {MaxPages}";
				}
			}

			private static void OnPageLeft()
			{
				AssetStorage.AUsrc.Play();
				SetPage(CurrentPage - 1);
			}

			private static void OnPageRight()
			{
				AssetStorage.AUsrc.Play();
				SetPage(CurrentPage + 1);
			}
		}

		private static Dictionary<string, Wrapper> _npcData = new Dictionary<string, Wrapper>();

		private static List<Piece> _pieces = new List<Piece>();

		private static GameObject CopyFrom;

		private static GameObject INACTIVE = new GameObject("INACTIVE_SAVEDNPCS")
		{
			hideFlags = (HideFlags)61
		};

		private static GameObject MarketplaceHammer_Item;

		private static void ProcessSavedNPC(string fileName, string data)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (_npcData.ContainsKey(fileName))
			{
				return;
			}
			try
			{
				Wrapper value = new DeserializerBuilder().Build().Deserialize<Wrapper>(data);
				_npcData[fileName] = value;
				GameObject val = Object.Instantiate<GameObject>(CopyFrom, INACTIVE.transform);
				((Object)val).name = "MARKETNPC_HAMMER_BUILDED";
				val.GetComponent<Piece>().m_name = fileName;
				val.GetComponent<Piece>().m_description = value.main.Description();
				if (!string.IsNullOrEmpty(value.main.IMAGE))
				{
					Texture2D val2 = new Texture2D(1, 1);
					ImageConversion.LoadImage(val2, Convert.FromBase64String(value.main.IMAGE));
					val.GetComponent<Piece>().m_icon = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0f, 0f));
				}
				else
				{
					val.GetComponent<Piece>().m_icon = AssetStorage.NullSprite;
				}
				_pieces.Add(val.GetComponent<Piece>());
			}
			catch (Exception arg)
			{
				Utils.print($"Error file parsing saved npc: {fileName}: \n{arg}");
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			INACTIVE.SetActive(false);
			CopyFrom = AssetStorage.asset.LoadAsset<GameObject>("MarketplaceHammerCopyFrom");
			CopyFrom.AddComponent<NPC_FadeCopy>();
			MarketplaceHammer_Item = AssetStorage.asset.LoadAsset<GameObject>("MarketplaceHammer");
			Item item = new Item(MarketplaceHammer_Item);
			item.Configurable = Configurability.Disabled;
			item.Name.English("Marketplace Hammer");
			item.Description.English("Used to place NPCs");
			Reload();
		}

		private static void Reload()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			MessageHud instance = MessageHud.instance;
			if (instance != null)
			{
				instance.ShowMessage((MessageType)2, "Reloading NPC Hammer List", 0, (Sprite)null, false);
			}
			if (Object.op_Implicit((Object)(object)Chat.instance))
			{
				Chat.instance.m_hideTimer = 0f;
				((Terminal)Chat.instance).AddString("<color=green>Reloading NPC Hammer List</color>");
			}
			_npcData.Clear();
			_pieces.Clear();
			foreach (Transform item in INACTIVE.transform)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			string nPC_Saved = Market_Paths.NPC_Saved;
			string[] files = Directory.GetFiles(nPC_Saved, "*.yml", SearchOption.AllDirectories);
			string[] files2 = Directory.GetFiles(nPC_Saved, "*.yaml", SearchOption.AllDirectories);
			foreach (string item2 in files.Concat(files2))
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item2);
				string data = File.ReadAllText(item2);
				ProcessSavedNPC(fileNameWithoutExtension, data);
			}
			Hud_Awake_Patch.SetPage(1);
		}

		public static void SaveNPC(Market_NPC.NPCcomponent npc)
		{
			string nPC_Saved = Market_Paths.NPC_Saved;
			NPC_DataTypes.NPC_Main main = default(NPC_DataTypes.NPC_Main);
			NPC_DataTypes.NPC_Fashion fashion = default(NPC_DataTypes.NPC_Fashion);
			bool isPinned = npc.znv.m_zdo.GET_NPC_IsPinned();
			main.Type = npc._currentNpcType;
			main.NameOverride = npc.znv.m_zdo.GET_NPC_Name();
			main.Profile = npc.znv.m_zdo.GET_NPC_Profile();
			main.Prefab = npc.znv.m_zdo.GET_NPC_Model();
			main.Dialogue = npc.znv.m_zdo.GET_NPC_Dialogue();
			main.PinIcon = npc.znv.m_zdo.GET_NPC_PinIcon();
			fashion.LeftItem = npc.znv.m_zdo.GET_NPC_LeftItem();
			fashion.RightItem = npc.znv.m_zdo.GET_NPC_RightItem();
			fashion.HelmetItem = npc.znv.m_zdo.GET_NPC_HelmetItem();
			fashion.ChestItem = npc.znv.m_zdo.GET_NPC_ChestItem();
			fashion.LegsItem = npc.znv.m_zdo.GET_NPC_LegsItem();
			fashion.CapeItem = npc.znv.m_zdo.GET_NPC_CapeItem();
			fashion.HairItem = npc.znv.m_zdo.GET_NPC_HairItem();
			fashion.HairColor = npc.znv.m_zdo.GET_NPC_HairColor();
			fashion.ModelScale = npc.znv.m_zdo.GET_NPC_NPCScale().ToString();
			fashion.LeftItemHidden = npc.znv.m_zdo.GET_NPC_LeftItemBack();
			fashion.RightItemHidden = npc.znv.m_zdo.GET_NPC_RightItemBack();
			fashion.InteractAnimation = npc.znv.m_zdo.GET_NPC_InteractAnimation();
			fashion.GreetAnimation = npc.znv.m_zdo.GET_NPC_GreetingAnimation();
			fashion.ByeAnimation = npc.znv.m_zdo.GET_NPC_ByeAnimation();
			fashion.GreetText = npc.znv.m_zdo.GET_NPC_GreetingText();
			fashion.ByeText = npc.znv.m_zdo.GET_NPC_ByeText();
			fashion.SkinColor = npc.znv.m_zdo.GET_NPC_SkinColor();
			fashion.CraftingAnimation = npc.znv.m_zdo.GET_NPC_CraftingAnimation();
			fashion.BeardItem = npc.znv.m_zdo.GET_NPC_BeardItem();
			fashion.BeardColor = npc.znv.m_zdo.GET_NPC_BeardColor();
			fashion.InteractAudioClip = npc.znv.m_zdo.GET_NPC_InteractSound();
			fashion.TextSize = npc.znv.m_zdo.GET_NPC_TextSize().ToString();
			fashion.TextHeight = npc.znv.m_zdo.GET_NPC_TextHeight().ToString();
			fashion.PeriodicAnimation = npc.znv.m_zdo.GET_NPC_PeriodicAnimation();
			fashion.PeriodicAnimationTime = npc.znv.m_zdo.GET_NPC_PeriodicAnimationTime().ToString();
			fashion.PeriodicSound = npc.znv.m_zdo.GET_NPC_PeriodicSound();
			fashion.PeriodicSoundTime = npc.znv.m_zdo.GET_NPC_PeriodicSoundTime().ToString();
			((Component)((Component)npc).transform.Find("TMP")).gameObject.SetActive(false);
			main.IMAGE = PlayerModelPreview.MakeScreenshot(((Component)npc).gameObject, 256);
			((Component)((Component)npc).transform.Find("TMP")).gameObject.SetActive(true);
			string text = $"{npc._currentNpcType} {main.NameOverride.NoRichText()} {main.Profile.NoRichText()}";
			string path = Path.Combine(nPC_Saved, text + ".yml");
			if (!File.Exists(path))
			{
				File.Create(path).Dispose();
			}
			Wrapper wrapper = default(Wrapper);
			wrapper.main = main;
			wrapper.fashion = fashion;
			wrapper.isPinned = isPinned;
			Wrapper wrapper2 = wrapper;
			string contents = new SerializerBuilder().Build().Serialize(wrapper2);
			File.WriteAllText(path, contents);
			Chat.instance.m_hideTimer = 0f;
			((Terminal)Chat.instance).AddString("<color=green>NPC Saved to " + Path.GetFileName(path) + ". Write <color=yellow>/mreloadnpcs</color> to reload NPC list in hammer</color>");
		}
	}
}
namespace Marketplace.ExternalLoads
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Both, Market_Autoload.Priority.Init, "OnInit", null, null)]
	public static class AsmLoad_UnityCode
	{
		[UsedImplicitly]
		public static void OnInit()
		{
			LoadAsm("Marketplace_UnityCode");
		}

		public static void LoadAsm(string name)
		{
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Marketplace.Resources." + name + ".dll");
			byte[] array = new byte[manifestResourceStream.Length];
			manifestResourceStream.Read(array, 0, array.Length);
			try
			{
				Assembly.Load(array);
				manifestResourceStream.Dispose();
			}
			catch (Exception arg)
			{
				Utils.print($"Error loading {name} assembly\n:{arg}", ConsoleColor.Red);
			}
		}
	}
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Both, Market_Autoload.Priority.First, "OnInit", null, null)]
	public static class AssetStorage
	{
		[HarmonyPatch(typeof(AudioMan), "Awake")]
		[ClientOnlyPatch]
		private static class AudioMan_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(AudioMan __instance)
			{
				AudioMixerGroup outputAudioMixerGroup = __instance.m_masterMixer.FindMatchingGroups("SFX")[0];
				AUsrc = Chainloader.ManagerObject.AddComponent<AudioSource>();
				AUsrc.clip = asset.LoadAsset<AudioClip>("MarketClick");
				AUsrc.reverbZoneMix = 0f;
				AUsrc.spatialBlend = 0f;
				AUsrc.bypassListenerEffects = true;
				AUsrc.bypassEffects = true;
				AUsrc.volume = 0.8f;
				AUsrc.outputAudioMixerGroup = AudioMan.instance.m_masterMixer.outputAudioMixerGroup;
				GameObject[] array = asset.LoadAllAssets<GameObject>();
				foreach (GameObject val in array)
				{
					AudioSource[] componentsInChildren = val.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val2 in componentsInChildren)
					{
						val2.outputAudioMixerGroup = outputAudioMixerGroup;
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <LoadSoundsCoroutine>d__28 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string path;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

			private string <file>5__4;

			private UnityWebRequest <stream>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<file>5__4 = null;
				<stream>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = Directory.GetFiles(path, "*.mp3", SearchOption.AllDirectories);
						<>7__wrap2 = 0;
						break;
					case 1:
						<>1__state = -3;
						try
						{
							AudioClip content = DownloadHandlerAudioClip.GetContent(<stream>5__5);
							NPC_AudioClips[Path.GetFileNameWithoutExtension(<file>5__4)] = content;
						}
						catch (Exception arg)
						{
							Utils.print($"Can't load clip: {<file>5__4}. Reason:\n{arg}", ConsoleColor.Red);
						}
						<>m__Finally1();
						<stream>5__5 = null;
						<file>5__4 = null;
						<>7__wrap2++;
						break;
					}
					if (<>7__wrap2 < <>7__wrap1.Length)
					{
						<file>5__4 = <>7__wrap1[<>7__wrap2];
						<stream>5__5 = UnityWebRequestMultimedia.GetAudioClip(<file>5__4, (AudioType)13);
						<>1__state = -3;
						<>2__current = <stream>5__5.SendWebRequest();
						<>1__state = 1;
						return true;
					}
					<>7__wrap1 = 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 (<stream>5__5 != null)
				{
					((IDisposable)<stream>5__5).Dispose();
				}
			}

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

		public static AssetBundle asset = null;

		public static readonly Dictionary<string, Sprite> GlobalCachedSprites = new Dictionary<string, Sprite>();

		public static readonly Dictionary<string, AudioClip> NPC_AudioClips = new Dictionary<string, AudioClip>();

		public static readonly Dictionary<string, string> NPC_VideoClips = new Dictionary<string, string>();

		public static GameObject MarketplaceQuestTargetIcon = null;

		public static GameObject MarketplaceQuestHasQuestIcon = null;

		public static GameObject MarketplaceQuestQuestionIcon = null;

		public static Sprite PlaceholderMonsterIcon = null;

		public static Sprite PlaceholderGamblerIcon = null;

		public static Sprite RandomItemIcon = null;

		public static Sprite MoveQuestIcon = null;

		public static Sprite PlaceholderMailIcon = null;

		public static Sprite NPC_MapControl = null;

		public static Sprite CustomValue_Icon = null;

		public static Sprite EpicMMO_Exp = null;

		public static Sprite Cozyheim_Exp = null;

		public static Sprite Battlepass_Exp = null;

		public static Sprite MH_Exp_Icon = null;

		public static Sprite NullSprite = null;

		public static Sprite QuestCompleteIcon = null;

		public static Sprite PortalIconDefault = null;

		public static Sprite RustyClassesIcon = null;

		public static Texture WoodTex = null;

		public static AudioClip TypeClip = null;

		public static GameObject Teleporter_VFX1 = null;

		public static GameObject Teleporter_VFX2 = null;

		public static AudioSource AUsrc = null;

		[UsedImplicitly]
		private static void OnInit()
		{
			asset = GetAssetBundle("kg_marketplace");
			TypeClip = asset.LoadAsset<AudioClip>("TypeKeySoundMP");
			NullSprite = asset.LoadAsset<Sprite>("NullSpriteMP");
			WoodTex = asset.LoadAsset<Texture>("cbimage");
			Teleporter_VFX1 = asset.LoadAsset<GameObject>("MarketplaceTP_1");
			Teleporter_VFX2 = asset.LoadAsset<GameObject>("MarketplaceTP_2");
			MarketplaceQuestTargetIcon = asset.LoadAsset<GameObject>("MarketplaceQuestTargetIcon");
			MarketplaceQuestQuestionIcon = asset.LoadAsset<GameObject>("MarketplaceQuestionMark");
			MarketplaceQuestHasQuestIcon = asset.LoadAsset<GameObject>("MarketplaceHasQuestsMark");
			CustomValue_Icon = asset.LoadAsset<Sprite>("CustomValueIcon");
			QuestCompleteIcon = asset.LoadAsset<Sprite>("questcomplete");
			EpicMMO_Exp = asset.LoadAsset<Sprite>("EpicMMOIcon");
			MH_Exp_Icon = asset.LoadAsset<Sprite>("magicheim_icon");
			Cozyheim_Exp = asset.LoadAsset<Sprite>("cozyheim_icon");
			PlaceholderGamblerIcon = asset.LoadAsset<Sprite>("placeholdergambler_icon");
			RandomItemIcon = asset.LoadAsset<Sprite>("randomitem_icon");
			MoveQuestIcon = asset.LoadAsset<Sprite>("movequesticon");
			PlaceholderMailIcon = asset.LoadAsset<Sprite>("MarketplaceMailPlaceholder");
			PlaceholderMonsterIcon = asset.LoadAsset<Sprite>("placeholdermonster_icon");
			PortalIconDefault = asset.LoadAsset<Sprite>("default_portal_icon");
			NPC_MapControl = asset.LoadAsset<Sprite>("NPC_MapControl");
			Battlepass_Exp = asset.LoadAsset<Sprite>("battlepass_icon");
			RustyClassesIcon = asset.LoadAsset<Sprite>("RustyClassesIcon");
			GlobalCachedSprites["teleporter_default"] = PortalIconDefault;
			if (Marketplace.WorkingAsType != Marketplace.WorkingAs.Server)
			{
				ReloadImages();
				ReloadSounds();
				ReloadVideoClips();
			}
		}

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

		public static void ReloadSounds()
		{
			((MonoBehaviour)Marketplace._thistype).StartCoroutine(LoadSoundsCoroutine(Market_Paths.NPC_SoundsPath));
		}

		public static void ReloadImages()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			GlobalCachedSprites.Clear();
			string[] files = Directory.GetFiles(Market_Paths.CachedImagesFolder, "*.png", SearchOption.AllDirectories);
			foreach (string path in files)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(1, 1);
				ImageConversion.LoadImage(val, array);
				Sprite value = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0f, 0f));
				GlobalCachedSprites[fileNameWithoutExtension] = value;
			}
		}

		public static void ReloadVideoClips()
		{
			NPC_VideoClips.Clear();
			string[] files = Directory.GetFiles(Market_Paths.VideoClipsFolder, "*.*", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
				NPC_VideoClips[fileNameWithoutExtension] = text;
			}
		}

		public static AssetBundle GetAssetBundle(string filename)
		{
			string filename2 = filename;
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename2));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}
	}
}
namespace Marketplace.DiscordStuff
{
	[UsedImplicitly]
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.Last, "OnInit", new string[] { "DiscordSettings.cfg" }, new string[] { "OnDiscordSettingsChange" })]
	public static class DiscordStuff
	{
		public enum Webhooks
		{
			Marketplace,
			Gambler,
			Quest,
			Lootboxes
		}

		private static ConfigFile DiscordConfig;

		private static Dictionary<Webhooks, ConfigEntry<string>> WebhookLinks;

		private static Dictionary<Webhooks, ConfigEntry<string>> LocalizedWebhookTitles;

		private static Dictionary<Webhooks, ConfigEntry<string>> WebhookMessages;

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_0012: 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_0023: Expected O, but got Unknown
			string text = Path.Combine(Market_Paths.DiscordStuffFolder, "DiscordSettings.cfg");
			DiscordConfig = new ConfigFile(text, true)
			{
				SaveOnConfigSet = true
			};
			WebhookLinks = new Dictionary<Webhooks, ConfigEntry<string>>
			{
				[Webhooks.Marketplace] = DiscordConfig.Bind<string>("Webhook Links", "Marketplace Webhook Link", "LINK HERE", (ConfigDescription)null),
				[Webhooks.Gambler] = DiscordConfig.Bind<string>("Webhook Links", "Gambler Webhook Link", "LINK HERE", (ConfigDescription)null),
				[Webhooks.Quest] = DiscordConfig.Bind<string>("Webhook Links", "Quest Webhook Link", "LINK HERE", (ConfigDescription)null),
				[Webhooks.Lootboxes] = DiscordConfig.Bind<string>("Webhook Links", "Lootboxes Webhook Link", "LINK HERE", (ConfigDescription)null)
			};
			WebhookMessages = new Dictionary<Webhooks, ConfigEntry<string>>
			{
				[Webhooks.Marketplace] = DiscordConfig.Bind<string>("Webhook Messages", "Marketplace Webhook Message", "**{0}** posted **x{1} {2}** with **{3} {4} each**", (ConfigDescription)null),
				[Webhooks.Gambler] = DiscordConfig.Bind<string>("Webhook Messages", "Gambler Webhook Message", "**{0}** won **x{1} {2}**!", (ConfigDescription)null),
				[Webhooks.Quest] = DiscordConfig.Bind<string>("Webhook Messages", "Quest Webhook Message", "**{0}** finished quest **{1}**", (ConfigDescription)null),
				[Webhooks.Lootboxes] = DiscordConfig.Bind<string>("Webhook Messages", "Lootboxes Webhook Message", "**{0}** opened **{1}** and got: **{2}**", (ConfigDescription)null)
			};
			LocalizedWebhookTitles = new Dictionary<Webhooks, ConfigEntry<string>>
			{
				[Webhooks.Marketplace] = DiscordConfig.Bind<string>("Webhook Titles", "Marketplace Webhook Title", "Marketplace Message", (ConfigDescription)null),
				[Webhooks.Gambler] = DiscordConfig.Bind<string>("Webhook Titles", "Gambler Webhook Title", "Gambler Message", (ConfigDescription)null),
				[Webhooks.Quest] = DiscordConfig.Bind<string>("Webhook Titles", "Quest Webhook Title", "Quest Message", (ConfigDescription)null),
				[Webhooks.Lootboxes] = DiscordConfig.Bind<string>("Webhook Titles", "Lootboxes Webhook Title", "Lootboxes Message", (ConfigDescription)null)
			};
		}

		[UsedImplicitly]
		private static void OnDiscordSettingsChange()
		{
			Utils.DelayReloadConfig(DiscordConfig);
			Utils.print("Discord Settings Changed.");
		}

		public static void SendMarketplaceWebhook(global::Marketplace.DB.DB.MarketSlot data)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			if (!(data.SellerName == "**************"))
			{
				ZPackage val = new ZPackage();
				val.Write(0);
				val.Write(data.SellerName);
				val.Write(data.Count);
				val.Write(data.ItemName);
				val.Write(data.Price);
				val.Write(ZNetScene.instance.GetPrefab(data.Currency).GetComponent<ItemDrop>().m_itemData.m_shared.m_name);
				val.SetPos(0);
				SendWebhook(0L, val);
			}
		}

		[MarketplaceRPC("KGmarket CustomWebhooks", Market_Autoload.Type.Server)]
		private static void SendWebhook(long sender, ZPackage pkg)
		{
			Webhooks type = (Webhooks)pkg.ReadInt();
			string link = WebhookLinks[type].Value;
			if (!Uri.TryCreate(link, UriKind.Absolute, out Uri _))
			{
				return;
			}
			string text2 = pkg.ReadString();
			string text;
			switch (type)
			{
			case Webhooks.Marketplace:
				text = string.Format(WebhookMessages[type].Value, text2, pkg.ReadInt(), Localization.instance.Localize(pkg.ReadString()), pkg.ReadInt(), pkg.ReadString());
				break;
			case Webhooks.Gambler:
				text = string.Format(WebhookMessages[type].Value, text2, pkg.ReadInt(), Localization.instance.Localize(pkg.ReadString()));
				break;
			case Webhooks.Quest:
				text = string.Format(WebhookMessages[type].Value, text2, pkg.ReadString());
				break;
			case Webhooks.Lootboxes:
				text = string.Format(WebhookMessages[type].Value, text2, pkg.ReadString(), Localization.instance.Localize(pkg.ReadString()));
				break;
			default:
				text = "No Data";
				break;
			}
			text = Utils.RemoveRichTextDynamicTag(text, "color");
			Task.Run(async delegate
			{
				string value = "{\n  \"username\": \"" + LocalizedWebhookTitles[type].Value + "\",\n  \"avatar_url\": \"\",\n  \"content\": \"" + text + "\",\n  \"embeds\": [],\n  \"components\": []\n}";
				HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(link);
				httpWebRequest.ContentType = "application/json";
				httpWebRequest.Method = "POST";
				using (StreamWriter streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
				{
					await streamWriter.WriteAsync(value);
				}
				await httpWebRequest.GetResponseAsync();
			});
		}
	}
}
namespace Marketplace.DB
{
	[Market_Autoload(Market_Autoload.Type.Server, Market_Autoload.Priority.First, "OnInit", null, null)]
	public class DB
	{
		public class Marketplace_Context_LiteDB
		{
			private LiteDatabase open => new LiteDatabase(new ConnectionString
			{
				Filename = DBPATH,
				Connection = ConnectionType.Shared
			});

			public void Marketplace_AddItem(MarketSlot item)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<MarketSlot> collection = liteDatabase.GetCollection<MarketSlot>("Marketplace");
					collection.Insert(item);
					collection.EnsureIndex((MarketSlot x) => x.ItemPrefab);
				}
				catch (Exception ex)
				{
					Utils.print("Error adding item to marketplace: " + ex);
				}
			}

			public void Marketplace_RemoveItem(int uid)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<MarketSlot> collection = liteDatabase.GetCollection<MarketSlot>("Marketplace");
					collection.Delete(uid);
				}
				catch (Exception ex)
				{
					Utils.print("Error removing item from marketplace: " + ex);
				}
			}

			public List<MarketSlot> Marketplace_GetItems()
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<MarketSlot> collection = liteDatabase.GetCollection<MarketSlot>("Marketplace");
					return collection.FindAll().ToList();
				}
				catch (Exception ex)
				{
					Utils.print("Error getting items from marketplace: " + ex);
					return new List<MarketSlot>();
				}
			}

			public MarketSlot GetSlotByID(int id)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<MarketSlot> collection = liteDatabase.GetCollection<MarketSlot>("Marketplace");
					return collection.FindById(id);
				}
				catch (Exception ex)
				{
					Utils.print("Error getting slot by id: " + ex);
					return null;
				}
			}

			public void ModifyExisting(MarketSlot slot)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<MarketSlot> collection = liteDatabase.GetCollection<MarketSlot>("Marketplace");
					collection.Update(slot);
				}
				catch (Exception ex)
				{
					Utils.print("Error modifying slot: " + ex);
				}
			}

			public List<CMS_User> GetAllCMSUsers()
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_User> collection = liteDatabase.GetCollection<CMS_User>("Users");
					return collection.FindAll().ToList();
				}
				catch (Exception ex)
				{
					Utils.print("Error getting all CMS users: " + ex);
					return new List<CMS_User>();
				}
			}

			public int GetTotalMailCountForUser(string userID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					return collection.Count((CMS_Entry e) => e.Owner == userID2);
				}
				catch (Exception ex)
				{
					Utils.print("Error getting total mail count for user: " + ex);
					return 0;
				}
			}

			public int GetUnreadMailCountForUser(string userID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					return collection.Count((CMS_Entry e) => e.Owner == userID2 && !e.WasRead);
				}
				catch (Exception ex)
				{
					Utils.print("Error getting unread mail count for user: " + ex);
					return 0;
				}
			}

			public List<CMS_Entry> GetUserMails(string userID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					return collection.Find((CMS_Entry e) => e.Owner == userID2).ToList();
				}
				catch (Exception ex)
				{
					Utils.print("Error getting user mails: " + ex);
					return new List<CMS_Entry>();
				}
			}

			public Dictionary<string, List<CMS_Entry>> GetAllMailsByUserId()
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					Dictionary<string, List<CMS_Entry>> dictionary = new Dictionary<string, List<CMS_Entry>>();
					foreach (CMS_Entry item in collection.FindAll())
					{
						if (!dictionary.ContainsKey(item.Owner))
						{
							dictionary.Add(item.Owner, new List<CMS_Entry>());
						}
						dictionary[item.Owner].Add(item);
					}
					return dictionary;
				}
				catch (Exception ex)
				{
					Utils.print("Error getting all mails by user id: " + ex);
					return new Dictionary<string, List<CMS_Entry>>();
				}
			}

			public void SetMailRead(string userID, int mailUID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					CMS_Entry cMS_Entry = collection.FindOne((CMS_Entry e) => e.Owner == userID2 && e._id == mailUID);
					if (cMS_Entry != null)
					{
						cMS_Entry.WasRead = true;
						collection.Update(cMS_Entry);
					}
				}
				catch (Exception ex)
				{
					Utils.print("Error setting mail read: " + ex);
				}
			}

			public void AddMail(CMS_Entry mail)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					collection.EnsureIndex((CMS_Entry x) => x.Owner);
					collection.Insert(mail);
				}
				catch (Exception ex)
				{
					Utils.print("Error adding mail: " + ex);
				}
			}

			public CMS_Entry GetMailByUID(string userID, int mailUID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					return collection.FindOne((CMS_Entry e) => e.Owner == userID2 && e._id == mailUID);
				}
				catch (Exception ex)
				{
					Utils.print("Error getting mail by uid: " + ex);
					return null;
				}
			}

			public void Mail_SetAttachmentTaken(string userID, int mailUID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					CMS_Entry cMS_Entry = collection.FindOne((CMS_Entry e) => e.Owner == userID2 && e._id == mailUID);
					if (cMS_Entry != null)
					{
						cMS_Entry.AttachmentsTaken = true;
						collection.Update(cMS_Entry);
					}
				}
				catch (Exception ex)
				{
					Utils.print("Error setting attachment taken: " + ex);
				}
			}

			public void RemoveMailFromUser(string userID, int mailUID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_Entry> collection = liteDatabase.GetCollection<CMS_Entry>("Mails");
					CMS_Entry cMS_Entry = collection.FindOne((CMS_Entry e) => e.Owner == userID2 && e._id == mailUID);
					if (cMS_Entry != null)
					{
						collection.Delete(cMS_Entry._id);
					}
				}
				catch (Exception ex)
				{
					Utils.print("Error removing mail from user: " + ex);
				}
			}

			public void AddCMSUser(CMS_User user)
			{
				CMS_User user2 = user;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<CMS_User> collection = liteDatabase.GetCollection<CMS_User>("Users");
					collection.EnsureIndex((CMS_User x) => x.UserID);
					CMS_User cMS_User = collection.FindOne((CMS_User e) => e.UserID == user2.UserID);
					if (cMS_User != null)
					{
						user2._id = cMS_User._id;
						collection.Update(user2);
					}
					else
					{
						collection.Insert(user2);
					}
				}
				catch (Exception ex)
				{
					Utils.print("Error adding CMS user: " + ex);
				}
			}

			public void AddBankItem(string userID, int prefab, int amount)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<BankSlot> collection = liteDatabase.GetCollection<BankSlot>("Bank");
					collection.EnsureIndex((BankSlot x) => x.Owner);
					BankSlot bankSlot = collection.FindOne((BankSlot e) => e.Owner == userID2 && e.Prefab == prefab);
					if (bankSlot == null)
					{
						collection.Insert(new BankSlot
						{
							Owner = userID2,
							Prefab = prefab,
							Amount = amount
						});
					}
					else
					{
						bankSlot.Amount += amount;
						collection.Update(bankSlot);
					}
				}
				catch (Exception ex)
				{
					Utils.print("Error adding bank item: " + ex);
				}
			}

			public int RemoveBankItem(string userID, int prefab, int amount)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<BankSlot> collection = liteDatabase.GetCollection<BankSlot>("Bank");
					collection.EnsureIndex((BankSlot x) => x.Owner);
					BankSlot bankSlot = collection.FindOne((BankSlot e) => e.Owner == userID2 && e.Prefab == prefab);
					if (bankSlot == null)
					{
						return 0;
					}
					int num = Math.Min(bankSlot.Amount, amount);
					bankSlot.Amount -= num;
					if (bankSlot.Amount <= 0)
					{
						collection.Delete(bankSlot._id);
					}
					else
					{
						collection.Update(bankSlot);
					}
					return num;
				}
				catch (Exception ex)
				{
					Utils.print("Error removing bank item: " + ex);
					return 0;
				}
			}

			public Dictionary<int, int> GetUserBankItems(string userID)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<BankSlot> collection = liteDatabase.GetCollection<BankSlot>("Bank");
					return collection.Find((BankSlot e) => e.Owner == userID2).ToDictionary((BankSlot e) => e.Prefab, (BankSlot e) => e.Amount);
				}
				catch (Exception ex)
				{
					Utils.print("Error getting user bank items: " + ex);
					return new Dictionary<int, int>();
				}
			}

			public Player_Leaderboard GetOrCreateLeaderboard(string userID, string playerName)
			{
				string userID2 = userID;
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<Player_Leaderboard> collection = liteDatabase.GetCollection<Player_Leaderboard>("Leaderboard");
					collection.EnsureIndex((Player_Leaderboard x) => x.Owner);
					Player_Leaderboard player_Leaderboard = collection.FindOne((Player_Leaderboard e) => e.Owner == userID2);
					if (player_Leaderboard == null)
					{
						player_Leaderboard = new Player_Leaderboard
						{
							Owner = userID2,
							PlayerName = playerName
						};
						collection.Insert(player_Leaderboard);
					}
					return player_Leaderboard;
				}
				catch (Exception ex)
				{
					Utils.print("Error getting or creating leaderboard: " + ex);
					return null;
				}
			}

			public Dictionary<string, Player_Leaderboard> GetAllLeaderboards()
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<Player_Leaderboard> collection = liteDatabase.GetCollection<Player_Leaderboard>("Leaderboard");
					Dictionary<string, Player_Leaderboard> dictionary = new Dictionary<string, Player_Leaderboard>();
					foreach (Player_Leaderboard item in collection.FindAll())
					{
						dictionary[item.Owner] = item;
					}
					return dictionary;
				}
				catch (Exception ex)
				{
					Utils.print("Error getting all leaderboards: " + ex);
					return new Dictionary<string, Player_Leaderboard>();
				}
			}

			public void UpdateLeaderboard(Player_Leaderboard leaderboard)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<Player_Leaderboard> collection = liteDatabase.GetCollection<Player_Leaderboard>("Leaderboard");
					collection.Update(leaderboard);
				}
				catch (Exception ex)
				{
					Utils.print("Error updating leaderboard: " + ex);
				}
			}

			public void IncreaseInterest(HashSet<string> vipList, Dictionary<string, Dictionary<int, DateTime>> BankerTimeStamp)
			{
				try
				{
					using LiteDatabase liteDatabase = open;
					ILiteCollection<BankSlot> collection = liteDatabase.GetCollection<BankSlot>("Bank");
					List<BankSlot> list = collection.FindAll().ToList();
					Dictionary<string, List<BankSlot>> dictionary = new Dictionary<string, List<BankSlot>>();
					foreach (BankSlot item in list)
					{
						if (!dictionary.ContainsKey(item.Owner))
						{
							dictionary.Add(item.Owner, new List<BankSlot>());
						}
						dictionary[item.Owner].Add(item);
					}
					HashSet<int> hashSet = new HashSet<int>(from i in Global_Configs.BankerInterestItems.Split(new char[1] { ',' })
						select StringExtensionMethods.GetStableHashCode(i));
					bool flag = Global_Configs.BankerInterestItems == "All";
					foreach (KeyValuePair<string, List<BankSlot>> item2 in dictionary)
					{
						float num = (Global_Configs.SyncedGlobalOptions.Value._vipPlayerList.Contains(item2.Key) ? Global_Configs.BankerVIPIncomeMultiplier : Global_Configs.BankerIncomeMultiplier);
						foreach (BankSlot item3 in item2.Value)
						{
							if (item3.Amount > 0 && (flag || hashSet.Contains(item3.Prefab)) && (!BankerTimeStamp.ContainsKey(item2.Key) || !BankerTimeStamp[item2.Key].ContainsKey(item3.Prefab) || (DateTime.Now - BankerTimeStamp[item2.Key][item3.Prefab]).TotalHours >= (double)Global_Configs.BankerIncomeTime))
							{
								double num2 = Math.Ceiling((float)item3.Amount * num);
								if ((double)item3.Amount + num2 > 2147483647.0)
								{
									item3.Amount = int.MaxValue;
								}
								else
								{
									item3.Amount = (int)(num2 + (double)item3.Amount);
								}
								collection.Update(item3);
							}
						}
					}
				}
				catch (Exception ex)
				{
					Utils.print("Error increasing interest: " + ex);
				}
			}
		}

		public class MarketSlot : ISerializableParameter
		{
			public int _id { get; set; }

			public string ItemPrefab { get; set; }

			public int Count { get; set; }

			public int Price { get; set; }

			public string SellerName { get; set; }

			public string SellerUserID { get; set; }

			public Marketplace_DataTypes.ItemData_ItemCategory ItemCategory { get; set; }

			public int Quality { get; set; }

			public int Variant { get; set; }

			public string CrafterName { get; set; } = "";


			public long CrafterID { get; set; }

			public string CUSTOMdata { get; set; } = "{}";


			public byte DurabilityPercent { get; set; }

			public uint TimeStamp { get; set; }

			public string Currency { get; set; } = "Coins";


			public string ItemName
			{
				get
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(ItemPrefab);
					if (prefab == null)
					{
						return ItemPrefab;
					}
					return prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				}
			}

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(_id);
				pkg.Write(ItemPrefab ?? "");
				pkg.Write(Count);
				pkg.Write(Price);
				pkg.Write(SellerName ?? "");
				pkg.Write(SellerUserID ?? "");
				pkg.Write((int)ItemCategory);
				pkg.Write(Quality);
				pkg.Write(Variant);
				pkg.Write(CrafterName ?? "");
				pkg.Write(CrafterID);
				pkg.Write(CUSTOMdata ?? "{}");
				pkg.Write(DurabilityPercent);
				pkg.Write(TimeStamp);
				pkg.Write(string.IsNullOrWhiteSpace(Currency) ? "Coins" : Currency);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				_id = pkg.ReadInt();
				ItemPrefab = pkg.ReadString();
				Count = pkg.ReadInt();
				Price = pkg.ReadInt();
				SellerName = pkg.ReadString();
				SellerUserID = pkg.ReadString();
				ItemCategory = (Marketplace_DataTypes.ItemData_ItemCategory)pkg.ReadInt();
				Quality = pkg.ReadInt();
				Variant = pkg.ReadInt();
				CrafterName = pkg.ReadString();
				CrafterID = pkg.ReadLong();
				CUSTOMdata = pkg.ReadString();
				DurabilityPercent = pkg.ReadByte();
				TimeStamp = pkg.ReadUInt();
				Currency = pkg.ReadString();
			}

			public string LocalizeKey()
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(ItemPrefab);
				if (prefab == null)
				{
					return ItemPrefab;
				}
				return prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
			}

			public MarketSlot()
			{
			}

			public Marketplace_DataTypes.ClientMarketSendData ToClient()
			{
				return new Marketplace_DataTypes.ClientMarketSendData
				{
					ItemPrefab = ItemPrefab,
					Count = Count,
					Price = Price,
					SellerName = SellerName,
					ItemCategory = ItemCategory,
					Quality = Quality,
					Variant = Variant,
					CUSTOMdata = CUSTOMdata,
					CrafterName = CrafterName,
					CrafterID = CrafterID,
					DurabilityPercent = DurabilityPercent
				};
			}

			public MarketSlot(Marketplace_DataTypes.ClientMarketSendData other, string user)
			{
				ItemPrefab = other.ItemPrefab;
				Count = other.Count;
				Price = other.Price;
				SellerName = other.SellerName;
				SellerUserID = user;
				ItemCategory = other.ItemCategory;
				Quality = other.Quality;
				Variant = other.Variant;
				CUSTOMdata = other.CUSTOMdata;
				CrafterName = other.CrafterName;
				CrafterID = other.CrafterID;
				TimeStamp = (uint)ZNet.instance.m_netTime;
				DurabilityPercent = other.DurabilityPercent;
				Currency = other.Currency;
				if (string.IsNullOrWhiteSpace(Currency) || !Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(Currency)) || !Global_Configs.SyncedGlobalOptions.Value._possibleCurrencies.Contains(Currency))
				{
					Currency = Global_Configs.SyncedGlobalOptions.Value._possibleCurrencies[0];
				}
			}
		}

		public class CMS_User : ISerializableParameter
		{
			public int _id { get; set; }

			public string Name { get; set; }

			public string UserID { get; set; }

			public long LastOnline { get; set; }

			public bool IsOnline { get; set; }

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(Name ?? "");
				pkg.Write(UserID ?? "");
				pkg.Write(LastOnline);
				pkg.Write(IsOnline);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Name = pkg.ReadString();
				UserID = pkg.ReadString();
				LastOnline = pkg.ReadLong();
				IsOnline = pkg.ReadBool();
			}
		}

		public class CMS_Entry : ISerializableParameter
		{
			public int _id { get; set; }

			public string Owner { get; set; }

			public long Created { get; set; }

			public string Sender { get; set; }

			public string Topic { get; set; }

			public string Message { get; set; }

			public List<Marketplace_DataTypes.ClientMarketSendData> Attachments { get; set; }

			public List<Marketplace_DataTypes.ClientMarketSendData> Links { get; set; }

			public int ExpireAfterMinutes { get; set; } = 10800;


			public bool WasRead { get; set; }

			public bool AttachmentsTaken { get; set; }

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(_id);
				pkg.Write(Owner ?? "");
				pkg.Write(Created);
				pkg.Write(Sender ?? "");
				pkg.Write(Topic ?? "");
				pkg.Write(Message ?? "");
				if (Attachments != null)
				{
					pkg.Write(true);
					pkg.Write(JSON.ToJSON(Attachments));
				}
				else
				{
					pkg.Write(false);
				}
				if (Links != null)
				{
					pkg.Write(true);
					pkg.Write(JSON.ToJSON(Links));
				}
				else
				{
					pkg.Write(false);
				}
				pkg.Write(ExpireAfterMinutes);
				pkg.Write(WasRead);
				pkg.Write(AttachmentsTaken);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				_id = pkg.ReadInt();
				Owner = pkg.ReadString();
				Created = pkg.ReadLong();
				Sender = pkg.ReadString();
				Topic = pkg.ReadString();
				Message = pkg.ReadString();
				if (pkg.ReadBool())
				{
					Attachments = JSON.ToObject<List<Marketplace_DataTypes.ClientMarketSendData>>(pkg.ReadString());
				}
				if (pkg.ReadBool())
				{
					Links = JSON.ToObject<List<Marketplace_DataTypes.ClientMarketSendData>>(pkg.ReadString());
				}
				ExpireAfterMinutes = pkg.ReadInt();
				WasRead = pkg.ReadBool();
				AttachmentsTaken = pkg.ReadBool();
			}
		}

		public class BankSlot
		{
			public int _id { get; set; }

			public string Owner { get; set; }

			public int Prefab { get; set; }

			public int Amount { get; set; }
		}

		public class Player_Leaderboard
		{
			public Dictionary<string, int> KilledCreatures = new Dictionary<string, int>();

			public Dictionary<string, int> BuiltStructures = new Dictionary<string, int>();

			public Dictionary<string, int> ItemsCrafted = new Dictionary<string, int>();

			public Dictionary<string, int> KilledBy = new Dictionary<string, int>();

			public Dictionary<string, int> Harvested = new Dictionary<string, int>();

			public int _id { get; set; }

			public string Owner { get; set; }

			public float MapExplored { get; set; }

			public int DeathAmount { get; set; }

			public string PlayerName { get; set; }

			[BsonIgnore]
			public int KilledPlayers
			{
				get
				{
					if (!KilledCreatures.TryGetValue("Player", out var value))
					{
						return 0;
					}
					return value;
				}
			}
		}

		private static ConfigEntry<string> LiteDBPath;

		public static Marketplace_Context_LiteDB _context;

		private static string DBPATH;

		[UsedImplicitly]
		private static void OnInit()
		{
			LiteDBPath = ((BaseUnityPlugin)Marketplace._thistype).Config.Bind<string>("Database", "Database File Path", "", (ConfigDescription)null);
			DBPATH = (string.IsNullOrEmpty(LiteDBPath.Value) ? Market_Paths.DBFile : LiteDBPath.Value);
			BsonMapper.Global.EmptyStringToNull = false;
			BsonMapper.Global.IncludeFields = true;
			BsonMapper.Global.TrimWhitespace = false;
			_context = new Marketplace_Context_LiteDB();
		}
	}
}
namespace API
{
	[PublicAPI]
	public static class Marketplace_API
	{
		[Flags]
		public enum TerritoryFlags
		{
			None = 0,
			PushAway = 1,
			NoBuild = 2,
			NoPickaxe = 4,
			NoInteract = 8,
			NoAttack = 0x10,
			PvpOnly = 0x20,
			PveOnly = 0x40,
			PeriodicHeal = 0x80,
			PeriodicDamage = 0x100,
			IncreasedPlayerDamage = 0x200,
			IncreasedMonsterDamage = 0x400,
			NoMonsters = 0x800,
			CustomEnvironment = 0x1000,
			MoveSpeedMultiplier = 0x2000,
			NoDeathPenalty = 0x4000,
			NoPortals = 0x8000,
			PeriodicHealALL = 0x10000,
			ForceGroundHeight = 0x20000,
			ForceBiome = 0x40000,
			AddGroundHeight = 0x80000,
			NoBuildDamage = 0x100000,
			MonstersAddStars = 0x200000,
			InfiniteFuel = 0x400000,
			NoInteractItems = 0x800000,
			NoInteractCraftingStation = 0x1000000,
			NoInteractItemStands = 0x2000000,
			NoInteractChests = 0x4000000,
			NoInteractDoors = 0x8000000,
			NoStructureSupport = 0x10000000,
			NoInteractPortals = 0x20000000,
			CustomPaint = 0x40000000,
			LimitZoneHeight = int.MinValue
		}

		[Flags]
		public enum AdditionalTerritoryFlags
		{
			None = 0,
			NoItemLoss = 1,
			SnowMask = 2,
			NoMist = 4,
			InfiniteEitr = 8,
			InfiniteStamina = 0x10,
			DropMultiplier = 0x20,
			ForceWind = 0x40,
			GodMode = 0x80
		}

		public enum API_NPCType
		{
			None,
			Trader,
			Info,
			Teleporter,
			Feedback,
			Banker,
			Gambler,
			Quests,
			Buffer,
			Transmog,
			Marketplace
		}

		private static readonly bool _IsInstalled;

		private static readonly MethodInfo MI_IsPlayerInsideTerritory;

		private static readonly MethodInfo MI_IsObjectInsideTerritoryWithFlag;

		private static readonly MethodInfo MI_IsObjectInsideTerritoryWithFlag_Additional;

		private static readonly MethodInfo MI_ResetTraderItems;

		private static readonly MethodInfo MI_OpenQuestJournal;

		public static bool IsInstalled()
		{
			return _IsInstalled;
		}

		public static bool IsPlayerInsideTerritory(out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			flags = TerritoryFlags.None;
			additionalFlags = AdditionalTerritoryFlags.None;
			name = "";
			if (!_IsInstalled || MI_IsPlayerInsideTerritory == null)
			{
				return false;
			}
			object[] array = new object[3] { "", 0, 0 };
			bool result = (bool)MI_IsPlayerInsideTerritory.Invoke(null, array);
			name = (string)array[0];
			flags = (TerritoryFlags)array[1];
			additionalFlags = (AdditionalTerritoryFlags)array[2];
			return result;
		}

		public static bool IsObjectInsideTerritoryWithFlag(GameObject go, TerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return IsPointInsideTerritoryWithFlag(go.transform.position, flag, out name, out flags, out additionalFlags);
		}

		public static bool IsObjectInsideTerritoryWithFlag(GameObject go, AdditionalTerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return IsPointInsideTerritoryWithFlag(go.transform.position, flag, out name, out flags, out additionalFlags);
		}

		public static bool IsPointInsideTerritoryWithFlag(Vector3 pos, TerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			name = "";
			flags = TerritoryFlags.None;
			additionalFlags = AdditionalTerritoryFlags.None;
			if (!_IsInstalled || MI_IsObjectInsideTerritoryWithFlag == null)
			{
				return false;
			}
			object[] array = new object[5]
			{
				pos,
				(int)flag,
				"",
				0,
				0
			};
			bool result = (bool)MI_IsObjectInsideTerritoryWithFlag.Invoke(null, array);
			name = (string)array[2];
			flags = (TerritoryFlags)array[3];
			additionalFlags = (AdditionalTerritoryFlags)array[4];
			return result;
		}

		public static bool IsPointInsideTerritoryWithFlag(Vector3 pos, AdditionalTerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			name = "";
			flags = TerritoryFlags.None;
			additionalFlags = AdditionalTerritoryFlags.None;
			if (!_IsInstalled || MI_IsObjectInsideTerritoryWithFlag_Additional == null)
			{
				return false;
			}
			object[] array = new object[5]
			{
				pos,
				(int)flag,
				"",
				0,
				0
			};
			bool result = (bool)MI_IsObjectInsideTerritoryWithFlag_Additional.Invoke(null, array);
			name = (string)array[2];
			flags = (TerritoryFlags)array[3];
			additionalFlags = (AdditionalTerritoryFlags)array[4];
			return result;
		}

		public static void ResetTraderItems()
		{
			if (_IsInstalled && !(MI_ResetTraderItems == null))
			{
				MI_ResetTraderItems.Invoke(null, null);
			}
		}

		public static void OpenQuestJournal()
		{
			if (_IsInstalled && !(MI_OpenQuestJournal == null))
			{
				MI_OpenQuestJournal.Invoke(null, null);
			}
		}

		public static void SET_NPC_Type(this ZDO zdo, API_NPCType type)
		{
			zdo.Set("KGmarketNPC", (int)type);
		}

		public static void SET_NPC_Profile(this ZDO zdo, string profile)
		{
			zdo.Set("KGnpcProfile", profile);
		}

		public static void SET_NPC_Model(this ZDO zdo, string prefab)
		{
			zdo.Set("KGnpcModelOverride", prefab);
		}

		public static void SET_NPC_Name(this ZDO zdo, string name)
		{
			zdo.Set("KGnpcNameOverride", name);
		}

		public static void SET_NPC_Dialogue(this ZDO zdo, string dialogue)
		{
			zdo.Set("KGnpcDialogue", dialogue);
		}

		public static void SET_NPC_PatrolData(this ZDO zdo, string patrolData)
		{
			zdo.Set("KGmarket PatrolData", patrolData);
		}

		public static void SET_NPC_LeftItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGleftItem", prefab);
		}

		public static void SET_NPC_RightItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGrightItem", prefab);
		}

		public static void SET_NPC_HelmetItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGhelmetItem", prefab);
		}

		public static void SET_NPC_ChestItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGchestItem", prefab);
		}

		public static void SET_NPC_LegsItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGlegsItem", prefab);
		}

		public static void SET_NPC_CapeItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGcapeItem", prefab);
		}

		public static void SET_NPC_HairItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGhairItem", prefab);
		}

		public static void SET_NPC_HairColor(this ZDO zdo, string color)
		{
			zdo.Set("KGhairItemColor", color);
		}

		public static void SET_NPC_LeftItemBack(this ZDO zdo, string prefab)
		{
			zdo.Set("KGLeftItemBack", prefab);
		}

		public static void SET_NPC_RightItemBack(this ZDO zdo, string prefab)
		{
			zdo.Set("KGRightItemBack", prefab);
		}

		public static void SET_NPC_InteractAnimation(this ZDO zdo, string animation)
		{
			zdo.Set("KGinteractAnimation", animation);
		}

		public static void SET_NPC_GreetingAnimation(this ZDO zdo, string animation)
		{
			zdo.Set("KGgreetingAnimation", animation);
		}

		public static void SET_NPC_ByeAnimation(this ZDO zdo, string animation)
		{
			zdo.Set("KGbyeAnimation", animation);
		}

		public static void SET_NPC_GreetingText(this ZDO zdo, string text)
		{
			zdo.Set("KGgreetingText", text);
		}

		public static void SET_NPC_ByeText(this ZDO zdo, string text)
		{
			zdo.Set("KGbyeText", text);
		}

		public static void SET_NPC_SkinColor(this ZDO zdo, string color)
		{
			zdo.Set("KGskinColor", color);
		}

		public static void SET_NPC_CraftingAnimation(this ZDO zdo, string animation)
		{
			zdo.Set("KGcraftingAnimation", animation);
		}

		public static void SET_NPC_BeardItem(this ZDO zdo, string prefab)
		{
			zdo.Set("KGbeardItem", prefab);
		}

		public static void SET_NPC_BeardColor(this ZDO zdo, string color)
		{
			zdo.Set("KGbeardColor", color);
		}

		public static void SET_NPC_InteractSound(this ZDO zdo, string sound)
		{
			zdo.Set("KGinteractSound", sound);
		}

		public static void SET_NPC_TextSize(this ZDO zdo, string size)
		{
			zdo.Set("KGtextSize", float.TryParse(size, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result) ? result : 3f);
		}

		public static void SET_NPC_TextHeight(this ZDO zdo, string height)
		{
			zdo.Set("KGtextHeight", float.TryParse(height, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result) ? result : 0f);
		}

		public static void SET_NPC_PeriodicAnimation(this ZDO zdo, string animation)
		{
			zdo.Set("KGperiodicAnimation", animation);
		}

		public static void SET_NPC_PeriodicAnimationTime(this ZDO zdo, string time)
		{
			zdo.Set("KGperiodicAnimationTime", float.TryParse(time, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result) ? result : 0f);
		}

		public static void SET_NPC_PeriodicSound(this ZDO zdo, string sound)
		{
			zdo.Set("KGperiodicSound", sound);
		}

		public static void SET_NPC_PeriodicSoundTime(this ZDO zdo, string time)
		{
			zdo.Set("KGperiodicSoundTime", float.TryParse(time, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result) ? result : 0f);
		}

		public static void SET_NPC_NPCScale(this ZDO zdo, string scale)
		{
			zdo.Set("KGnpcScale", float.TryParse(scale, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result) ? result : 1f);
		}

		public static void SET_NPC_IsPinned(this ZDO zdo, bool pinned)
		{
			zdo.Set("KGmarketPinned", pinned);
		}

		public static void SET_NPC_PinIcon(this ZDO zdo, string pinIcon)
		{
			zdo.Set("KGmarketPinIcon", string.IsNullOrWhiteSpace(pinIcon) ? "" : pinIcon);
		}

		public static API_NPCType GET_NPC_Type(this ZDO zdo)
		{
			return (API_NPCType)zdo.GetInt("KGmarketNPC", 0);
		}

		public static string GET_NPC_Profile(this ZDO zdo)
		{
			return zdo.GetString("KGnpcProfile", "default");
		}

		public static string GET_NPC_Model(this ZDO zdo)
		{
			return zdo.GetString("KGnpcModelOverride", "");
		}

		public static string GET_NPC_Name(this ZDO zdo)
		{
			return zdo.GetString("KGnpcNameOverride", "");
		}

		public static string GET_NPC_Dialogue(this ZDO zdo)
		{
			return zdo.GetString("KGnpcDialogue", "");
		}

		public static string GET_NPC_PatrolData(this ZDO zdo)
		{
			return zdo.GetString("KGmarket PatrolData", "");
		}

		public static bool GET_NPC_IsPinned(this ZDO zdo)
		{
			return zdo.GetBool("KGmarketPinned", false);
		}

		public static string GET_NPC_PinIcon(this ZDO zdo)
		{
			return zdo.GetString("KGmarketPinIcon", "");
		}

		public static string GET_NPC_LeftItem(this ZDO zdo)
		{
			return zdo.GetString("KGleftItem", "");
		}

		public static string GET_NPC_RightItem(this ZDO zdo)
		{
			return zdo.GetString("KGrightItem", "");
		}

		public static string GET_NPC_HelmetItem(this ZDO zdo)
		{
			return zdo.GetString("KGhelmetItem", "");
		}

		public static string GET_NPC_ChestItem(this ZDO zdo)
		{
			return zdo.GetString("KGchestItem", "");
		}

		public static string GET_NPC_LegsItem(this ZDO zdo)
		{
			return zdo.GetString("KGlegsItem", "");
		}

		public static string GET_NPC_CapeItem(this ZDO zdo)
		{
			return zdo.GetString("KGcapeItem", "");
		}

		public static string GET_NPC_HairItem(this ZDO zdo)
		{
			return zdo.GetString("KGhairItem", "");
		}

		public static string GET_NPC_HairColor(this ZDO zdo)
		{
			return zdo.GetString("KGhairItemColor", "");
		}

		public static string GET_NPC_LeftItemBack(this ZDO zdo)
		{
			return zdo.GetString("KGLeftItemBack", "");
		}

		public static string GET_NPC_RightItemBack(this ZDO zdo)
		{
			return zdo.GetString("KGRightItemBack", "");
		}

		public static string GET_NPC_InteractAnimation(this ZDO zdo)
		{
			return zdo.GetString("KGinteractAnimation", "");
		}

		public static string GET_NPC_GreetingAnimation(this ZDO zdo)
		{
			return zdo.GetString("KGgreetingAnimation", "");
		}

		public static string GET_NPC_ByeAnimation(this ZDO zdo)
		{
			return zdo.GetString("KGbyeAnimation", "");
		}

		public static string GET_NPC_GreetingText(this ZDO zdo)
		{
			return zdo.GetString("KGgreetingText", "");
		}

		public static string GET_NPC_ByeText(this ZDO zdo)
		{
			return zdo.GetString("KGbyeText", "");
		}

		public static string GET_NPC_SkinColor(this ZDO zdo)
		{
			return zdo.GetString("KGskinColor", "");
		}

		public static string GET_NPC_CraftingAnimation(this ZDO zdo)
		{
			return zdo.GetString("KGcraftingAnimation", "");
		}

		public static string GET_NPC_BeardItem(this ZDO zdo)
		{
			return zdo.GetString("KGbeardItem", "");
		}

		public static string GET_NPC_BeardColor(this ZDO zdo)
		{
			return zdo.GetString("KGbeardColor", "");
		}

		public static string GET_NPC_InteractSound(this ZDO zdo)
		{
			return zdo.GetString("KGinteractSound", "");
		}

		public static float GET_NPC_TextSize(this ZDO zdo)
		{
			return zdo.GetFloat("KGtextSize", 3f);
		}

		public static float GET_NPC_TextHeight(this ZDO zdo)
		{
			return zdo.GetFloat("KGtextHeight", 0f);
		}

		public static string GET_NPC_PeriodicAnimation(this ZDO zdo)
		{
			return zdo.GetString("KGperiodicAnimation", "");
		}

		public static float GET_NPC_PeriodicAnimationTime(this ZDO zdo)
		{
			return zdo.GetFloat("KGperiodicAnimationTime", 0f);
		}

		public static string GET_NPC_PeriodicSound(this ZDO zdo)
		{
			return zdo.GetString("KGperiodicSound", "");
		}

		public static float GET_NPC_PeriodicSoundTime(this ZDO zdo)
		{
			return zdo.GetFloat("KGperiodicSoundTime", 0f);
		}

		public static float GET_NPC_NPCScale(this ZDO zdo)
		{
			return zdo.GetFloat("KGnpcScale", 1f);
		}

		static Marketplace_API()
		{
			Type type = Type.GetType("API.ClientSide, kg.Marketplace");
			if ((object)type == null)
			{
				_IsInstalled = false;
				return;
			}
			_IsInstalled = true;
			MI_IsPlayerInsideTerritory = type.GetMethod("IsPlayerInsideTerritory", BindingFlags.Static | BindingFlags.Public);
			MI_IsObjectInsideTerritoryWithFlag = type.GetMethod("IsObjectInsideTerritoryWithFlag", BindingFlags.Static | BindingFlags.Public);
			MI_IsObjectInsideTerritoryWithFlag_Additional = type.GetMethod("IsObjectInsideTerritoryWithFlag_Additional", BindingFlags.Static | BindingFlags.Public);
			MI_ResetTraderItems = type.GetMethod("ResetTraderItems", BindingFlags.Static | BindingFlags.Public);
			MI_OpenQuestJournal = type.GetMethod("OpenQuestJournal", BindingFlags.Static | BindingFlags.Public);
		}
	}
	public static class ClientSide
	{
		public static bool FillingTerritoryData;

		public static void ResetTraderItems()
		{
			Trader_Main_Client.InitTraderItems();
			Gambler_Main_Client.GamblerInit();
			Transmogrification_Main_Client.InitTransmogData();
		}

		public static void OpenQuestJournal()
		{
			Quests_UIs.QuestUI.ClickJournal();
		}

		public static bool IsPlayerInsideTerritory(out string name, out int flags, out int additionalFlags)
		{
			if (TerritorySystem_Main_Client.CurrentTerritory != null)
			{
				name = TerritorySystem_Main_Client.CurrentTerritory.Name;
				flags = (int)TerritorySystem_Main_Client.CurrentTerritory.Flags;
				additionalFlags = (int)TerritorySystem_Main_Client.CurrentTerritory.AdditionalFlags;
				return true;
			}
			name = "";
			flags = 0;
			additionalFlags = 0;
			return false;
		}

		public static bool IsObjectInsideTerritoryWithFlag(Vector3 pos, int flag, out string name, out int flags, out int additionalFlags)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			foreach (TerritorySystem_DataTypes.Territory item in TerritorySystem_Main_Client.TerritoriesByFlags[(TerritorySystem_DataTypes.TerritoryFlags)flag])
			{
				if (item.IsInside(pos))
				{
					name = item.Name;
					flags = (int)item.Flags;
					additionalFlags = (int)item.AdditionalFlags;
					return true;
				}
			}
			name = "";
			flags = 0;
			additionalFlags = 0;
			return false;
		}

		public static bool IsObjectInsideTerritoryWithFlag_Additional(Vector3 pos, int flag, out string name, out int flags, out int additionalFlags)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			foreach (TerritorySystem_DataTypes.Territory item in TerritorySystem_Main_Client.TerritoriesByFlags_Additional[(TerritorySystem_DataTypes.AdditionalTerritoryFlags)flag])
			{
				if (item.IsInside(pos))
				{
					name = item.Name;
					flags = (int)item.Flags;
					additionalFlags = (int)item.AdditionalFlags;
					return true;
				}
			}
			name = "";
			flags = 0;
			additionalFlags = 0;
			return false;
		}
	}
}
[CompilerGenerated]
internal sealed class <d5594bdc-b525-4196-ada5-7f762636b0b9><PrivateImplementationDetails>
{
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 20)]
	internal struct __StaticArrayInitTypeSize=20
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 40)]
	internal struct __StaticArrayInitTypeSize=40
	{
	}

	internal static readonly __StaticArrayInitTypeSize=40 3C302C66759EFBAC718FA13855DEACAE39604DE093A35E5782C5750E161A8033/* Not supported: data(31 00 00 00 32 00 00 00 33 00 00 00 34 00 00 00 35 00 00 00 36 00 00 00 37 00 00 00 38 00 00 00 39 00 00 00 30 00 00 00) */;

	internal static readonly __StaticArrayInitTypeSize=20 8AE2A715C9FE74FAC37164DCA1C79F14560E6D4CACFD5CF96D24A32162350F84/* Not supported: data(08 00 00 00 10 00 00 00 00 02 00 00 1F 00 00 00 E0 00 00 00) */;

	internal static void ThrowInvalidOperationException()
	{
		throw new InvalidOperationException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

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

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(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();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	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();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace fastJSON
{
	internal class DynamicJson : DynamicObject, IEnumerable
	{
		private IDictionary<string, object> _dictionary { get; set; }

		private List<object> _list { get; set; }

		public DynamicJson(string json)
		{
			object obj = JSON.Parse(json);
			if (obj is IDictionary<string, object>)
			{
				_dictionary = (IDictionary<string, object>)obj;
			}
			else
			{
				_list = (List<object>)obj;
			}
		}

		private DynamicJson(object dictionary)
		{
			if (dictionary is IDictionary<string, object>)
			{
				_dictionary = (IDictionary<string, object>)dictionary;
			}
		}

		public override IEnumerable<string> GetDynamicMemberNames()
		{
			return _dictionary.Keys.ToList();
		}

		public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
		{
			object obj = indexes[0];
			if (obj is int)
			{
				result = _list[(int)obj];
			}
			else
			{
				result = _dictionary[(string)obj];
			}
			if (result is IDictionary<string, object>)
			{
				result = new DynamicJson(result as IDictionary<string, object>);
			}
			return true;
		}

		public override bool TryGetMember(GetMemberBinder binder, out object result)
		{
			if (!_dictionary.TryGetValue(binder.Name, out result) && !_dictionary.TryGetValue(binder.Name.ToLowerInvariant(), out result))
			{
				return false;
			}
			if (result is IDictionary<string, object>)
			{
				result = new DynamicJson(result as IDictionary<string, object>);
			}
			else if (result is List<object>)
			{
				List<object> list = new List<object>();
				foreach (object item in (List<object>)result)
				{
					if (item is IDictionary<string, object>)
					{
						list.Add(new DynamicJson(item as IDictionary<string, object>));
					}
					else
					{
						list.Add(item);
					}
				}
				result = list;
			}
			return _dictionary.ContainsKey(binder.Name);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			foreach (object item in _list)
			{
				yield return new DynamicJson(item as IDictionary<string, object>);
			}
		}
	}
	internal sealed class DatasetSchema
	{
		public List<string> Info;

		public string Name;
	}
	internal class DataMemberAttribute : Attribute
	{
		public string Name { get; set; }
	}
	internal static class Formatter
	{
		private static void AppendIndent(StringBuilder sb, int count, string indent)
		{
			while (count > 0)
			{
				sb.Append(indent);
				count--;
			}
		}

		public static string PrettyPrint(string input)
		{
			return PrettyPrint(input, new string(' ', JSON.Parameters.FormatterIndentSpaces));
		}

		public static string PrettyPrint(string input, string spaces)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			int length = input.Length;
			char[] array = input.ToCharArray();
			for (int i = 0; i < length; i++)
			{
				char c = array[i];
				if (c == '"')
				{
					bool flag = true;
					while (flag)
					{
						stringBuilder.Append(c);
						c = array[++i];
						switch (c)
						{
						case '\\':
							stringBuilder.Append(c);
							c = array[++i];
							break;
						case '"':
							flag = false;
							break;
						}
					}
				}
				switch (c)
				{
				case '[':
				case '{':
					stringBuilder.Append(c);
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, ++num, spaces);
					break;
				case ']':
				case '}':
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, --num, spaces);
					stringBuilder.Append(c);
					break;
				case ',':
					stringBuilder.Append(c);
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, num, spaces);
					break;
				case ':':
					stringBuilder.Append(" : ");
					break;
				default:
					if (!char.IsWhiteSpace(c))
					{
						stringBuilder.Append(c);
					}
					break;
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal class Helper
	{
		public static bool IsNullable(Type t)
		{
			if (!t.IsGenericType)
			{
				return false;
			}
			Type genericTypeDefinition = t.GetGenericTypeDefinition();
			return genericTypeDefinition.Equals(typeof(Nullable<>));
		}

		public static Type UnderlyingTypeOf(Type t)
		{
			return Reflection.Instance.GetGenericArguments(t)[0];
		}

		public static DateTimeOffset CreateDateTimeOffset(int year, int month, int day, int hour, int min, int sec, int milli, int extraTicks, TimeSpan offset)
		{
			DateTimeOffset dateTimeOffset = new DateTimeOffset(year, month, day, hour, min, sec, milli, offset);
			if (extraTicks > 0)
			{
				return dateTimeOffset + TimeSpan.FromTicks(extraTicks);
			}
			return dateTimeOffset;
		}

		public static bool BoolConv(object v)
		{
			bool result = false;
			if (v is bool)
			{
				result = (bool)v;
			}
			else if (v is long)
			{
				result = (((long)v > 0) ? true : false);
			}
			else if (v is string)
			{
				string text = (string)v;
				switch (text.ToLowerInvariant())
				{
				case "1":
				case "true":
				case "yes":
				case "on":
					result = true;
					break;
				}
			}
			return result;
		}

		public static long AutoConv(object value, JSONParameters param)
		{
			if (value is string)
			{
				if (param.AutoConvertStringToNumbers)
				{
					string text = (string)value;
					return CreateLong(text, 0, text.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (value is long)
			{
				return (long)value;
			}
			return Convert.ToInt64(value);
		}

		public unsafe static long CreateLong(string s, int index, int count)
		{
			long num = 0L;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public unsafe static long CreateLong(char[] s, int index, int count)
		{
			long num = 0L;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public unsafe static int CreateInteger(string s, int index, int count)
		{
			int num = 0;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public static object CreateEnum(Type pt, object v)
		{
			return Enum.Parse(pt, v.ToString(), ignoreCase: true);
		}

		public static Guid CreateGuid(string s)
		{
			if (s.Length > 30)
			{
				return new Guid(s);
			}
			return new Guid(Convert.FromBase64String(s));
		}

		public static StringDictionary CreateSD(Dictionary<string, object> d)
		{
			StringDictionary stringDictionary = new StringDictionary();
			foreach (KeyValuePair<string, object> item in d)
			{
				stringDictionary.Add(item.Key, (string)item.Value);
			}
			return stringDictionary;
		}

		public static NameValueCollection CreateNV(Dictionary<string, object> d)
		{
			NameValueCollection nameValueCollection = new NameValueCollection();
			foreach (KeyValuePair<string, object> item in d)
			{
				nameValueCollection.Add(item.Key, (string)item.Value);
			}
			return nameValueCollection;
		}

		public static object CreateDateTimeOffset(string value)
		{
			int milli = 0;
			int extraTicks = 0;
			int num = 0;
			int num2 = 0;
			int year = CreateInteger(value, 0, 4);
			int month = CreateInteger(value, 5, 2);
			int day = CreateInteger(value, 8, 2);
			int hour = CreateInteger(value, 11, 2);
			int min = CreateInteger(value, 14, 2);
			int sec = CreateInteger(value, 17, 2);
			int num3 = 20;
			if (value.Length > 21 && value[19] == '.')
			{
				milli = CreateInteger(value, num3, 3);
				num3 = 23;
				if (value.Length > 25 && char.IsDigit(value[num3]))
				{
					extraTicks = CreateInteger(value, num3, 4);
					num3 = 27;
				}
			}
			if (value[num3] == 'Z')
			{
				return CreateDateTimeOffset(year, month, day, hour, min, sec, milli, extraTicks, TimeSpan.Zero);
			}
			if (value[num3] == ' ')
			{
				num3++;
			}
			num = CreateInteger(value, num3 + 1, 2);
			num2 = CreateInteger(value, num3 + 1 + 2 + 1, 2);
			if (value[num3] == '-')
			{
				num = -num;
			}
			return CreateDateTimeOffset(year, month, day, hour, min, sec, milli, extraTicks, new TimeSpan(num, num2, 0));
		}

		public static DateTime CreateDateTime(string value, bool UseUTCDateTime)
		{
			if (value.Length < 19)
			{
				return DateTime.MinValue;
			}
			bool flag = false;
			int millisecond = 0;
			int year = CreateInteger(value, 0, 4);
			int month = CreateInteger(value, 5, 2);
			int day = CreateInteger(value, 8, 2);
			int hour = CreateInteger(value, 11, 2);
			int minute = CreateInteger(value, 14, 2);
			int second = CreateInteger(value, 17, 2);
			if (value.Length > 21 && value[19] == '.')
			{
				millisecond = CreateInteger(value, 20, 3);
			}
			if (value[value.Length - 1] == 'Z')
			{
				flag = true;
			}
			if (!UseUTCDateTime && !flag)
			{
				return new DateTime(year, month, day, hour, minute, second, millisecond);
			}
			return new DateTime(year, month, day, hour, minute, second, millisecond, DateTimeKind.Utc).ToLocalTime();
		}
	}
	internal sealed class JSONSerializer
	{
		private StringBuilder _output = new StringBuilder();

		private int _before;

		private int _MAX_DEPTH = 20;

		private int _current_depth;

		private Dictionary<string, int> _globalTypes = new Dictionary<string, int>();

		private Dictionary<object, int> _cirobj;

		private JSONParameters _params;

		private bool _useEscapedUnicode;

		private bool _TypesWritten;

		internal JSONSerializer(JSONParameters param)
		{
			if (param.OverrideObjectHashCodeChecking)
			{
				_cirobj = new Dictionary<object, int>(10, ReferenceEqualityComparer.Default);
			}
			else
			{
				_cirobj = new Dictionary<object, int>();
			}
			_params = param;
			_useEscapedUnicode = _params.UseEscapedUnicode;
			_MAX_DEPTH = _params.SerializerMaxDepth;
		}

		internal string ConvertToJSON(object obj)
		{
			WriteValue(obj);
			if (_params.UsingGlobalTypes && _globalTypes != null && _globalTypes.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("\"$types\":{");
				bool flag = false;
				foreach (KeyValuePair<string, int> globalType in _globalTypes)
				{
					if (flag)
					{
						stringBuilder.Append(',');
					}
					flag = true;
					stringBuilder.Append('"');
					stringBuilder.Append(globalType.Key);
					stringBuilder.Append("\":\"");
					stringBuilder.Append(globalType.Value);
					stringBuilder.Append('"');
				}
				stringBuilder.Append("},");
				_output.Insert(_before, stringBuilder.ToString());
			}
			return _output.ToString();
		}

		private void WriteValue(object obj)
		{
			if (obj == null || obj is DBNull)
			{
				_output.Append("null");
			}
			else if (obj is string || obj is char)
			{
				WriteString(obj.ToString());
			}
			else if (obj is Guid)
			{
				WriteGuid((Guid)obj);
			}
			else if (obj is bool)
			{
				_output.Append(((bool)obj) ? "true" : "false");
			}
			else if (obj is int || obj is long || obj is decimal || obj is byte || obj is short || obj is sbyte || obj is ushort || obj is uint || obj is ulong)
			{
				_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
			}
			else if (obj is double || obj is double)
			{
				double d = (double)obj;
				if (double.IsNaN(d))
				{
					_output.Append("\"NaN\"");
				}
				else if (double.IsInfinity(d))
				{
					_output.Append('"');
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
					_output.Append('"');
				}
				else
				{
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
				}
			}
			else if (obj is float || obj is float)
			{
				float f = (float)obj;
				if (float.IsNaN(f))
				{
					_output.Append("\"NaN\"");
				}
				else if (float.IsInfinity(f))
				{
					_output.Append('"');
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
					_output.Append('"');
				}
				else
				{
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
				}
			}
			else if (obj is DateTime)
			{
				WriteDateTime((DateTime)obj);
			}
			else if (obj is DateTimeOffset)
			{
				WriteDateTimeOffset((DateTimeOffset)obj);
			}
			else if (obj is TimeSpan)
			{
				_output.Append(((TimeSpan)obj).Ticks);
			}
			else if (!_params.KVStyleStringDictionary && obj is IEnumerable<KeyValuePair<string, object>>)
			{
				WriteStringDictionary((IEnumerable<KeyValuePair<string, object>>)obj);
			}
			else if (!_params.KVStyleStringDictionary && obj is IDictionary && obj.GetType().IsGenericType && Reflection.Instance.GetGenericArguments(obj.GetType())[0] == typeof(string))
			{
				WriteStringDictionary((IDictionary)obj);
			}
			else if (obj is IDictionary)
			{
				WriteDictionary((IDictionary)obj);
			}
			else if (obj is byte[])
			{
				WriteBytes((byte[])obj);
			}
			else if (obj is StringDictionary)
			{
				WriteSD((StringDictionary)obj);
			}
			else if (obj is NameValueCollection)
			{
				WriteNV((NameValueCollection)obj);
			}
			else if (obj is Array)
			{
				WriteArrayRanked((Array)obj);
			}
			else if (obj is IEnumerable)
			{
				WriteArray((IEnumerable)obj);
			}
			else if (obj is Enum)
			{
				WriteEnum((Enum)obj);
			}
			else if (Reflection.Instance.IsTypeRegistered(obj.GetType()))
			{
				WriteCustom(obj);
			}
			else
			{
				WriteObject(obj);
			}
		}

		private void WriteDateTimeOffset(DateTimeOffset d)
		{
			DateTime dt = (_params.UseUTCDateTime ? d.UtcDateTime : d.DateTime);
			write_date_value(dt);
			long num = dt.Ticks % 10000000;
			_output.Append('.');
			_output.Append(num.ToString("0000000", NumberFormatInfo.InvariantInfo));
			if (_params.UseUTCDateTime)
			{
				_output.Append('Z');
			}
			else
			{
				if (d.Offset.Hours > 0)
				{
					_output.Append('+');
				}
				else
				{
					_output.Append('-');
				}
				_output.Append(d.Offset.Hours.ToString("00", NumberFormatInfo.InvariantInfo));
				_output.Append(':');
				_output.Append(d.Offset.Minutes.ToString("00", NumberFormatInfo.InvariantInfo));
			}
			_output.Append('"');
		}

		private void WriteNV(NameValueCollection nameValueCollection)
		{
			_output.Append('{');
			bool flag = false;
			foreach (string item in nameValueCollection)
			{
				if (_params.SerializeNullValues || nameValueCollection[item] != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(item.ToLowerInvariant(), nameValueCollection[item]);
					}
					else
					{
						WritePair(item, nameValueCollection[item]);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteSD(StringDictionary stringDictionary)
		{
			_output.Append('{');
			bool flag = false;
			foreach (DictionaryEntry item in stringDictionary)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string text = (string)item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(text.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(text, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteCustom(object obj)
		{
			Reflection.Instance._customSerializer.TryGetValue(obj.GetType(), out var value);
			WriteStringFast(value(obj));
		}

		private void WriteEnum(Enum e)
		{
			if (_params.UseValuesOfEnums)
			{
				WriteValue(Convert.ToInt32(e));
			}
			else
			{
				WriteStringFast(e.ToString());
			}
		}

		private void WriteGuid(Guid g)
		{
			if (!_params.UseFastGuid)
			{
				WriteStringFast(g.ToString());
			}
			else
			{
				WriteBytes(g.ToByteArray());
			}
		}

		private void WriteBytes(byte[] bytes)
		{
			WriteStringFast(Convert.ToBase64String(bytes, 0, bytes.Length, Base64FormattingOptions.None));
		}

		private void WriteDateTime(DateTime dateTime)
		{
			DateTime dt = dateTime;
			if (_params.UseUTCDateTime)
			{
				dt = dateTime.ToUniversalTime();
			}
			write_date_value(dt);
			if (_params.DateTimeMilliseconds)
			{
				_output.Append('.');
				_output.Append(dt.Millisecond.ToString("000", NumberFormatInfo.InvariantInfo));
			}
			if (_params.UseUTCDateTime)
			{
				_output.Append('Z');
			}
			_output.Append('"');
		}

		private void write_date_value(DateTime dt)
		{
			_output.Append('"');
			_output.Append(dt.Year.ToString("0000", NumberFormatInfo.InvariantInfo));
			_output.Append('-');
			_output.Append(dt.Month.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append('-');
			_output.Append(dt.Day.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append('T');
			_output.Append(dt.Hour.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append(':');
			_output.Append(dt.Minute.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append(':');
			_output.Append(dt.Second.ToString("00", NumberFormatInfo.InvariantInfo));
		}

		private void WriteObject(object obj)
		{
			int value = 0;
			if (!_cirobj.TryGetValue(obj, out value))
			{
				_cirobj.Add(obj, _cirobj.Count + 1);
			}
			else if (_current_depth > 0 && !_params.InlineCircularReferences)
			{
				_output.Append("{\"$i\":");
				_output.Append(value.ToString());
				_output.Append('}');
				return;
			}
			if (!_params.UsingGlobalTypes)
			{
				_output.Append('{');
			}
			else if (!_TypesWritten)
			{
				_output.Append('{');
				_before = _output.Length;
			}
			else
			{
				_output.Append('{');
			}
			_TypesWritten = true;
			_current_depth++;
			if (_current_depth > _MAX_DEPTH)
			{
				throw new Exception("Serializer encountered maximum depth of " + _MAX_DEPTH);
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			Type type = obj.GetType();
			bool flag = false;
			if (_params.UseExtensions)
			{
				if (!_params.UsingGlobalTypes)
				{
					WritePairFast("$type", Reflection.Instance.GetTypeAssemblyName(type));
				}
				else
				{
					int value2 = 0;
					string typeAssemblyName = Reflection.Instance.GetTypeAssemblyName(type);
					if (!_globalTypes.TryGetValue(typeAssemblyName, out value2))
					{
						value2 = _globalTypes.Count + 1;
						_globalTypes.Add(typeAssemblyName, value2);
					}
					WritePairFast("$type", value2.ToString());
				}
				flag = true;
			}
			Getters[] getters = Reflection.Instance.GetGetters(type, _params.IgnoreAttributes);
			int num = getters.Length;
			for (int i = 0; i < num; i++)
			{
				Getters getters2 = getters[i];
				if (!_params.ShowReadOnlyProperties && getters2.ReadOnly)
				{
					continue;
				}
				object obj2 = getters2.Getter(obj);
				if (!_params.SerializeNullValues && (obj2 == null || obj2 is DBNull))
				{
					continue;
				}
				if (flag)
				{
					_output.Append(',');
				}
				if (getters2.memberName != null)
				{
					WritePair(getters2.memberName, obj2);
				}
				else if (_params.SerializeToLowerCaseNames)
				{
					WritePair(getters2.lcName, obj2);
				}
				else
				{
					WritePair(getters2.Name, obj2);
				}
				if (obj2 != null && _params.UseExtensions)
				{
					Type type2 = obj2.GetType();
					if (type2 == typeof(object))
					{
						dictionary.Add(getters2.Name, type2.ToString());
					}
				}
				flag = true;
			}
			if (dictionary.Count > 0 && _params.UseExtensions)
			{
				_output.Append(",\"$map\":");
				WriteStringDictionary(dictionary);
			}
			_output.Append('}');
			_current_depth--;
		}

		private void WritePairFast(string name, string value)
		{
			WriteStringFast(name);
			_output.Append(':');
			WriteStringFast(value);
		}

		private void WritePair(string name, object value)
		{
			WriteString(name);
			_output.Append(':');
			WriteValue(value);
		}

		private void WriteArray(IEnumerable array)
		{
			_output.Append('[');
			bool flag = false;
			foreach (object item in array)
			{
				if (flag)
				{
					_output.Append(',');
				}
				WriteValue(item);
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteArrayRanked(Array array)
		{
			if (array.Rank == 1)
			{
				WriteArray(array);
				return;
			}
			_output.Append('[');
			bool flag = false;
			foreach (object item in array)
			{
				if (flag)
				{
					_output.Append(',');
				}
				WriteValue(item);
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteStringDictionary(IDictionary dic)
		{
			_output.Append('{');
			bool flag = false;
			foreach (DictionaryEntry item in dic)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string text = (string)item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(text.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(text, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteStringDictionary(IEnumerable<KeyValuePair<string, object>> dic)
		{
			_output.Append('{');
			bool flag = false;
			foreach (KeyValuePair<string, object> item in dic)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string key = item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(key.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(key, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteDictionary(IDictionary dic)
		{
			_output.Append('[');
			bool flag = false;
			foreach (DictionaryEntry item in dic)
			{
				if (flag)
				{
					_output.Append(',');
				}
				_output.Append('{');
				WritePair("k", item.Key);
				_output.Append(',');
				WritePair("v", item.Value);
				_output.Append('}');
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteStringFast(string s)
		{
			_output.Append('"');
			_output.Append(s);
			_output.Append('"');
		}

		private void WriteString(string s)
		{
			_output.Append('"');
			int num = -1;
			int length = s.Length;
			for (int i = 0; i < length; i++)
			{
				char c = s[i];
				if (_useEscapedUnicode)
				{
					if (c >= ' ' && c < '\u0080' && c != '"' && c != '\\')
					{
						if (num == -1)
						{
							num = i;
						}
						continue;
					}
				}
				else if (c != '\t' && c != '\n' && c != '\r' && c != '"' && c != '\\' && c != 0)
				{
					if (num == -1)
					{
						num = i;
					}
					continue;
				}
				if (num != -1)
				{
					_output.Append(s, num, i - num);
					num = -1;
				}
				switch (c)
				{
				case '\t':
					_output.Append('\\').Append('t');
					continue;
				case '\r':
					_output.Append('\\').Append('r');
					continue;
				case '\n':
					_output.Append('\\').Append('n');
					continue;
				case '"':
				case '\\':
					_output.Append('\\');
					_output.Append(c);
					continue;
				case '\0':
					_output.Append("\\u0000");
					continue;
				}
				if (_useEscapedUnicode)
				{
					_output.Append("\\u");
					StringBuilder output = _output;
					int num2 = c;
					output.Append(num2.ToString("X4", NumberFormatInfo.InvariantInfo));
				}
				else
				{
					_output.Append(c);
				}
			}
			if (num != -1)
			{
				_output.Append(s, num, s.Length - num);
			}
			_output.Append('"');
		}
	}
	internal sealed class JSONParameters
	{
		public bool UseOptimizedDatasetSchema = true;

		public bool UseFastGuid = true;

		public bool SerializeNullValues = true;

		public bool UseUTCDateTime = true;

		public bool ShowReadOnlyProperties;

		public bool UsingGlobalTypes = true;

		[Obsolete("Not needed anymore and will always match")]
		public bool IgnoreCaseOnDeserialize;

		public bool EnableAnonymousTypes;

		public bool UseExtensions = true;

		public bool UseEscapedUnicode = true;

		public bool KVStyleStringDictionary;

		public bool UseValuesOfEnums;

		public List<Type> IgnoreAttributes = new List<Type>
		{
			typeof(XmlIgnoreAttribute),
			typeof(NonSerializedAttribute)
		};

		public bool ParametricConstructorOverride;

		public bool DateTimeMilliseconds;

		public byte SerializerMaxDepth = 20;

		public bool InlineCircularReferences;

		public bool SerializeToLowerCaseNames;

		public byte FormatterIndentSpaces = 3;

		public bool AllowNonQuotedKeys;

		public bool AutoConvertStringToNumbers = true;

		public bool OverrideObjectHashCodeChecking;

		[Obsolete("Racist term removed, please use BadListTypeChecking")]
		public bool BlackListTypeChecking = true;

		public bool BadListTypeChecking = true;

		public bool FullyQualifiedDataSetSchema;

		public void FixValues()
		{
			if (!UseExtensions)
			{
				UsingGlobalTypes = false;
				InlineCircularReferences = true;
			}
			if (EnableAnonymousTypes)
			{
				ShowReadOnlyProperties = true;
			}
		}

		public JSONParameters MakeCopy()
		{
			return new JSONParameters
			{
				AllowNonQuotedKeys = AllowNonQuotedKeys,
				DateTimeMilliseconds = DateTimeMilliseconds,
				EnableAnonymousTypes = EnableAnonymousTypes,
				FormatterIndentSpaces = FormatterIndentSpaces,
				IgnoreAttributes = new List<Type>(IgnoreAttributes),
				InlineCircularReferences = InlineCircularReferences,
				KVStyleStringDictionary = KVStyleStringDictionary,
				ParametricConstructorOverride = ParametricConstructorOverride,
				SerializeNullValues = SerializeNullValues,
				SerializerMaxDepth = SerializerMaxDepth,
				SerializeToLowerCaseNames = SerializeToLowerCaseNames,
				ShowReadOnlyProperties = ShowReadOnlyProperties,
				UseEscapedUnicode = UseEscapedUnicode,
				UseExtensions = UseExtensions,
				UseFastGuid = UseFastGuid,
				UseOptimizedDatasetSchema = UseOptimizedDatasetSchema,
				UseUTCDateTime = UseUTCDateTime,
				UseValuesOfEnums = UseValuesOfEnums,
				UsingGlobalTypes = UsingGlobalTypes,
				AutoConvertStringToNumbers = AutoConvertStringToNumbers,
				OverrideObjectHashCodeChecking = OverrideObjectHashCodeChecking,
				FullyQualifiedDataSetSchema = FullyQualifiedDataSetSchema,
				BadListTypeChecking = BadListTypeChecking
			};
		}
	}
	internal static class JSON
	{
		public static JSONParameters Parameters = new JSONParameters();

		public static string ToNiceJSON(object obj)
		{
			string input = ToJSON(obj, Parameters);
			return Beautify(input);
		}

		public static string ToNiceJSON(object obj, JSONParameters param)
		{
			string input = ToJSON(obj, param);
			return Beautify(input, param.FormatterIndentSpaces);
		}

		public static string ToJSON(object obj)
		{
			return ToJSON(obj, Parameters);
		}

		public static string ToJSON(object obj, JSONParameters param)
		{
			param.FixValues();
			param = param.MakeCopy();
			Type c = null;
			if (obj == null)
			{
				return "null";
			}
			if (obj.GetType().IsGenericType)
			{
				c = Reflection.Instance.GetGenericTypeDefinition(obj.GetType());
			}
			if (typeof(IDictionary).IsAssignableFrom(c) || typeof(List<>).IsAssignableFrom(c))
			{
				param.UsingGlobalTypes = false;
			}
			if (param.EnableAnonymousTypes)
			{
				param.UseExtensions = false;
				param.UsingGlobalTypes = false;
			}
			return new JSONSerializer(param).ConvertToJSON(obj);
		}

		public static object Parse(string json)
		{
			return new JsonParser(json, Parameters.AllowNonQuotedKeys).Decode(null);
		}

		public static dynamic ToDynamic(string json)
		{
			return new DynamicJson(json);
		}

		public static T ToObject<T>(string json)
		{
			return new deserializer(Parameters).ToObject<T>(json);
		}

		public static T ToObject<T>(string json, JSONParameters param)
		{
			return new deserializer(param).ToObject<T>(json);
		}

		public static object ToObject(string json)
		{
			return new deserializer(Parameters).ToObject(json, null);
		}

		public static object ToObject(string json, JSONParameters param)
		{
			return new deserializer(param).ToObject(json, null);
		}

		public static object ToObject(string json, Type type)
		{
			return new deserializer(Parameters).ToObject(json, type);
		}

		public static object ToObject(string json, Type type, JSONParameters par)
		{
			return new deserializer(par).ToObject(json, type);
		}

		public static object FillObject(object input, string json)
		{
			if (!(new JsonParser(json, Parameters.AllowNonQuotedKeys).Decode(input.GetType()) is Dictionary<string, object> d))
			{
				return null;
			}
			return new deserializer(Parameters).ParseDictionary(d, null, input.GetType(), input);
		}

		public static object DeepCopy(object obj)
		{
			return new deserializer(Parameters).ToObject(ToJSON(obj));
		}

		public static T DeepCopy<T>(T obj)
		{
			return new deserializer(Parameters).ToObject<T>(ToJSON(obj));
		}

		public static string Beautify(string input)
		{
			string spaces = new string(' ', Parameters.FormatterIndentSpaces);
			return Formatter.PrettyPrint(input, spaces);
		}

		public static string Beautify(string input, byte spaces)
		{
			string spaces2 = new string(' ', spaces);
			return Formatter.PrettyPrint(input, spaces2);
		}

		public static void RegisterCustomType(Type type, Reflection.Serialize serializer, Reflection.Deserialize deserializer)
		{
			Reflection.Instance.RegisterCustomType(type, serializer, deserializer);
		}

		public static void ClearReflectionCache()
		{
			Reflection.Instance.ClearReflectionCache();
		}
	}
	internal class deserializer
	{
		private JSONParameters _params;

		private bool _usingglobals;

		private Dictionary<object, int> _circobj;

		private Dictionary<int, object> _cirrev = new Dictionary<int, object>();

		public deserializer(JSONParameters param)
		{
			if (param.OverrideObjectHashCodeChecking)
			{
				_circobj = new Dictionary<object, int>(10, ReferenceEqualityComparer.Default);
			}
			else
			{
				_circobj = new Dictionary<object, int>();
			}
			param.FixValues();
			_params = param.MakeCopy();
		}

		public T ToObject<T>(string json)
		{
			Type typeFromHandle = typeof(T);
			object obj = ToObject(json, typeFromHandle);
			if (typeFromHandle.IsArray)
			{
				if ((obj as ICollection).Count == 0)
				{
					Type elementType = typeFromHandle.GetElementType();
					object obj2 = Array.CreateInstance(elementType, 0);
					return (T)obj2;
				}
				return (T)obj;
			}
			return (T)obj;
		}

		public object ToObject(string json)
		{
			return ToObject(json, null);
		}

		public object ToObject(string json, Type type)
		{
			Type type2 = null;
			if (type != null && type.IsGenericType)
			{
				type2 = Reflection.Instance.GetGenericTypeDefinition(type);
			}
			_usingglobals = _params.UsingGlobalTypes;
			if (typeof(IDictionary).IsAssignableFrom(type2) || typeof(List<>).IsAssignableFrom(type2))
			{
				_usingglobals = false;
			}
			object obj = new JsonParser(json, _params.AllowNonQuotedKeys).Decode(type);
			if (obj == null)
			{
				return null;
			}
			if (obj is IDictionary)
			{
				if (type != null && typeof(Dictionary<, >).IsAssignableFrom(type2))
				{
					return RootDictionary(obj, type);
				}
				return ParseDictionary(obj as Dictionary<string, object>, null, type, null);
			}
			if (obj is List<object>)
			{
				if (!(type != null))
				{
					List<object> list = (List<object>)obj;
					if (list.Count > 0 && list[0].GetType() == typeof(Dictionary<string, object>))
					{
						Dictionary<string, object> globaltypes = new Dictionary<string, object>();
						List<object> list2 = new List<object>();
						{
							foreach (object item in list)
							{
								list2.Add(ParseDictionary((Dictionary<string, object>)item, globaltypes, null, null));
							}
							return list2;
						}
					}
					return list.ToArray();
				}
				if (typeof(Dictionary<, >).IsAssignableFrom(type2))
				{
					return RootDictionary(obj, type);
				}
				if (type2 == typeof(List<>))
				{
					return RootList(obj, type);
				}
				if (type.IsArray)
				{
					return RootArray(obj, type);
				}
				if (type == typeof(Hashtable))
				{
					return RootHashTable((List<object>)obj);
				}
			}
			else if (type != null && obj.GetType() != type)
			{
				return ChangeType(obj, type);
			}
			return obj;
		}

		private object RootHashTable(List<object> o)
		{
			Hashtable hashtable = new Hashtable();
			foreach (Dictionary<string, object> item in o)
			{
				object obj = item["k"];
				object obj2 = item["v"];
				if (obj is Dictionary<string, object>)
				{
					obj = ParseDictionary((Dictionary<string, object>)obj, null, typeof(object), null);
				}
				if (obj2 is Dictionary<string, object>)
				{
					obj2 = ParseDictionary((Dictionary<string, object>)obj2, null, typeof(object), null);
				}
				hashtable.Add(obj, obj2);
			}
			return hashtable;
		}

		private object ChangeType(object value, Type conversionType)
		{
			if (conversionType == typeof(object))
			{
				return value;
			}
			if (conversionType == typeof(int))
			{
				if (!(value is string text))
				{
					return (int)(long)value;
				}
				if (_params.AutoConvertStringToNumbers)
				{
					return Helper.CreateInteger(text, 0, text.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (conversionType == typeof(long))
			{
				if (!(value is string text2))
				{
					return (long)value;
				}
				if (_params.AutoConvertStringToNumbers)
				{
					return Helper.CreateLong(text2, 0, text2.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (conversionType == typeof(string))
			{
				return (string)value;
			}
			if (conversionType.IsEnum)
			{
				return Helper.CreateEnum(conversionType, value);
			}
			if (conversionType == typeof(DateTime))
			{
				return Helper.CreateDateTime((string)value, _params.UseUTCDateTime);
			}
			if (conversionType == typeof(DateTimeOffset))
			{
				return Helper.CreateDateTimeOffset((string)value);
			}
			if (Reflection.Instance.IsTypeRegistered(conversionType))
			{
				return Reflection.Instance.CreateCustom((string)value, conversionType);
			}
			if (Helper.IsNullable(conversionType))
			{
				if (value == null)
				{
					return value;
				}
				conversionType = Helper.UnderlyingTypeOf(conversionType);
			}
			if (conversionType == typeof(Guid))
			{
				return Helper.CreateGuid((string)value);
			}
			if (conversionType == typeof(byte[]))
			{
				return Convert.FromBase64String((string)value);
			}
			if (conversionType == typeof(TimeSpan))
			{
				return new TimeSpan((long)value);
			}
			return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
		}

		private object RootList(object parse, Type type)
		{
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type);
			IList list = (IList)Reflection.Instance.FastCreateList(type, ((IList)parse).Count);
			DoParseList((IList)parse, genericArguments[0], list);
			return list;
		}

		private void DoParseList(IList parse, Type it, IList o)
		{
			Dictionary<string, object> globaltypes = new Dictionary<string, object>();
			foreach (object item in parse)
			{
				_usingglobals = false;
				object obj = item;
				obj = ((!(item is Dictionary<string, object> d)) ? ChangeType(item, it) : ParseDictionary(d, globaltypes, it, null));
				o.Add(obj);
			}
		}

		private object RootArray(object parse, Type type)
		{
			Type elementType = type.GetElementType();
			IList list = (IList)Reflection.Instance.FastCreateInstance(typeof(List<>).MakeGenericType(elementType));
			DoParseList((IList)parse, elementType, list);
			Array array = Array.CreateInstance(elementType, list.Count);
			list.CopyTo(array, 0);
			return array;
		}

		private object RootDictionary(object parse, Type type)
		{
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type);
			Type type2 = null;
			Type type3 = null;
			bool flag = false;
			if (genericArguments != null)
			{
				type2 = genericArguments[0];
				type3 = genericArguments[1];
				if (type3 != null)
				{
					flag = type3.Name.StartsWith("Dictionary");
				}
			}
			Type elementType = type3.GetElementType();
			if (parse is Dictionary<string, object>)
			{
				IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(type);
				{
					foreach (KeyValuePair<string, object> item in (Dictionary<string, object>)parse)
					{
						object key = ChangeType(item.Key, type2);
						object value = ((!flag) ? ((!(item.Value is Dictionary<string, object>)) ? ((type3.IsArray && type3 != typeof(byte[])) ? CreateArray((List<object>)item.Value, type3, elementType, null) : ((!(item.Value is IList)) ? ChangeType(item.Value, type3) : CreateGenericList((List<object>)item.Value, type3, type2, null))) : ParseDictionary(item.Value as Dictionary<string, object>, null, type3, null)) : RootDictionary(item.Value, type3));
						dictionary.Add(key, value);
					}
					return dictionary;
				}
			}
			if (parse is List<object>)
			{
				return CreateDictionary(parse as List<object>, type, genericArguments, null);
			}
			return null;
		}

		internal object ParseDictionary(Dictionary<string, object> d, Dictionary<string, object> globaltypes, Type type, object input)
		{
			object value = "";
			if (type == typeof(NameValueCollection))
			{
				return Helper.CreateNV(d);
			}
			if (type == typeof(StringDictionary))
			{
				return Helper.CreateSD(d);
			}
			if (d.TryGetValue("$i", out value))
			{
				object value2 = null;
				_cirrev.TryGetValue((int)(long)value, out value2);
				return value2;
			}
			if (d.TryGetValue("$types", out value))
			{
				_usingglobals = true;
				if (globaltypes == null)
				{
					globaltypes = new Dictionary<string, object>();
				}
				foreach (KeyValuePair<string, object> item in (Dictionary<string, object>)value)
				{
					globaltypes.Add((string)item.Value, item.Key);
				}
			}
			if (globaltypes != null)
			{
				_usingglobals = true;
			}
			bool flag = d.TryGetValue("$type", out value);
			if (!flag && type == typeof(object))
			{
				return d;
			}
			if (flag)
			{
				if (_usingglobals)
				{
					object value3 = "";
					if (globaltypes != null && globaltypes.TryGetValue((string)value, out value3))
					{
						value = value3;
					}
				}
				type = Reflection.Instance.GetTypeFromCache((string)value, _params.BadListTypeChecking);
			}
			if (type == null)
			{
				throw new Exception("Cannot determine type : " + value);
			}
			string fullName = type.FullName;
			object obj = input;
			if (obj == null)
			{
				obj = ((!_params.ParametricConstructorOverride) ? Reflection.Instance.FastCreateInstance(type) : FormatterServices.GetUninitializedObject(type));
			}
			int value4 = 0;
			if (!_circobj.TryGetValue(obj, out value4))
			{
				value4 = _circobj.Count + 1;
				_circobj.Add(obj, value4);
				_cirrev.Add(value4, obj);
			}
			Dictionary<string, myPropInfo> dictionary = Reflection.Instance.Getproperties(type, fullName, _params.ShowReadOnlyProperties);
			foreach (KeyValuePair<string, object> item2 in d)
			{
				string key = item2.Key;
				object value5 = item2.Value;
				string text = key;
				if (text == "$map")
				{
					ProcessMap(obj, dictionary, (Dictionary<string, object>)d[text]);
				}
				else
				{
					if ((!dictionary.TryGetValue(text, out var value6) && !dictionary.TryGetValue(text.ToLowerInvariant(), out value6)) || !value6.CanWrite)
					{
						continue;
					}
					object value7 = null;
					if (value5 != null)
					{
						switch (value6.Type)
						{
						case myPropInfoType.Int:
							value7 = (int)Helper.AutoConv(value5, _params);
							break;
						case myPropInfoType.Long:
							value7 = Helper.AutoConv(value5, _params);
							break;
						case myPropInfoType.String:
							value7 = value5.ToString();
							break;
						case myPropInfoType.Bool:
							value7 = Helper.BoolConv(value5);
							break;
						case myPropInfoType.DateTime:
							value7 = Helper.CreateDateTime((string)value5, _params.UseUTCDateTime);
							break;
						case myPropInfoType.Enum:
							value7 = Helper.CreateEnum(value6.pt, value5);
							break;
						case myPropInfoType.Guid:
							value7 = Helper.CreateGuid((string)value5);
							break;
						case myPropInfoType.Array:
							if (!value6.IsValueType)
							{
								value7 = CreateArray((List<object>)value5, value6.pt, value6.bt, globaltypes);
							}
							break;
						case myPropInfoType.ByteArray:
							value7 = Convert.FromBase64String((string)value5);
							break;
						case myPropInfoType.Dictionary:
							value7 = CreateDictionary((List<object>)value5, value6.pt, value6.GenericTypes, globaltypes);
							break;
						case myPropInfoType.StringKeyDictionary:
							value7 = CreateStringKeyDictionary((Dictionary<string, object>)value5, value6.pt, value6.GenericTypes, globaltypes);
							break;
						case myPropInfoType.NameValue:
							value7 = Helper.CreateNV((Dictionary<string, object>)value5);
							break;
						case myPropInfoType.StringDictionary:
							value7 = Helper.CreateSD((Dictionary<string, object>)value5);
							break;
						case myPropInfoType.Custom:
							value7 = Reflection.Instance.CreateCustom((string)value5, value6.pt);
							break;
						default:
							value7 = ((value6.IsGenericType && !value6.IsValueType && value5 is List<object>) ? CreateGenericList((List<object>)value5, value6.pt, value6.bt, globaltypes) : (((value6.IsClass || value6.IsStruct || value6.IsInterface) && value5 is Dictionary<string, object>) ? ParseDictionary((Dictionary<string, object>)value5, globaltypes, value6.pt, null) : ((!(value5 is List<object>)) ? ((!value6.IsValueType) ? value5 : ChangeType(value5, value6.changeType)) : CreateArray((List<object>)value5, value6.pt, typeof(object), globaltypes))));
							break;
						}
					}
					obj = value6.setter(obj, value7);
				}
			}
			return obj;
		}

		private static void ProcessMap(object obj, Dictionary<string, myPropInfo> props, Dictionary<string, object> dic)
		{
			foreach (KeyValuePair<string, object> item in dic)
			{
				myPropInfo myPropInfo2 = props[item.Key];
				object obj2 = myPropInfo2.getter(obj);
				Type typeFromCache = Reflection.Instance.GetTypeFromCache((string)item.Value, badlistChecking: true);
				if (typeFromCache == typeof(Guid))
				{
					myPropInfo2.setter(obj, Helper.CreateGuid((string)obj2));
				}
			}
		}

		private object CreateArray(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
		{
			if (bt == null)
			{
				bt = typeof(object);
			}
			Array array = Array.CreateInstance(bt, data.Count);
			Type elementType = bt.GetElementType();
			for (int i = 0; i < data.Count; i++)
			{
				object obj = data[i];
				if (obj != null)
				{
					if (obj is IDictionary)
					{
						array.SetValue(ParseDictionary((Dictionary<string, object>)obj, globalTypes, bt, null), i);
					}
					else if (obj is ICollection)
					{
						array.SetValue(CreateArray((List<object>)obj, bt, elementType, globalTypes), i);
					}
					else
					{
						array.SetValue(ChangeType(obj, bt), i);
					}
				}
			}
			return array;
		}

		private object CreateGenericList(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
		{
			if (pt != typeof(object))
			{
				IList list = (IList)Reflection.Instance.FastCreateList(pt, data.Count);
				Type type = Reflection.Instance.GetGenericArguments(pt)[0];
				{
					foreach (object datum in data)
					{
						if (datum is IDictionary)
						{
							list.Add(ParseDictionary((Dictionary<string, object>)datum, globalTypes, type, null));
						}
						else if (datum is List<object>)
						{
							if (bt.IsGenericType)
							{
								list.Add((List<object>)datum);
							}
							else
							{
								list.Add(((List<object>)datum).ToArray());
							}
						}
						else
						{
							list.Add(ChangeType(datum, type));
						}
					}
					return list;
				}
			}
			return data;
		}

		private object CreateStringKeyDictionary(Dictionary<string, object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
		{
			IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(pt);
			Type type = null;
			Type type2 = null;
			if (types != null)
			{
				type2 = types[1];
			}
			Type bt = null;
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type2);
			if (genericArguments.Length != 0)
			{
				bt = genericArguments[0];
			}
			type = type2.GetElementType();
			foreach (KeyValuePair<string, object> item in reader)
			{
				string key = item.Key;
				object obj = null;
				obj = ((!(item.Value is Dictionary<string, object>)) ? ((types != null && type2.IsArray) ? ((!(item.Value is Array)) ? CreateArray((List<object>)item.Value, type2, type, globalTypes) : item.Value) : ((!(item.Value is IList)) ? ChangeType(item.Value, type2) : CreateGenericList((List<object>)item.Value, type2, bt, globalTypes))) : ParseDictionary((Dictionary<string, object>)item.Value, globalTypes, type2, null));
				dictionary.Add(key, obj);
			}
			return dictionary;
		}

		private object CreateDictionary(List<object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
		{
			IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(pt);
			Type type = null;
			Type type2 = null;
			Type bt = null;
			if (types != null)
			{
				type = types[0];
				type2 = types[1];
			}
			Type bt2 = type2;
			if (type2 != null)
			{
				Type[] genericArguments = Reflection.Instance.GetGenericArguments(type2);
				if (genericArguments.Length != 0)
				{
					bt = genericArguments[0];
				}
				bt2 = type2.GetElementType();
			}
			bool flag = typeof(IDictionary).IsAssignableFrom(type2);
			foreach (Dictionary<string, object> item in reader)
			{
				object obj = item["k"];
				object obj2 = item["v"];
				obj = ((!(obj is Dictionary<string, object>)) ? ChangeType(obj, type) : ParseDictionary((Dictionary<string, object>)obj, globalTypes, type, null));
				obj2 = ((!flag) ? ((!(obj2 is Dictionary<string, object>)) ? ((types != null && type2.IsArray) ? CreateArray((List<object>)obj2, type2, bt2, globalTypes) : ((!(obj2 is IList)) ? ChangeType(obj2, type2) : CreateGenericList((List<object>)obj2, type2, bt, globalTypes))) : ParseDictionary((Dictionary<string, object>)obj2, globalTypes, type2, null)) : RootDictionary(obj2, type2));
				dictionary.Add(obj, obj2);
			}
			return dictionary;
		}
	}
	internal sealed class JsonParser
	{
		private enum Token
		{
			None = -1,
			Curly_Open,
			Curly_Close,
			Squared_Open,
			Squared_Close,
			Colon,
			Comma,
			String,
			Number,
			True,
			False,
			Null,
			PosInfinity,
			NegInfinity,
			NaN
		}

		private readonly char[] json;

		private readonly StringBuilder s = new StringBuilder();

		private Token lookAheadToken = Token.None;

		private int index;

		private bool allownonquotedkey;

		private int _len;

		private SafeDictionary<string, bool> _lookup;

		private SafeDictionary<Type, bool> _seen;

		private bool _parseJsonType;

		private bool _parseType;

		internal JsonParser(string json, bool AllowNonQuotedKeys)
		{
			allownonquotedkey = AllowNonQuotedKeys;
			this.json = json.ToCharArray();
			_len = json.Length;
		}

		private void SetupLookup()
		{
			_lookup = new SafeDictionary<string, bool>();
			_seen = new SafeDictionary<Type, bool>();
			_lookup.Add("$types", value: true);
			_lookup.Add("$type", value: true);
			_lookup.Add("$i", value: true);
			_lookup.Add("$map", value: true);
			_lookup.Add("$schema", value: true);
			_lookup.Add("k", value: true);
			_lookup.Add("v", value: true);
		}

		public unsafe object Decode(Type objtype)
		{
			fixed (char* p = json)
			{
				if (objtype != null && !CheckForTypeInJson(p))
				{
					_parseJsonType = true;
					SetupLookup();
					BuildLookup(objtype);
					if (!_parseJsonType || _lookup.Count() == 7)
					{
						_lookup = null;
					}
				}
				return ParseValue(p);
			}
		}

		private unsafe bool CheckForTypeInJson(char* p)
		{
			int i = 0;
			for (int num = ((_len > 1000) ? 1000 : _len); i < num; i++)
			{
				if (p[i] == '$' && p[i + 1] == 't' && p[i + 2] == 'y' && p[i + 3] == 'p' && p[i + 4] == 'e' && p[i + 5] == 's')
				{
					return true;
				}
			}
			return false;
		}

		private void BuildGenericTypeLookup(Type t)
		{
			if (_seen.TryGetValue(t, out var _))
			{
				return;
			}
			Type[] genericArguments = t.GetGenericArguments();
			foreach (Type type in genericArguments)
			{
				if (!type.IsPrimitive)
				{
					bool flag = type.IsValueType && !type.IsEnum;
					if ((type.IsClass || flag || type.IsAbstract) && type != typeof(string) && type != typeof(DateTime) && type != typeof(Guid))
					{
						BuildLookup(type);
					}
				}
			}
		}

		private void BuildArrayTypeLookup(Type t)
		{
			if (!_seen.TryGetValue(t, out var _))
			{
				bool flag = t.IsValueType && !t.IsEnum;
				if ((t.IsClass || flag) && t != typeof(string) && t != typeof(DateTime) && t != typeof(Guid))
				{
					BuildLookup(t.GetElementType());
				}
			}
		}

		private void BuildLookup(Type objtype)
		{
			if (objtype == null || objtype == typeof(NameValueCollection) || objtype == typeof(StringDictionary) || typeof(IDictionary).IsAssignableFrom(objtype) || _seen.TryGetValue(objtype, out var _))
			{
				return;
			}
			if (objtype.IsGenericType)
			{
				BuildGenericTypeLookup(objtype);
				return;
			}
			if (objtype.IsArray)
			{
				BuildArrayTypeLookup(objtype);
				return;
			}
			_seen.Add(objtype, value: true);
			foreach (KeyValuePair<string, myPropInfo> item in Reflection.Instance.Getproperties(objtype, objtype.FullName, ShowReadOnlyProperties: true))
			{
				Type pt = item.Value.pt;
				_lookup.Add(item.Key, value: true);
				if (pt.IsArray)
				{
					BuildArrayTypeLookup(pt);
				}
				if (pt.IsGenericType)
				{
					if (typeof(IDictionary).IsAssignableFrom(pt))
					{
						_parseJsonType = false;
						break;
					}
					BuildGenericTypeLookup(pt);
				}
				if (pt.FullName.IndexOf("System.") == -1)
				{
					BuildLookup(pt);
				}
			}
		}

		private bool InLookup(string name)
		{
			if (_lookup == null)
			{
				return true;
			}
			bool value;
			return _lookup.TryGetValue(name.ToLowerInvariant(), out value);
		}

		private unsafe Dictionary<string, object> ParseObject(char* p)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					continue;
				case Token.Curly_Close:
					ConsumeToken();
					return dictionary;
				}
				string text = ParseKey(p);
				Token token = NextToken(p);
				if (token != Token.Colon)
				{
					throw new Exception("Expected colon at index " + index);
				}
				if (_parseJsonType)
				{
					if (text == "$types")
					{
						_parseType = true;
						Dictionary<string, object> dictionary2 = (Dictionary<string, object>)ParseValue(p);
						_parseType = false;
						if (_lookup == null)
						{
							SetupLookup();
						}
						foreach (string key in dictionary2.Keys)
						{
							BuildLookup(Reflection.Instance.GetTypeFromCache(key, badlistChecking: true));
						}
						dictionary[text] = dictionary2;
					}
					else if (text == "$schema")
					{
						_parseType = true;
						object value = ParseValue(p);
						_parseType = false;
						dictionary[text] = value;
					}
					else if (_parseType || InLookup(text))
					{
						dictionary[text] = ParseValue(p);
					}
					else
					{
						SkipValue(p);
					}
				}
				else
				{
					dictionary[text] = ParseValue(p);
				}
			}
		}

		private unsafe void SkipValue(char* p)
		{
			switch (LookAhead(p))
			{
			case Token.Number:
				ParseNumber(p, skip: true);
				break;
			case Token.String:
				SkipString(p);
				break;
			case Token.Curly_Open:
				SkipObject(p);
				break;
			case Token.Squared_Open:
				SkipArray(p);
				break;
			case Token.True:
			case Token.False:
			case Token.Null:
			case Token.PosInfinity:
			case Token.NegInfinity:
			case Token.NaN:
				ConsumeToken();
				break;
			case Token.Curly_Close:
			case Token.Squared_Close:
			case Token.Colon:
			case Token.Comma:
				break;
			}
		}

		private unsafe void SkipObject(char* p)
		{
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					continue;
				case Token.Curly_Close:
					ConsumeToken();
					return;
				}
				SkipString(p);
				Token token = NextToken(p);
				if (token != Token.Colon)
				{
					throw new Exception("Expected colon at index " + index);
				}
				SkipValue(p);
			}
		}

		private unsafe void SkipArray(char* p)
		{
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					break;
				case Token.Squared_Close:
					ConsumeToken();
					return;
				default:
					SkipValue(p);
					break;
				}
			}
		}

		private unsafe void SkipString(char* p)
		{
			ConsumeToken();
			int len = _len;
			while (index < len)
			{
				switch (p[index++])
				{
				case '"':
					return;
				case '\\':
				{
					char c = p[index++];
					if (c == 'u')
					{
						index += 4;
					}
					break;
				}
				}
			}
		}

		private unsafe List<object> ParseArray(char* p)
		{
			List<object> list = new List<object>();
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					break;
				case Token.Squared_Close:
					ConsumeToken();
					return list;
				default:
					list.Add(ParseValue(p));
					break;
				}
			}
		}

		private unsafe object ParseValue(char* p)
		{
			switch (LookAhead(p))
			{
			case Token.Number:
				return ParseNumber(p, skip: false);
			case Token.String:
				return ParseString(p);
			case Token.Curly_Open:
				return ParseObject(p);
			case Token.Squared_Open:
				return ParseArray(p);
			case Token.True:
				ConsumeToken();
				return true;
			case Token.False:
				ConsumeToken();
				return false;
			case Token.Null:
				ConsumeToken();
				return null;
			case Token.PosInfinity:
				ConsumeToken();
				return double.PositiveInfinity;
			case Token.NegInfinity:
				ConsumeToken();
				return double.NegativeInfinity;
			case Token.NaN:
				ConsumeToken();
				return double.NaN;
			default:
				throw new Exception("Unrecognized token at index " + index);
			}
		}

		private unsafe string ParseKey(char* p)
		{
			if (!allownonquotedkey || p[index - 1] == '"')
			{
				return ParseString(p);
			}
			ConsumeToken();
			int len = _len;
			int num = 0;
			while (index + num < len)
			{
				char c = p[index + num++];
				if (c == ':')
				{
					string result = UnsafeSubstring(p, index, num - 1).Trim();
					index += num - 1;
					return result;
				}
			}
			throw new Exception("Unable to read key");
		}

		private unsafe string ParseString(char* p)
		{
			char c = p[index - 1];
			ConsumeToken();
			if (s.Length > 0)
			{
				s.Length = 0;
			}
			int len = _len;
			int num = 0;
			while (index + num < len)
			{
				char c2 = p[index + num++];
				if (c2 == '\\')
				{
					break;
				}
				if (c2 == c)
				{
					string result = UnsafeSubstring(p, index, num - 1);
					index += num;
					return result;
				}
			}
			while (index < len)
			{
				char c3 = p[index++];
				if (c3 == c)
				{
					return s.ToString();
				}
				if (c3 != '\\')
				{
					s.Append(c3);
					continue;
				}
				c3 = p[index++];
				switch (c3)
				{
				case 'b':
					s.Append('\b');
					continue;
				case 'f':
					s.Append('\f');
					continue;
				case 'n':
					s.Append('\n');
					continue;
				case 'r':
					s.Append('\r');
					continue;
				case 't':
					s.Append('\t');
					continue;
				case 'u':
				{
					uint num2 = ParseUnicode(p[index], p[index + 1], p[index + 2], p[index + 3]);
					s.Append((char)num2);
					index += 4;
					continue;
				}
				}
				if (c3 == '\r' || c3 == '\n' || c3 == ' ' || c3 == '\t')
				{
					while (c3 == '\r' || c3 == '\n' || c3 == ' ' || c3 == '\t')
					{
						index++;
						c3 = p[index];
						if (c3 == '\r' || c3 == '\n')
						{
							c3 = p[index + 1];
							if (c3 == '\r' || c3 == '\n')
							{
								index += 2;
								c3 = p[index];
							}
							break;
						}
					}
				}
				else
				{
					s.Append(c3);
				}
			}
			return s.ToString();
		}

		private unsafe string ParseJson5String(char* p)
		{
			throw new NotImplementedException();
		}

		private uint ParseSingleChar(char c1, uint multipliyer)
		{
			uint result = 0u;
			if (c1 >= '0' && c1 <= '9')
			{
				result = (uint)(c1 - 48) * multipliyer;
			}
			else if (c1 >= 'A' && c1 <= 'F')
			{
				result = (uint)(c1 - 65 + 10) * multipliyer;
			}
			else if (c1 >= 'a' && c1 <= 'f')
			{
				result = (uint)(c1 - 97 + 10) * multipliyer;
			}
			return result;
		}

		private uint ParseUnicode(char c1, char c2, char c3, char c4)
		{
			uint num = ParseSingleChar(c1, 4096u);
			uint num2 = ParseSingleChar(c2, 256u);
			uint num3 = ParseSingleChar(c3, 16u);
			uint num4 = ParseSingleChar(c4, 1u);
			return num + num2 + num3 + num4;
		}

		private unsafe object ParseNumber(char* p, bool skip)
		{
			ConsumeToken();
			int num = index - 1;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = true;
			if (p[num] == '.')
			{
				flag = true;
			}
			while (index != _len)
			{
				switch (p[index])
				{
				case 'X':
				case 'x':
					index++;
					return ReadHexNumber(p);
				case '+':
				case '-':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					index++;
					break;
				case 'E':
				case 'e':
					flag2 = true;
					index++;
					break;
				case '.':
					index++;
					flag = true;
					break;
				case 'N':
				case 'n':
					index += 3;
					return double.NaN;
				default:
					flag3 = false;
					break;
				}
				if (index == _len)
				{
					flag3 = false;
				}
				if (!flag3)
				{
					break;
				}
			}
			if (skip)
			{
				return 0;
			}
			int num2 = index - num;
			if (flag2 || num2 > 31)
			{
				string text = UnsafeSubstring(p, num, num2);
				return double.Parse(text, NumberFormatInfo.InvariantInfo);
			}
			if (!flag && num2 < 20)
			{
				return Helper.CreateLong(json, num, num2);
			}
			string text2 = UnsafeSubstring(p, num, num2);
			return decimal.Parse(text2, NumberFormatInfo.InvariantInfo);
		}

		private unsafe object ReadHexNumber(char* p)
		{
			long num = 0L;
			bool flag = true;
			while (flag && index < _len)
			{
				char c = p[index];
				switch (c)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					index++;
					num = (num << 4) + (c - 48);
					break;
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
					index++;
					num = (num << 4) + (c - 97) + 10;
					break;
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
					index++;
					num = (num << 4) + (c - 65) + 10;
					break;
				default:
					flag = false;
					break;
				}
			}
			return num;
		}

		private unsafe Token LookAhead(char* p)
		{
			if (lookAheadToken != Token.None)
			{
				return lookAheadToken;
			}
			return lookAheadToken = NextTokenCore(p);
		}

		private void ConsumeToken()
		{
			lookAheadToken = Token.None;
		}

		private unsafe Token NextToken(char* p)
		{
			Token result = ((lookAheadToken != Token.None) ? lookAheadToken : NextTokenCore(p));
			lookAheadToken = Token.None;
			return result;
		}

		private unsafe void SkipWhitespace(char* p)
		{
			char c;
			do
			{
				c = p[index];
				if (c == '/' && p[index + 1] == '/')
				{
					index++;
					index++;
					do
					{
						c = p[index];
					}
					while (c != '\r' && c != '\n' && ++index < _len);
				}
				if (c != '/' || p[index + 1] != '*')
				{
					continue;
				}
				index++;
				index++;
				do
				{
					c = p[index];
					if (c == '*' && p[index + 1] == '/')
					{
						index += 2;
						c = p[index];
						break;
					}
				}
				while (++index < _len);
			}
			while ((c == ' ' || c == '\t' || c == '\n' || c == '\r') && ++index < _len);
		}

		private unsafe Token NextTokenCore(char* p)
		{
			int len = _len;
			SkipWhitespace(p);
			if (index == len)
			{
				throw new Exception("Reached end of string unexpectedly");
			}
			char c = p[index];
			index++;
			switch (c)
			{
			case '{':
				return Token.Curly_Open;
			case '}':
				return Token.Curly_Close;
			case '[':
				return Token.Squared_Open;
			case ']':
				return Token.Squared_Close;
			case ',':
				return Token.Comma;
			case '"':
			case '\'':
				return Token.String;
			case '-':
				if (p[index] == 'i' || p[index] == 'I')
				{
					index += 8;
					return Token.NegInfinity;
				}
				return Token.Number;
			case '+':
				if (p[index] == 'i' || p[index] == 'I')
				{
					index += 8;
					return Token.PosInfinity;
				}
				return Token.Number;
			case '.':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				return Token.Number;
			case ':':
				return Token.Colon;
			case 'I':
			case 'i':
				index += 7;
				return Token.PosInfinity;
			case 'f':
				if (len - index >= 4 && p[index] == 'a' && p[index + 1] == 'l' && p[index + 2] == 's' && p[index + 3] == 'e')
				{
					index += 4;
					return Token.False;
				}
				break;
			case 't':
				if (len - index >= 3 && p[index] == 'r' && p[index + 1] == 'u' && p[index + 2] == 'e')
				{
					index += 3;
					return Token.True;
				}
				break;
			case 'N':
			case 'n':
				if (len - index >= 3 && p[index] == 'u' && p[index + 1] == 'l' && p[index + 2] == 'l')
				{
					index += 3;
					return Token.Null;
				}
				if (len - index >= 2 && p[index] == 'a' && (p[index + 1] == 'n' || p[index + 1] == 'N'))
				{
					index += 2;
					return Token.NaN;
				}
				break;
			}
			if (allownonquotedkey)
			{
				index--;
				return Token.String;
			}
			throw new Exception("Could not find token at index " + --index + " got '" + p[index].ToString() + "'");
		}

		private unsafe static string UnsafeSubstring(char* p, int startIndex, int length)
		{
			return new string(p, startIndex, length);
		}
	}
	internal struct Getters
	{
		public string Name;

		public string lcName;

		public string memberName;

		public Reflection.GenericGetter Getter;

		public bool ReadOnly;
	}
	internal enum myPropInfoType
	{
		Int,
		Long,
		String,
		Bool,
		DateTime,
		Enum,
		Guid,
		Array,
		ByteArray,
		Dictionary,
		StringKeyDictionary,
		NameValue,
		StringDictionary,
		Hashtable,
		DataSet,
		DataTable,
		Custom,
		Unknown
	}
	internal class myPropInfo
	{
		public Type pt;

		public Type bt;

		public Type changeType;

		public Reflection.GenericSetter setter;

		public Reflection.GenericGetter getter;

		public Type[] GenericTypes;

		public string Name;

		public string memberName;

		public myPropInfoType Type;

		public bool CanWrite;

		public bool IsClass;

		public bool IsValueType;

		public bool IsGenericType;

		public bool IsStruct;

		public bool IsInterface;
	}
	internal sealed class Reflection
	{
		public delegate string Serialize(object data);

		public delegate object Deserialize(string data);

		public delegate object GenericSetter(object target, object value);

		public delegate object GenericGetter(object obj);

		private delegate object CreateObject();

		private delegate object CreateList(int capacity);

		private static readonly Reflection instance;

		public static bool RDBMode;

		private SafeDictionary<Type, string> _tyname = new SafeDictionary<Type, string>(10);

		private SafeDictionary<string, Type> _typecache = new SafeDictionary<string, Type>(10);

		private SafeDictionary<Type, CreateObject> _constrcache = new SafeDictionary<Type, CreateObject>(10);

		private SafeDictionary<Type, CreateList> _conlistcache = new SafeDictionary<Type, CreateList>(10);

		private SafeDictionary<Type, Getters[]> _getterscache = new SafeDictionary<Type, Getters[]>(10);

		private SafeDictionary<string, Dictionary<string, myPropInfo>> _propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>(10);

		private SafeDictionary<Type, Type[]> _genericTypes = new SafeDictionary<Type, Type[]>(10);

		private SafeDictionary<Type, Type> _genericTypeDef = new SafeDictionary<Type, Type>(10);

		private static SafeDictionary<short, OpCode> _opCodes;

		private static List<string> _badlistTypes;

		private static UTF8Encoding utf8;

		internal SafeDictionary<Type, Serialize> _customSerializer = new SafeDictionary<Type, Serialize>();

		internal SafeDictionary<Type, Deserialize> _customDeserializer = new SafeDictionary<Type, Deserialize>();

		public static Reflection Instance => instance;

		static Reflection()
		{
			instance = new Reflection();
			RDBMode = false;
			_badlistTypes = new List<string> { "system.configuration.install.assemblyinstaller", "system.activities.presentation.workflowdesigner", "system.windows.resourcedictionary", "system.windows.data.objectdataprovider", "system.windows.forms.bindingsource", "microsoft.exchange.management.systemmanager.winforms.exchangesettingsprovider" };
			utf8 = new UTF8Encoding();
		}

		private Reflection()
		{
		}

		private static bool TryGetOpCode(short code, out OpCode opCode)
		{
			if (_opCodes != null)
			{
				return _opCodes.TryGetValue(code, out opCode);
			}
			SafeDictionary<short, OpCode> safeDictionary = new SafeDictionary<short, OpCode>();
			FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (typeof(OpCode).IsAssignableFrom(fieldInfo.FieldType))
				{
					OpCode value = (OpCode)fieldInfo.GetValue(null);
					if (value.OpCodeType != OpCodeType.Nternal)
					{
						safeDictionary.Add(value.Value, value);
					}
				}
			}
			_opCodes = safeDictionary;
			return _opCodes.TryGetValue(code, out opCode);
		}

		public static byte[] UTF8GetBytes(string str)
		{
			return utf8.GetBytes(str);
		}

		public static string UTF8GetString(byte[] bytes, int offset, int len)
		{
			return utf8.GetString(bytes, offset, len);
		}

		public unsafe static byte[] UnicodeGetBytes(string str)
		{
			int num = str.Length * 2;
			byte[] array = new byte[num];
			fixed (void* value = str)
			{
				Marshal.Copy(new IntPtr(value), array, 0, num);
			}
			return array;
		}

		public static string UnicodeGetString(byte[] b)
		{
			return UnicodeGetString(b, 0, b.Length);
		}

		public unsafe static string UnicodeGetString(byte[] bytes, int offset, int buflen)
		{
			string text = "";
			fixed (byte* ptr = bytes)
			{
				char* value = (char*)(ptr + offset);
				text = new string(value, 0, buflen / 2);
			}
			return text;
		}

		internal object CreateCustom(string v, Type type)
		{
			_customDeserializer.TryGetValue(type, out var value);
			return value(v);
		}

		internal void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
		{
			if (type != null && serializer != null && deserializer != null)
			{
				_customSerializer.Add(type, serializer);
				_customDeserializer.Add(type, deserializer);
				Instance.ResetPropertyCache();
			}
		}

		internal bool IsTypeRegistered(Type t)
		{
			if (_customSerializer.Count() == 0)
			{
				return false;
			}
			Serialize value;
			return _customSerializer.TryGetValue(t, out value);
		}

		public Type GetGenericTypeDefinition(Type t)
		{
			Type value = null;
			if (_genericTypeDef.TryGetValue(t, out value))
			{
				return value;
			}
			value = t.GetGenericTypeDefinition();
			_genericTypeDef.Add(t, value);
			return value;
		}

		public Type[] GetGenericArguments(Type t)
		{
			Type[] value = null;
			if (_genericTypes.TryGetValue(t, out value))
			{
				return value;
			}
			value = t.GetGenericArguments();
			_genericTypes.Add(t, value);
			return value;
		}

		public Dictionary<string, myPropInfo> Getproperties(Type type, string typename, bool ShowReadOnlyProperties)
		{
			Dictionary<string, myPropInfo> value = null;
			if (_propertycache.TryGetValue(typename, out value))
			{
				return value;
			}
			value = new Dictionary<string, myPropInfo>(10);
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				myPropInfo myPropInfo2 = CreateMyProp(propertyInfo.PropertyType, propertyInfo.Name);
				myPropInfo2.setter = CreateSetMethod(type, propertyInfo, ShowReadOnlyProperties);
				if (myPropInfo2.setter != null)
				{
					myPropInfo2.CanWrite = true;
				}
				myPropInfo2.getter = CreateGetMethod(type, propertyInfo);
				object[] customAttributes = propertyInfo.GetCustomAttributes(inherit: true);
				object[] array2 = customAttributes;
				foreach (object obj in array2)
				{
					if (obj is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)obj;
						if (dataMemberAttribute.Name != "")
						{
							myPropInfo2.memberName = dataMemberAttribute.Name;
						}
					}
				}
				if (myPropInfo2.memberName != null)
				{
					value.Add(myPropInfo2.memberName, myPropInfo2);
				}
				else
				{
					value.Add(propertyInfo.Name.ToLowerInvariant(), myPropInfo2);
				}
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			FieldInfo[] array3 = fields;
			foreach (FieldInfo fieldInfo in array3)
			{
				myPropInfo myPropInfo3 = CreateMyProp(fieldInfo.FieldType, fieldInfo.Name);
				if (fieldInfo.IsLiteral)
				{
					continue;
				}
				if (!fieldInfo.IsInitOnly)
				{
					myPropInfo3.setter = CreateSetField(type, fieldInfo);
				}
				if (myPropInfo3.setter != null)
				{
					myPropInfo3.CanWrite = true;
				}
				myPropInfo3.getter = CreateGetField(type, fieldInfo);
				object[] customAttributes2 = fieldInfo.GetCustomAttributes(inherit: true);
				object[] array4 = customAttributes2;
				foreach (object obj2 in array4)
				{
					if (obj2 is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute2 = (DataMemberAttribute)obj2;
						if (dataMemberAttribute2.Name != "")
						{
							myPropInfo3.memberName = dataMemberAttribute2.Name;
						}
					}
				}
				if (myPropInfo3.memberName != null)
				{
					value.Add(myPropInfo3.memberName, myPropInfo3);
				}
				else
				{
					value.Add(fieldInfo.Name.ToLowerInvariant(), myPropInfo3);
				}
			}
			_propertycache.Add(typename, value);
			return value;
		}

		private myPropInfo CreateMyProp(Type t, string name)
		{
			myPropInfo myPropInfo2 = new myPropInfo();
			myPropInfoType type = myPropInfoType.Unknown;
			if (t == typeof(int) || t == typeof(int?))
			{
				type = myPropInfoType.Int;
			}
			else if (t == typeof(long) || t == typeof(long?))
			{
				type = myPropInfoType.Long;
			}
			else if (t == typeof(string))
			{
				type = myPropInfoType.String;
			}
			else if (t == typeof(bool) || t == typeof(bool?))
			{
				type = myPropInfoType.Bool;
			}
			else if (t == typeof(DateTime) || t == typeof(DateTime?))
			{
				type = myPropInfoType.DateTime;
			}
			else if (t.IsEnum)
			{
				type = myPropInfoType.Enum;
			}
			else if (t == typeof(Guid) || t == typeof(Guid?))
			{
				type = myPropInfoType.Guid;
			}
			else if (t == typeof(StringDictionary))
			{
				type = myPropInfoType.StringDictionary;
			}
			else if (t == typeof(NameValueCollection))
			{
				type = myPropInfoType.NameValue;
			}
			else if (t.IsArray)
			{
				myPropInfo2.bt = t.GetElementType();
				type = ((!(t == typeof(byte[]))) ? myPropInfoType.Array : myPropInfoType.ByteArray);
			}
			else if (t.Name.Contains("Dictionary"))
			{
				myPropInfo2.GenericTypes = Instance.GetGenericArguments(t);
				type = ((myPropInfo2.GenericTypes.Length == 0 || !(myPropInfo2.GenericTypes[0] == typeof(string))) ? myPropInfoType.Dictionary : myPropInfoType.StringKeyDictionary);
			}
			else if (IsTypeRegistered(t))
			{
				type = myPropInfoType.Custom;
			}
			if (t.IsValueType && !t.IsPrimitive && !t.IsEnum && t != typeof(decimal))
			{
				myPropInfo2.IsStruct = true;
			}
			myPropInfo2.IsInterface = t.IsInterface;
			myPropInfo2.IsClass = t.IsClass;
			myPropInfo2.IsValueType = t.IsValueType;
			if (t.IsGenericType)
			{
				myPropInfo2.IsGenericType = true;
				myPropInfo2.bt = Instance.GetGenericArguments(t)[0];
			}
			myPropInfo2.pt = t;
			myPropInfo2.Name = name;
			myPropInfo2.changeType = GetChangeType(t);
			myPropInfo2.Type = type;
			return myPropInfo2;
		}

		private Type GetChangeType(Type conversionType)
		{
			if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
			{
				return Instance.GetGenericArguments(conversionType)[0];
			}
			return conversionType;
		}

		public string GetTypeAssemblyName(Type t)
		{
			string value = "";
			if (_tyname.TryGetValue(t, out value))
			{
				return value;
			}
			string assemblyQualifiedName = t.AssemblyQualifiedName;
			_tyname.Add(t, assemblyQualifiedName);
			return assemblyQualifiedName;
		}

		internal Type GetTypeFromCache(string typename, bool badlistChecking)
		{
			Type value = null;
			if (_typecache.TryGetValue(typename, out value))
			{
				return value;
			}
			if (badlistChecking)
			{
				string text = typename.Trim().ToLowerInvariant();
				foreach (string badlistType in _badlistTypes)
				{
					if (text.StartsWith(badlistType, StringComparison.Ordinal))
					{
						throw new Exception("Black list type encountered, possible attack vector when using $type : " + typename);
					}
				}
			}
			Type type = Type.GetType(typename);
			_typecache.Add(typename, type);
			return type;
		}

		internal object FastCreateList(Type objtype, int capacity)
		{
			try
			{
				int capacity2 = 10;
				if (capacity > 10)
				{
					capacity2 = capacity;
				}
				CreateList value = null;
				if (_conlistcache.TryGetValue(objtype, out value))
				{
					if (value != null)
					{
						return value(capacity2);
					}
					return FastCreateInstance(objtype);
				}
				ConstructorInfo constructor = objtype.GetConstructor(new Type[1] { typeof(int) });
				if (constructor != null)
				{
					DynamicMethod dynamicMethod = new DynamicMethod("_fcil", objtype, new Type[1] { typeof(int) }, restrictedSkipVisibility: true);
					ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Newobj, objtype.GetConstructor(new Type[1] { typeof(int) }));
					iLGenerator.Emit(OpCodes.Ret);
					value = (CreateList)dynamicMethod.CreateDelegate(typeof(CreateList));
					_conlistcache.Add(objtype, value);
					return value(capacity2);
				}
				_conlistcache.Add(objtype, null);
				return FastCreateInstance(objtype);
			}
			catch (Exception innerException)
			{
				throw new Exception($"Failed to fast create instance for type '{objtype.FullName}' from assembly '{objtype.AssemblyQualifiedName}'", innerException);
			}
		}

		internal object FastCreateInstance(Type objtype)
		{
			try
			{
				CreateObject value = null;
				if (_constrcache.TryGetValue(objtype, out value))
				{
					return value();
				}
				if (objtype.IsClass)
				{
					DynamicMethod dynamicMethod = new DynamicMethod("_fcic", objtype, null, restrictedSkipVisibility: true);
					ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
					iLGenerator.Emit(OpCodes.Newobj, objtype.GetConstructor(Type.EmptyTypes));
					iLGenerator.Emit(OpCodes.Ret);
					value = (CreateObject)dynamicMethod.CreateDelegate(typeof(CreateObject));
					_constrcache.Add(objtype, value);
				}
				else
				{
					DynamicMethod dynamicMethod2 = new DynamicMethod("_fcis", typeof(object), null, restrictedSkipVisibility: true);
					ILGenerator iLGenerator2 = dynamicMethod2.GetILGenerator();
					LocalBuilder local = iLGenerator2.DeclareLocal(objtype);
					iLGenerator2.Emit(OpCodes.Ldloca_S, local);
					iLGenerator2.Emit(OpCodes.Initobj, objtype);
					iLGenerator2.Emit(OpCodes.Ldloc_0);
					iLGenerator2.Emit(OpCodes.Box, objtype);
					iLGenerator2.Emit(OpCodes.Ret);
					value = (CreateObject)dynamicMethod2.CreateDelegate(typeof(CreateObject));
					_constrcache.Add(objtype, value);
				}
				return value();
			}
			catch (Exception innerException)
			{
				throw new Exception($"Failed to fast create instance for type '{objtype.FullName}' from assembly '{objtype.AssemblyQualifiedName}'", innerException);
			}
		}

		internal static GenericSetter CreateSetField(Type type, FieldInfo fieldInfo)
		{
			Type[] array = new Type[2];
			array[0] = (array[1] = typeof(object));
			DynamicMethod dynamicMethod = new DynamicMethod("_csf", typeof(object), array, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (fieldInfo.FieldType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, fieldInfo.FieldType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
				}
				iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
				iLGenerator.Emit(OpCodes.Ldloc_0);
				iLGenerator.Emit(OpCodes.Box, type);
				iLGenerator.Emit(OpCodes.Ret);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
				}
				iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ret);
			}
			return (GenericSetter)dynamicMethod.CreateDelegate(typeof(GenericSetter));
		}

		internal static FieldInfo GetGetterBackingField(PropertyInfo autoProperty)
		{
			MethodInfo getMethod = autoProperty.GetGetMethod();
			if (!getMethod.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false))
			{
				return null;
			}
			byte[] array = getMethod.GetMethodBody()?.GetILAsByteArray() ?? new byte[0];
			OpCode opCode;
			for (int i = 0; i < array.Length; i += ((opCode.OperandType != OperandType.InlineNone) ? ((opCode.OperandType == OperandType.ShortInlineBrTarget || opCode.OperandType == OperandType.ShortInlineI || opCode.OperandType == OperandType.ShortInlineVar) ? 1 : ((opCode.OperandType == OperandType.InlineVar) ? 2 : ((opCode.OperandType == OperandType.InlineI8 || opCode.OperandType == OperandType.InlineR) ? 8 : ((opCode.OperandType == OperandType.InlineSwitch) ? (4 * (BitConverter.ToInt32(array, i) + 1)) : 4)))) : 0))
			{
				byte b = array[i++];
				if (!TryGetOpCode(b, out opCode) && (i >= array.Length || !TryGetOpCode((short)(b * 256 + array[i++]), out opCode)))
				{
					throw new NotSupportedException("Unknown IL code detected.");
				}
				if (opCode == OpCodes.Ldfld && opCode.OperandType == OperandType.InlineField && i + 4 <= array.Length)
				{
					return getMethod.Module.ResolveMember(BitConverter.ToInt32(array, i), getMethod.DeclaringType?.GetGenericArguments(), null) as FieldInfo;
				}
			}
			return null;
		}

		internal static GenericSetter CreateSetMethod(Type type, PropertyInfo propertyInfo, bool ShowReadOnlyProperties)
		{
			MethodInfo setMethod = propertyInfo.GetSetMethod(ShowReadOnlyProperties);
			if (setMethod == null)
			{
				if (!ShowReadOnlyProperties)
				{
					return null;
				}
				FieldInfo getterBackingField = GetGetterBackingField(propertyInfo);
				if (!(getterBackingField != null))
				{
					return null;
				}
				return CreateSetField(type, getterBackingField);
			}
			Type[] array = new Type[2];
			array[0] = (array[1] = typeof(object));
			DynamicMethod dynamicMethod = new DynamicMethod("_csm", typeof(object), array, restrictedSkipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.EmitCall(OpCodes.Call, setMethod, null);
				iLGenerator.Emit(OpCodes.Ldloc_0);
				iLGenerator.Emit(OpCodes.Box, type);
			}
			else if (!setMethod.IsStatic)
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.EmitCall(OpCodes.Callvirt, setMethod, null);
				iLGenerator.Emit(OpCodes.Ldarg_0);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.Emit(OpCodes.Call, setMethod);
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericSetter)dynamicMethod.CreateDelegate(typeof(GenericSetter));
		}

		internal static GenericGetter CreateGetField(Type type, FieldInfo fieldInfo)
		{
			DynamicMethod dynamicMethod = new DynamicMethod("_cgf", typeof(object), new Type[1] { typeof(object) }, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, fieldInfo.FieldType);
				}
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, fieldInfo.FieldType);
				}
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericGetter)dynamicMethod.CreateDelegate(typeof(GenericGetter));
		}

		internal static GenericGetter CreateGetMethod(Type type, PropertyInfo propertyInfo)
		{
			MethodInfo getMethod = propertyInfo.GetGetMethod();
			if (getMethod == null)
			{
				return null;
			}
			DynamicMethod dynamicMethod = new DynamicMethod("_cgm", typeof(object), new Type[1] { typeof(object) }, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.EmitCall(OpCodes.Call, getMethod, null);
				if (propertyInfo.PropertyType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, propertyInfo.PropertyType);
				}
			}
			else
			{
				if (!getMethod.IsStatic)
				{
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
					iLGenerator.EmitCall(OpCodes.Callvirt, getMethod, null);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Call, getMethod);
				}
				if (propertyInfo.PropertyType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, propertyInfo.PropertyType);
				}
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericGetter)dynamicMethod.CreateDelegate(typeof(GenericGetter));
		}

		public Getters[] GetGetters(Type type, List<Type> IgnoreAttributes)
		{
			Getters[] value = null;
			if (_getterscache.TryGetValue(type, out value))
			{
				return value;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			List<Getters> list = new List<Getters>();
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				bool readOnly = false;
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				if (!propertyInfo.CanWrite)
				{
					readOnly = true;
				}
				if (IgnoreAttributes != null)
				{
					bool flag = false;
					foreach (Type IgnoreAttribute in IgnoreAttributes)
					{
						if (propertyInfo.IsDefined(IgnoreAttribute, inherit: false))
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						continue;
					}
				}
				string memberName = null;
				object[] customAttributes = propertyInfo.GetCustomAttributes(inherit: true);
				object[] array2 = customAttributes;
				foreach (object obj in array2)
				{
					if (obj is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)obj;
						if (dataMemberAttribute.Name != "")
						{
							memberName = dataMemberAttribute.Name;
						}
					}
				}
				GenericGetter genericGetter = CreateGetMethod(type, propertyInfo);
				if (genericGetter != null)
				{
					list.Add(new Getters
					{
						Getter = genericGetter,
						Name = propertyInfo.Name,
						lcName = propertyInfo.Name.ToLowerInvariant(),
						memberName = memberName,
						ReadOnly = readOnly
					});
				}
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			FieldInfo[] array3 = fields;
			foreach (FieldInfo fieldInfo in array3)
			{
				bool readOnly2 = false;
				if (fieldInfo.IsInitOnly)
				{
					readOnly2 = true;
				}
				if (IgnoreAttributes != null)
				{
					bool flag2 = false;
					foreach (Type IgnoreAttribute2 in IgnoreAttributes)
					{
						if (fieldInfo.IsDefined(IgnoreAttribute2, inherit: false))
						{
							flag2 = true;
							break;
						}
					}
					if (flag2)
					{
						continue;
					}
				}
				string memberName2 = null;
				object[] customAttributes2 = fieldInfo.GetCustomAttributes(inherit: true);
				object[] array4 = customAttributes2;
				foreach (object obj2 in array4)
				{
					if (obj2 is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute2 = (DataMemberAttribute)obj2;
						if (dataMemberAttribute2.Name != "")
						{
							memberName2 = dataMemberAttribute2.Name;
						}
					}
				}
				if (!fieldInfo.IsLiteral)
				{
					GenericGetter genericGetter2 = CreateGetField(type, fieldInfo);
					if (genericGetter2 != null)
					{
						list.Add(new Getters
						{
							Getter = genericGetter2,
							Name = fieldInfo.Name,
							lcName = fieldInfo.Name.ToLowerInvariant(),
							memberName = memberName2,
							ReadOnly = readOnly2
						});
					}
				}
			}
			value = list.ToArray();
			_getterscache.Add(type, value);
			return value;
		}

		internal void ResetPropertyCache()
		{
			_propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>();
		}

		internal void ClearReflectionCache()
		{
			_tyname = new SafeDictionary<Type, string>(10);
			_typecache = new SafeDictionary<string, Type>(10);
			_constrcache = new SafeDictionary<Type, CreateObject>(10);
			_getterscache = new SafeDictionary<Type, Getters[]>(10);
			_propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>(10);
			_genericTypes = new SafeDictionary<Type, Type[]>(10);
			_genericTypeDef = new SafeDictionary<Type, Type>(10);
		}
	}
	internal class ReferenceEqualityComparer : IEqualityComparer, IEqualityComparer<object>
	{
		public static ReferenceEqualityComparer Default { get; } = new ReferenceEqualityComparer();


		public new bool Equals(object x, object y)
		{
			return x.Equals(y);
		}

		public int GetHashCode(object obj)
		{
			return RuntimeHelpers.GetHashCode(obj);
		}
	}
	internal sealed class SafeDictionary<TKey, TValue>
	{
		private readonly object _Padlock = new object();

		private readonly Dictionary<TKey, TValue> _Dictionary;

		public TValue this[TKey key]
		{
			get
			{
				lock (_Padlock)
				{
					return _Dictionary[key];
				}
			}
			set
			{
				lock (_Padlock)
				{
					_Dictionary[key] = value;
				}
			}
		}

		public SafeDictionary(int capacity)
		{
			_Dictionary = new Dictionary<TKey, TValue>(capacity);
		}

		public SafeDictionary()
		{
			_Dictionary = new Dictionary<TKey, TValue>();
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			lock (_Padlock)
			{
				return _Dictionary.TryGetValue(key, out value);
			}
		}

		public int Count()
		{
			lock (_Padlock)
			{
				return _Dictionary.Count;
			}
		}

		public void Add(TKey key, TValue value)
		{
			lock (_Padlock)
			{
				if (!_Dictionary.ContainsKey(key))
				{
					_Dictionary.Add(key, value);
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

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

		public override object? GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class Polyfills
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Contains(this string source, char c)
		{
			return source.IndexOf(c) != -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly Func<PropertyInfo, bool> IsInstance = (PropertyInfo property) => !(property.GetMethod ?? property.SetMethod).IsStatic;

		private static readonly Func<PropertyInfo, bool> IsInstancePublic = (PropertyInfo property) => IsInstance(property) && (property.GetMethod ?? property.SetMethod).IsPublic;

		public static Type? BaseType(this Type type)
		{
			return type.GetTypeInfo().BaseType;
		}

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

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

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

		public static Type? GetImplementationOfOpenGenericInterface(this Type type, Type openGenericType)
		{
			if (!openGenericType.IsGenericType || !openGenericType.IsInterface)
			{
				throw new ArgumentException("The type must be a generic type definition and an interface", "openGenericType");
			}
			if (IsGenericDefinitionOfType(type, openGenericType))
			{
				return type;
			}
			return type.FindInterfaces((Type t, object context) => IsGenericDefinitionOfType(t, context), openGenericType).FirstOrDefault();
			static bool IsGenericDefinitionOfType(Type t, object? context)
			{
				if (t.IsGenericType)
				{
					return t.GetGenericTypeDefinition() == (Type)context;
				}
				return false;
			}
		}

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

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

		public static bool IsRequired(this MemberInfo member)
		{
			return member.GetCustomAttributes(inherit: true).Any((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.RequiredMemberAttribute");
		}

		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 bool IsAssignableFrom(this Type type, Type source)
		{
			return type.IsAssignableFrom(source.GetTypeInfo());
		}

		public static bool IsAssignableFrom(this Type type, TypeInfo source)
		{
			return type.GetTypeInfo().IsAssignableFrom(source);
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			if (type.IsEnum())
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (type == typeof(bool))
			{
				return TypeCode.Boolean;
			}
			if (type == typeof(char))
			{
				return TypeCode.Char;
			}
			if (type == typeof(sbyte))
			{
				return TypeCode.SByte;
			}
			if (type == typeof(byte))
			{
				return TypeCode.Byte;
			}
			if (type == typeof(short))
			{
				return TypeCode.Int16;
			}
			if (type == typeof(ushort))
			{
				return TypeCode.UInt16;
			}
			if (type == typeof(int))
			{
				return TypeCode.Int32;
			}
			if (type == typeof(uint))
			{
				return TypeCode.UInt32;
			}
			if (type == typeof(long))
			{
				return TypeCode.Int64;
			}
			if (type == typeof(ulong))
			{
				return TypeCode.UInt64;
			}
			if (type == typeof(float))
			{
				return TypeCode.Single;
			}
			if (type == typeof(double))
			{
				return TypeCode.Double;
			}
			if (type == typeof(decimal))
			{
				return TypeCode.Decimal;
			}
			if (type == typeof(DateTime))
			{
				return TypeCode.DateTime;
			}
			if (type == typeof(string))
			{
				return TypeCode.String;
			}
			return TypeCode.Object;
		}

		public static bool IsDbNull(this object value)
		{
			return value?.GetType()?.FullName == "System.DBNull";
		}

		public static Type[] GetGenericArguments(this Type type)
		{
			return type.GetTypeInfo().GenericTypeArguments;
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			string name2 = name;
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name2);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetRuntimeField(name);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			Func<PropertyInfo, bool> predicate = (includeNonPublic ? IsInstance : IsInstancePublic);
			if (!type.IsInterface())
			{
				return type.GetRuntimeProperties().Where(predicate);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetRuntimeProperties().Where(predicate));
		}

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

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return from f in type.GetRuntimeFields()
				where !f.IsStatic && f.IsPublic
				select f;
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return from m in type.GetRuntimeMethods()
				where m.IsPublic && m.IsStatic
				select m;
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name2)) ?? throw new MissingMethodException("Expected to find a method named '" + name2 + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			string name2 = name;
			Type[] parameterTypes2 = parameterTypes;
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name2))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes2.Length)
					{
						return parameters.Zip(parameterTypes2, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name2));
		}

		public static MethodInfo? GetGetMethod(this PropertyInfo property, bool nonPublic)
		{
			MethodInfo methodInfo = property.GetMethod;
			if (!nonPublic && !methodInfo.IsPublic)
			{
				methodInfo = null;
			}
			return methodInfo;
		}

		public static MethodInfo? GetSetMethod(this PropertyInfo property)
		{
			return property.SetMethod;
		}

		public static IEnumerable<Type> GetInterfaces(this Type type)
		{
			return type.GetTypeInfo().ImplementedInterfaces;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			if (!(o.GetType() == type))
			{
				return o.GetType().GetTypeInfo().IsSubclassOf(type);
			}
			return true;
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo member)
		{
			return Attribute.GetCustomAttributes(member, typeof(TAttribute), inherit: true);
		}

		public static bool AcceptsNull(this MemberInfo member)
		{
			object[] customAttributes = member.DeclaringType.GetCustomAttributes(inherit: true);
			object obj = customAttributes.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
			int num = 0;
			if (obj != null)
			{
				Type type = obj.GetType();
				PropertyInfo property = type.GetProperty("Flag");
				num = (byte)property.GetValue(obj);
			}
			object[] customAttributes2 = member.GetCustomAttributes(inherit: true);
			object obj2 = customAttributes2.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
			PropertyInfo propertyInfo = (obj2?.GetType())?.GetProperty("NullableFlags");
			byte[] source = (byte[])propertyInfo.GetValue(obj2);
			return source.Any((byte x) => x == 2) || num == 2;
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	internal abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = 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 WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			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<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)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<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<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<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<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	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<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize<object>(parser);
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		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;
		}
	}
	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;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		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, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer(enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value, enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties, BuildTypeConverters())
				},
				{
					typeof(FsharpListNodeDeserializer),
					(Nothing _) => new FsharpListNodeDeserializer(BuildTypeInspector(), enumNamingConvention)
				}
			};
			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();
		}

		public 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)
		{
			IObjectFactory objectFactory2 = objectFactory;
			if (objectFactory2 == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, 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)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<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)
		{
			INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public DeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<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 Type 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<TInterface, 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 (!YamlDotNet.Helpers.DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[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()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	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<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	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; }

		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; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	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; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	internal interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(IParser parser, Type type);
	}
	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);
	}
	internal interface INamingConvention
	{
		string Apply(string value);

		string Reverse(string value);
	}
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer);
	}
	internal interface INodeTypeResolver
	{
		bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
	}
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		object? Read(string name, object target);
	}
	internal interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		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.");
		}
	}
	internal interface IObjectFactory
	{
		object Create(Type type);

		object? CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer);
	}
	internal interface IObjectGraphVisitor<TContext>
	{
		bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

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

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

		void VisitScalar(IObjectDescriptor scalar, TContext context, ObjectSerializer serializer);

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

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context, ObjectSerializer serializer);

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

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context, ObjectSerializer serializer);
	}
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

		T? GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface IRegistrationLocationSelectionSyntax<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<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	internal interface ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

		void Serialize(TextWriter writer, object? graph, Type type);

		void Serialize(IEmitter emitter, object? graph);

		void Serialize(IEmitter emitter, object? graph, Type type);
	}
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching);

		string GetEnumName(Type enumType, string name);

		string GetEnumValue(object enumValue);
	}
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	internal interface IValueDeserializer
	{
		object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	internal interface IValueSerializer
	{
		void SerializeValue(IEmitter emitter, object? value, Type? type);
	}
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	internal delegate object? ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer);

		void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		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;
			}
		}

		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;
			}
		}

		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, 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);
			}
		}

		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, 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, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		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((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.");
			}
		}

		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;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			Func<TComponent, TArgument> argumentBuilder2 = argumentBuilder;
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder2(inner)));
		}

		public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			TArgument argument2 = argument;
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument2)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor(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);
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public Type? ConverterType => baseDescriptor.ConverterType;

		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, object? value)
		{
			baseDescriptor.Write(target, value);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	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(object? graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public string Serialize(object? graph, Type type)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph, type);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, object? graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, object? graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, object? graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, object? graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		private void EmitDocument(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());
		}
	}
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		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;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				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);
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, 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 Dictionary<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, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			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<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<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((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((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().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<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<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<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()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			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());
		}

		public 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; }
	}
	internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = 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 WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			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)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<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<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<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 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();
		}
	}
	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;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		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, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					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, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties: false, BuildTypeConverters())
				}
			};
			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();
		}

		public 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)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public StaticDeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<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)
		{
			INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
			return this;
		}

		public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<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 Type 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<TInterface, 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 + "'.");
			}
			typeMappings[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, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		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;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				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), NestedObjectSerializer);
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, 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 Dictionary<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, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			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<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<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((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, ScalarStyle.Plain, YamlFormatter.Default, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((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().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<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<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<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());
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	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);
			}
		}
	}
	internal sealed class TagMappings
	{
		private readonly Dictionary<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);
		}

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			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());
			}
		}

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

			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<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> 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 List<AttributeMapping> 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<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	internal sealed class YamlAttributeOverridesInspector : ReflectionTypeInspector
	{
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public Type? ConverterType => GetCustomAttribute<YamlConverterAttribute>()?.ConverterType ?? baseDescriptor.ConverterType;

			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, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				T attribute = overrides.GetAttribute<T>(classType, Name);
				return attribute ?? 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, object? container)
		{
			Type type2 = type;
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type2, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type2)));
			}
			return enumerable;
		}
	}
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

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

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(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;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	internal sealed class YamlConverterAttribute : Attribute
	{
		public Type ConverterType { get; }

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	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 virtual Func<object, ITypeInspector, INamingConvention, string> FormatEnum { get; set; } = delegate(object value, ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			string empty = string.Empty;
			empty = ((value != null) ? typeInspector.GetEnumValue(value) : string.Empty);
			return enumNamingConvention.Apply(empty);
		};


		public virtual Func<object, bool> PotentiallyQuoteEnums { get; set; } = (object _) => true;


		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
	{
	}
	[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;
		}

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		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(in start, in end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		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;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object? value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		private readonly IValueDeserializer innerDeserializer;

		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise value))
				{
					Mark start = @event.Start;
					Mark end = @event.End;
					throw new AnchorNotFoundException(in start, in 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 aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(anchorName))
				{
					aliasState2[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(anchorName, out ValuePromise value2))
				{
					aliasState3.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.typeInspector = typeInspector;
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			IParser parser2 = parser;
			SerializerState state2 = state;
			IValueDeserializer nestedObjectDeserializer2 = nestedObjectDeserializer;
			parser2.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser2, x, state2, nestedObjectDeserializer2);
			Mark start;
			Mark end;
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser2, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer2.DeserializeValue(r, t, state2, nestedObjectDeserializer2), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				start = @event?.Start ?? Mark.Empty;
				end = @event?.End ?? Mark.Empty;
				throw new YamlException(in start, in end, "Exception during deserialization", innerException);
			}
			start = @event?.Start ?? Mark.Empty;
			end = @event?.End ?? Mark.Empty;
			throw new YamlException(in start, in end, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
		{
			foreach (INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	internal interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly Dictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out object 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)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object 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();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (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)
		{
			string separator2 = separator;
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator2 + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class TypeConverter
	{
		public static T ChangeType<T>(object? value, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture, enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			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())
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (destinationType.IsEnum())
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			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 };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in type2.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.InnerException;
						}
					}
				}
			}
			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.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [NotNullWhen(true)] out IYamlTypeConverter? typeConverter)
		{
			(bool, IYamlTypeConverter) orAdd = YamlDotNet.Helpers.DictionaryExtensions.GetOrAdd(cache, type, (Type t, IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public IYamlTypeConverter GetConverterByType(Type converter)
		{
			IYamlTypeConverter[] array = typeConverters;
			foreach (IYamlTypeConverter yamlTypeConverter in array)
			{
				if (yamlTypeConverter.GetType() == converter)
				{
					return yamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, IYamlTypeConverter[] typeConverters)
		{
			foreach (IYamlTypeConverter yamlTypeConverter in typeConverters)
			{
				if (yamlTypeConverter.Accepts(type))
				{
					return (true, yamlTypeConverter);
				}
			}
			return (false, null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class StaticTypeResolver : ITypeResolver
	{
		public virtual Type Resolve(Type staticType, 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
{
	internal class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return YamlDotNet.Helpers.DictionaryExtensions.GetOrAdd(orAdd, name, delegate(string n, (Type enumType, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumType2, typeInspector) = context;
				return typeInspector.GetEnumName(enumType2, n);
			}, (enumType, innerTypeDescriptor));
		}

		public override string GetEnumValue(object enumValue)
		{
			return YamlDotNet.Helpers.DictionaryExtensions.GetOrAdd(enumValueCache, enumValue, delegate(object _, (object enumValue, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumValue2, typeInspector) = context;
				return typeInspector.GetEnumValue(enumValue2);
			}, (enumValue, innerTypeDescriptor));
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return YamlDotNet.Helpers.DictionaryExtensions.GetOrAdd(cache, type, delegate(Type t, (object container, ITypeInspector innerTypeDescriptor) context)
			{
				var (container2, typeInspector) = context;
				return typeInspector.GetProperties(t, container2).ToList();
			}, (container, innerTypeDescriptor));
		}
	}
	internal 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 string GetEnumName(Type enumType, string name)
		{
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumName(enumType, name);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumType,name", "Name not found on enum type");
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				throw new ArgumentNullException("enumValue");
			}
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumValue(enumValue);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumValue", $"Value not found for ({enumValue})");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			object container2 = container;
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type2, container2));
		}
	}
	internal 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 string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	internal class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal class ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			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;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(T), inherit: true);
				return (T)customAttributes.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, object? container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal class ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			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;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.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, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class ReflectionTypeInspector : TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching)
		{
			string name2 = name;
			IEnumerable<IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name2
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name2, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name2 + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name2 + "' 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;
		}
	}
	internal class WritablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			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;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.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, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((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
{
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly Dictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value, ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment 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, ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer)
		{
		}

		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 AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	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(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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, serializer);
		}
	}
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				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(propertyDescriptor, value, context, serializer);
		}
	}
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		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, ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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, serializer);
			}
			return false;
		}
	}
	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;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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, serializer);
		}
	}
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>()));
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context, ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer);

		protected abstract void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		protected readonly 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<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(IPropertyDescriptor? propertyDescriptor, object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			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(propertyDescriptor, value, context, serializer))
			{
				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, serializer);
					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, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			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);
				ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(IPropertyDescriptor propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache 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 = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				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, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	internal class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<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 Type 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)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, 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[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			Type attributeType2 = attributeType;
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType2];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType2, inherit: true).Length != 0).ToArray();
			});
		}
	}
	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);
		}
	}
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		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, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.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 implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	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);

		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, out IDictionary? dictionary, 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
	{
		bool INodeTypeResolver.Resolve(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;
		}
	}
	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}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Mark start = nodeEvent.Start;
				Mark end = nodeEvent.End;
				throw new YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	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(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type 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
	{
		bool INodeTypeResolver.Resolve(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
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			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;

			public object SyncRoot => 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();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public ArrayNodeDeserializer(INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	internal abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			IList result2 = result;
			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(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public CollectionNodeDeserializer(IObjectFactory objectFactory, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != 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, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, INamingConvention enumNamingConvention, ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			Action<int, object?> promiseResolvedHandler2 = promiseResolvedHandler;
			IList result2 = result;
			Type tItem2 = tItem;
			INamingConvention enumNamingConvention2 = enumNamingConvention;
			ITypeInspector typeInspector2 = typeInspector;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem2);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(tItem2.IsValueType() ? Activator.CreateInstance(tItem2) : null);
					if (promiseResolvedHandler2 != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler2(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result2[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem2, enumNamingConvention2, typeInspector2);
						};
					}
				}
				else
				{
					result2.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem2, enumNamingConvention2, typeInspector2));
				}
			}
		}
	}
	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(in start, in end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			IDictionary result2 = 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 += delegate(object? v)
						{
							result2[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result2, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result2[key] = v;
				};
			}
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.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, rootDeserializer);
			return true;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class FsharpListNodeDeserializer : INodeDeserializer
	{
		private readonly ITypeInspector typeInspector;

		private readonly INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static 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;
		}
	}
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Mark start = Mark.Empty;
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
					goto IL_0267;
				}
				catch (SerializationException ex)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Exception during deserialization", innerException);
				}
				IL_0267:
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, IPropertyDescriptor property, YamlDotNet.Core.Events.Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	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 ITypeInspector typeInspector;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, ITypeInspector typeInspector, YamlFormatter formatter, INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, 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, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		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("_", ""), CultureInfo.InvariantCulture);
					}
				}
				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, 
			});
		}

		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:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object 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;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			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;

			public object SyncRoot => 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();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			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, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			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;
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			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, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			IList result2 = result;
			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)
				{
					int index = result2.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			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, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Func<IParser, Type, object?> nestedObjectDeserializer2 = nestedObjectDeserializer;
			IParser parser2 = parser;
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser2, expectedType, (Type type) => nestedObjectDeserializer2(parser2, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			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
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToPascalCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	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);
		}
	}
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		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 = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? ScalarStyle.Plain : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					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);
		}
	}
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		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|\\s.*)$";

		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;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: 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);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		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 = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? 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;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	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
{
	internal class DateTime8601Converter : IYamlTypeConverter
	{
		private readonly ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	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, 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, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			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;
		}
	}
	internal class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(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, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			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));
		}
	}
	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, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			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));
		}
	}
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			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
{
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		private readonly LinkedList<ParsingEvent> buffer;

		private LinkedListNode<ParsingEvent>? current;

		public ParsingEvent? Current => current?.Value;

		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;
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type expectedType2 = expectedType;
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType2));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType3 = expectedType2;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType3 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType3, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, out Type? suggestedType);
	}
	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, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => targetKey == scalar.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar2 && typeMapping.TryGetValue(scalar2.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	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, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.Scalar key, out ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class DocumentLoadingState
	{
		private readonly Dictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly List<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");
			}
			anchors[node.Anchor] = node;
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		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);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	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 static 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(">");
			}
		}
	}
	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.");
		}

		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;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class YamlDocument
	{
		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()
		{
			AnchorAssigningVisitor anchorAssigningVisitor = new AnchorAssigningVisitor();
			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);
		}
	}
	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);
				if (!children.TryAdd(yamlNode, yamlNode2))
				{
					Mark start = yamlNode.Start;
					Mark end = yamlNode.End;
					throw new YamlException(in start, in end, $"Duplicate key {yamlNode}");
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(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);
		}

		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 YamlNode 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 = (child.Value.Anchor.IsEmpty ? YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value) : YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			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();
			}
		}

		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)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						yamlNode = text ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	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 YamlNode 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>)((string i) => i)));
		}

		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;
		}
	}
	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}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			string text = scalar.Value;
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		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);
		}

		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);
		}

		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());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly List<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);
		}

		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());
		}
	}
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly List<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();
		}
	}
	[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);
		}
	}
	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
{
	internal class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	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<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;
		}
	}
	internal static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		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();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		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();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(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();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			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, 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();
		}
	}
	internal interface IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		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.ContainsKey(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((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		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.ContainsValue(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((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;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				TKey key2 = key;
				if (dictionary.ContainsKey(key2))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
					dictionary[key2] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key2, value);
				}
				else
				{
					Add(key2, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			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(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		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)
		{
			TKey key2 = key;
			if (dictionary.ContainsKey(key2))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
				list.RemoveAt(index);
				if (!dictionary.Remove(key2))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(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;
			}
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	internal readonly struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		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);
		}

		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);
		}

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct CharacterAnalyzer<TBuffer> where TBuffer : ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = 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 c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	internal static class Constants
	{
		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 long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1L;
		}

		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 = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	internal class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			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 bool useUtf16SurrogatePair;

		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;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			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;
			foreach (ParsingEvent @event in events)
			{
				switch (@event.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;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				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;
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string @string = output.Encoding.GetString(bytes, 0, bytes.Length);
				return @string.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static 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;
				foreach (TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					TagDirective[] defaultTagDirectives2 = Constants.DefaultTagDirectives;
					foreach (TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, 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 static TagDirectiveCollection NonDefaultTagsAmong(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 static 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;
			}
			if (scalarStyle == ScalarStyle.ForcePlain)
			{
				scalarStyle = ScalarStyle.Plain;
			}
			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.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							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 static int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		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)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				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);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		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, delegate(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(CultureInfo.InvariantCulture, "%{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.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	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 bool UseUtf16SurrogatePairs { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			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;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		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, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithUtf16SurrogatePairs()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	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;
		}
	}
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class InsertionQueue<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();
		}
	}
	internal interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		YamlDotNet.Core.Tokens.Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[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;
		}
	}
	internal readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		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()));
		}

		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;
		}

		public static bool operator ==(Mark left, Mark right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(Mark left, Mark right)
		{
			return !(left == right);
		}

		public static bool operator <(Mark left, Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(Mark left, Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(Mark left, Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(Mark left, Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	internal sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class MergingParser : IParser
	{
		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 static IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(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;
					}
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			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(in start, in 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(in start, in 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;

		public ParsingEvent? Current => 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(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(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, 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 static 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 @object = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(@object.Clone);
		}
	}
	internal class Parser : IParser
	{
		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;

		private YamlDotNet.Core.Tokens.Token? currentToken;

		private VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public ParsingEvent? Current { get; private set; }

		private YamlDotNet.Core.Tokens.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 YamlDotNet.Core.Events.StreamStart ParseStreamStart()
		{
			YamlDotNet.Core.Tokens.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(in start, in end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			start = streamStart.Start;
			end = streamStart.End;
			return new YamlDotNet.Core.Events.StreamStart(in start, in 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.");
			}
			YamlDotNet.Core.Tokens.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(in start2, in 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(in start2, in end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		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(in start, in 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(in start, in 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(in start, in 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(in position);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static YamlDotNet.Core.Events.Scalar ProcessEmptyScalar(in 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(in start, in end, error.Value);
			}
			YamlDotNet.Core.Tokens.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();
				ParsingEvent 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(in start, in 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(in start, in 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(in start, in 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(in start, in 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();
				ParsingEvent 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(in start, in end, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && !(scanner.Current is FlowMappingEnd) && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new SemanticErrorException(in start, in 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(in start, in end, "While parsing a node, did not find expected node content.");
		}

		private YamlDotNet.Core.Events.DocumentEnd ParseDocumentEnd()
		{
			YamlDotNet.Core.Tokens.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(in start, in 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();
			}
			YamlDotNet.Core.Tokens.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(in position);
			}
			Mark start;
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				start = blockEnd.Start;
				end = blockEnd.End;
				ParsingEvent result = new SequenceEnd(in start, in end);
				Skip();
				return result;
			}
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in start, in end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			YamlDotNet.Core.Tokens.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(in position);
			}
			state = states.Pop();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new SequenceEnd(in start, in end);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			YamlDotNet.Core.Tokens.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(in position);
			}
			Mark position2;
			if (token is Value value)
			{
				Skip();
				position2 = value.End;
				return ProcessEmptyScalar(in 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;
				ParsingEvent result = new MappingEnd(in position2, in end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error error)
			{
				position2 = error.Start;
				end = error.End;
				throw new SyntaxErrorException(in position2, in end, error.Value);
			}
			position2 = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in position2, in end, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			YamlDotNet.Core.Tokens.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(in position);
			}
			Mark start;
			if (token is Error error)
			{
				start = error.Start;
				Mark end = error.End;
				throw new SemanticErrorException(in start, in end, error.Value);
			}
			state = ParserState.BlockMappingKey;
			start = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in start);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			YamlDotNet.Core.Tokens.Token token = GetCurrentToken();
			Mark start;
			Mark end;
			ParsingEvent result;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					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;
			result = new SequenceEnd(in start, in end);
			Skip();
			return result;
		}

		private ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			YamlDotNet.Core.Tokens.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(in position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			YamlDotNet.Core.Tokens.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(in position);
		}

		private MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			YamlDotNet.Core.Tokens.Token token = GetCurrentToken();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			YamlDotNet.Core.Tokens.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(in start, in 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(in 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(in start, in end);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			YamlDotNet.Core.Tokens.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(in position);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<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<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(in start, in end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<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<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<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: MaybeNull]
		public static T? Peek<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<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)] out YamlDotNet.Core.Events.Scalar? key, [MaybeNullWhen(false)] 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 flag = selector(scalar);
					parser.MoveNext();
					if (flag)
					{
						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,
		ForcePlain
	}
	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<long> indents = new Stack<long>();

		private readonly InsertionQueue<YamlDotNet.Core.Tokens.Token> tokens = new InsertionQueue<YamlDotNet.Core.Tokens.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 bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private long indent = -1L;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		private YamlDotNet.Core.Tokens.Token? previous;

		private Anchor? previousAnchor;

		private YamlDotNet.Core.Tokens.Scalar? lastScalar;

		private readonly int maxKeySize;

		private static readonly byte[] EmptyBytes = Array.Empty<byte>();

		public bool SkipComments { get; private set; }

		public YamlDotNet.Core.Tokens.Token? Current { get; private set; }

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && 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)
			: this(input, skipComments, 1024)
		{
		}

		public Scanner(TextReader input, bool skipComments, int maxKeySize)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
			this.maxKeySize = maxKeySize;
		}

		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 + maxKeySize < 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 == 0L && 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(in start, in 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(in start, in start));
		}

		private void UnrollIndent(long column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark start = cursor.Mark();
					tokens.Enqueue(new BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			YamlDotNet.Core.Tokens.Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private YamlDotNet.Core.Tokens.Token? ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			YamlDotNet.Core.Tokens.Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in 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(in start, in end, "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in 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(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				InsertionQueue<YamlDotNet.Core.Tokens.Token> insertionQueue = tokens;
				Mark end2 = cursor.Mark();
				insertionQueue.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in end, in end2));
				return;
			}
			YamlDotNet.Core.Tokens.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(in end, in end));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			YamlDotNet.Core.Tokens.Token item = ((!isSequenceToken) ? ((YamlDotNet.Core.Tokens.Token)new FlowMappingStart(in start, in start)) : ((YamlDotNet.Core.Tokens.Token)new FlowSequenceStart(in start, in start)));
			tokens.Enqueue(item);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			YamlDotNet.Core.Tokens.Token token = null;
			YamlDotNet.Core.Tokens.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(in start, in start);
			}
			else
			{
				item = new FlowMappingEnd(in start, in 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(in start, in 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(in start, in 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<YamlDotNet.Core.Tokens.Token> insertionQueue = tokens;
			start = cursor.Mark();
			insertionQueue.Enqueue(new BlockEntry(in start2, in start));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(in start, in 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<YamlDotNet.Core.Tokens.Token> insertionQueue = tokens;
			Mark end = cursor.Mark();
			insertionQueue.Enqueue(new Key(in start2, in end));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			Mark start;
			if (simpleKey.IsPossible)
			{
				InsertionQueue<YamlDotNet.Core.Tokens.Token> insertionQueue = tokens;
				int index = simpleKey.TokenNumber - tokensParsed;
				start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				insertionQueue.Insert(index, new Key(in start, in 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 == 0L && simpleKey.LineOffset == 0L)
					{
						InsertionQueue<YamlDotNet.Core.Tokens.Token> insertionQueue2 = tokens;
						int count = tokens.Count;
						start = simpleKey.Mark;
						Mark end = simpleKey.Mark;
						insertionQueue2.Insert(count, new Key(in start, in end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<YamlDotNet.Core.Tokens.Token> insertionQueue3 = tokens;
			start = cursor.Mark();
			insertionQueue3.Enqueue(new Value(in start2, in start));
		}

		private void RollIndent(long column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				YamlDotNet.Core.Tokens.Token item = ((!isSequence) ? ((YamlDotNet.Core.Tokens.Token)new BlockMappingStart(in position, in position)) : ((YamlDotNet.Core.Tokens.Token)new BlockSequenceStart(in position, in 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 YamlDotNet.Core.Tokens.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(in start, in 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 Tag 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(in start, in 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(in start, in 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 YamlDotNet.Core.Tokens.Scalar 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;
						long currentIndent = 0L;
						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(in start, in 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(in start, in 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(in start, in 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(in start, in 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.GetValueOrDefault())
							{
								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((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							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 long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine.GetValueOrDefault())
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine.GetValueOrDefault())
			{
				long 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(in end, in 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(in end, in end2, "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			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(in start, in end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in 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(in start, in 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(in start, in 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(in start, in 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(in start, in 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(in start, in 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((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									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;
							long 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 InvalidOperationException();
									}
									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(in start, in 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(in start, in end, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(in 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(in start, in end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in 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 VersionDirective ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private TagDirective ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in 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(in start, in end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(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(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					Mark start2 = cursor.Mark();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start2, in end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private string ScanUriEscapes(in 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(in start, in 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(in start, in 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(in start, in 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(in start, in 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(in start, in 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(in start, in end, "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in 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(in start, in 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);
			}
		}
	}
	internal class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long 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, IResettable
	{
		public string Value { get; set; } = string.Empty;


		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		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;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	internal sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	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));
		}
	}
	internal readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		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);
		}

		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);
		}

		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;
		}

		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());
		}
	}
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(in Mark.Empty, in Mark.Empty, message)
		{
		}

		public YamlException(in Mark start, in Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(in Mark.Empty, in 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(in start, in 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(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	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(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	internal sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Key(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	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(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	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(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	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(in start, in 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;
		}

		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 Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Value : Token
	{
		public Value()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Value(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	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(in start, in end)
		{
			Version = version;
		}

		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.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

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

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;


		public int MaximumRetainedCapacity { get; set; } = 4096;


		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly StringLookAheadBuffer Buffer;

			private readonly ObjectPool<StringLookAheadBuffer> pool;

			public BufferWrapper(StringLookAheadBuffer buffer, ObjectPool<StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

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

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			StringLookAheadBuffer stringLookAheadBuffer = Pool.Get();
			stringLookAheadBuffer.Value = value;
			return new BufferWrapper(stringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(in start, in 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);
		}
	}
	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(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	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(in start, in 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);
		}
	}
	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(in start, in 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 Mark start, in Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	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);
	}
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public MappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	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(in start, in 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; }

		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	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);
		}
	}
	internal sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public SequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	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
	}
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

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

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

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

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

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

		public string[] Members { get; }

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

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

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

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace Groups
{
	[PublicAPI]
	internal class API
	{
		public static event Action? joinedGroup;

		public static event Action? leftGroup;

		public static event Action<PlayerReference>? memberJoined;

		public static event Action<PlayerReference>? memberLeft;

		public static event Action<PlayerReference>? leaderChanged;

		public static event Action<PlayerReference, GameObject>? invitationReceived;

		public static event Action<PlayerReference, GameObject>? uiUpdate;

		internal static void InvokeGroupJoined()
		{
			API.joinedGroup?.Invoke();
		}

		internal static void InvokeGroupLeft()
		{
			API.leftGroup?.Invoke();
		}

		internal static void InvokeMemberJoined(PlayerReference player)
		{
			API.memberJoined?.Invoke(player);
		}

		internal static void InvokeMemberLeft(PlayerReference player)
		{
			API.memberLeft?.Invoke(player);
		}

		internal static void InvokeLeaderChanged(PlayerReference player)
		{
			API.leaderChanged?.Invoke(player);
		}

		internal static void InvokeInvitationReceived(PlayerReference player, GameObject invitationDialog)
		{
			API.invitationReceived?.Invoke(player, invitationDialog);
		}

		internal static void InvokeUIUpdate(PlayerReference player, GameObject playerRoot)
		{
			API.uiUpdate?.Invoke(player, playerRoot);
		}

		public static bool IsLoaded()
		{
			return false;
		}

		public static int GetMaxGroupSize()
		{
			return 0;
		}

		public static List<PlayerReference> GroupPlayers()
		{
			return new List<PlayerReference>();
		}

		public static PlayerReference? GetLeader()
		{
			return null;
		}

		public static bool CreateNewGroup()
		{
			return false;
		}

		public static bool WriteToGroup(string message)
		{
			return false;
		}

		public static bool LeaveGroup()
		{
			return false;
		}

		public static bool JoinGroup(PlayerReference targetPlayer)
		{
			return false;
		}

		public static bool PromoteToLeader(PlayerReference groupMember)
		{
			return false;
		}

		public static bool ForcePlayerIntoOwnGroup(PlayerReference targetPlayer)
		{
			return false;
		}

		public static PlayerReference? FindGroupMemberByPlayerId(long playerId)
		{
			if (playerId == Game.instance.m_playerProfile.GetPlayerID())
			{
				return PlayerReference.fromPlayerId(ZDOMan.GetSessionID());
			}
			return null;
		}
	}
	[PublicAPI]
	internal struct PlayerReference
	{
		public long peerId;

		public string name;

		public static PlayerReference fromPlayerId(long id)
		{
			return ZNet.instance.m_players.Where((PlayerInfo p) => ((ZDOID)(ref p.m_characterID)).UserID == id).Select(fromPlayerInfo).FirstOrDefault();
		}

		public static PlayerReference fromPlayerInfo(PlayerInfo playerInfo)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			PlayerReference result = default(PlayerReference);
			result.peerId = ((ZDOID)(ref playerInfo.m_characterID)).UserID;
			result.name = playerInfo.m_name ?? "";
			return result;
		}

		public static PlayerReference fromPlayer(Player player)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Player player2 = player;
			if (!((Object)(object)player2 == (Object)(object)Player.m_localPlayer))
			{
				return fromPlayerInfo(((IEnumerable<PlayerInfo>)ZNet.instance.m_players).FirstOrDefault((Func<PlayerInfo, bool>)((PlayerInfo info) => info.m_characterID == ((Character)player2).GetZDOID())));
			}
			PlayerReference result = default(PlayerReference);
			result.peerId = ZDOMan.GetSessionID();
			result.name = Game.instance.GetPlayerProfile().GetName();
			return result;
		}

		public static bool operator !=(PlayerReference a, PlayerReference b)
		{
			return !(a == b);
		}

		public static bool operator ==(PlayerReference a, PlayerReference b)
		{
			if (a.peerId == b.peerId)
			{
				return a.name == b.name;
			}
			return false;
		}

		public bool Equals(PlayerReference other)
		{
			return this == other;
		}

		public override bool Equals(object? obj)
		{
			if (obj is PlayerReference other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (peerId.GetHashCode() * 397) ^ (name?.GetHashCode() ?? 0);
		}

		public override string ToString()
		{
			return $"{peerId}:{name}";
		}

		public static PlayerReference fromString(string str)
		{
			string[] array = str.Split(new char[1] { ':' });
			PlayerReference result = default(PlayerReference);
			result.peerId = long.Parse(array[0]);
			result.name = array[1];
			return result;
		}
	}
}
namespace Guilds
{
	[PublicAPI]
	internal static class API
	{
		public delegate void AchievementCompleted(PlayerReference player, string achievment);

		public delegate void GuildJoined(Guild guild, PlayerReference player);

		public delegate void GuildLeft(Guild guild, PlayerReference player);

		public delegate void GuildCreated(Guild guild);

		public delegate void GuildDeleted(Guild guild);

		public static bool IsLoaded()
		{
			return false;
		}

		public static Guild? GetPlayerGuild(PlayerReference player)
		{
			return null;
		}

		public static Guild? GetPlayerGuild(Player player)
		{
			return GetPlayerGuild(PlayerReference.fromPlayer(player));
		}

		public static Guild? GetOwnGuild()
		{
			return GetPlayerGuild(PlayerReference.forOwnPlayer());
		}

		public static Guild? GetGuild(string name)
		{
			return null;
		}

		public static Guild? GetGuild(int id)
		{
			return null;
		}

		public static List<Guild> GetGuilds()
		{
			return new List<Guild>();
		}

		public static PlayerReference GetGuildLeader(Guild guild)
		{
			return guild.Members.FirstOrDefault<KeyValuePair<PlayerReference, GuildMember>>((KeyValuePair<PlayerReference, GuildMember> r) => r.Value.rank == Ranks.Leader).Key;
		}

		public static Guild? CreateGuild(string name, PlayerReference leader)
		{
			return null;
		}

		public static bool DeleteGuild(Guild guild)
		{
			return false;
		}

		public static bool RenameGuild(Guild guild, string newName)
		{
			return true;
		}

		public static bool SaveGuild(Guild guild)
		{
			return false;
		}

		public static bool AddPlayerToGuild(PlayerReference player, Guild guild)
		{
			if (GetPlayerGuild(player) == null)
			{
				guild.Members.Add(player, new GuildMember());
				SaveGuild(guild);
				return true;
			}
			return false;
		}

		public static bool RemovePlayerFromGuild(PlayerReference player)
		{
			Guild playerGuild = GetPlayerGuild(player);
			if (playerGuild != null)
			{
				playerGuild.Members.Remove(player);
				SaveGuild(playerGuild);
				return true;
			}
			return false;
		}

		public static Ranks GetPlayerRank(PlayerReference player)
		{
			return GetPlayerGuild(player)?.Members[player].rank ?? Ranks.Leader;
		}

		public static bool UpdatePlayerRank(PlayerReference player, Ranks newRank)
		{
			Guild playerGuild = GetPlayerGuild(player);
			if (playerGuild != null)
			{
				GuildMember guildMember = playerGuild.Members[player];
				guildMember.rank = newRank;
				playerGuild.Members[player] = guildMember;
				SaveGuild(playerGuild);
				return true;
			}
			return false;
		}

		public static IEnumerable<PlayerReference> GetOnlinePlayers(Guild? guild = null)
		{
			HashSet<PlayerReference> hashSet = new HashSet<PlayerReference>(ZNet.instance.m_players.Select(PlayerReference.fromPlayerInfo));
			if (guild != null)
			{
				return guild.Members.Keys.Where(hashSet.Contains);
			}
			foreach (PlayerReference item in GetGuilds().SelectMany((Guild g) => g.Members.Keys))
			{
				hashSet.Remove(item);
			}
			return hashSet;
		}

		public static Guild? GetOwnAppliedGuild()
		{
			return GetPlayerAppliedGuild(PlayerReference.forOwnPlayer());
		}

		public static Guild? GetPlayerAppliedGuild(PlayerReference player)
		{
			return null;
		}

		public static bool ApplyToGuild(PlayerReference player, string description, Guild guild)
		{
			RemovePlayerApplication(player);
			guild.Applications[player] = new Application
			{
				description = description
			};
			return SaveGuild(guild);
		}

		public static bool RemovePlayerApplication(PlayerReference player, Guild? guild = null)
		{
			Guild playerAppliedGuild = GetPlayerAppliedGuild(player);
			if (playerAppliedGuild != null && (guild == null || playerAppliedGuild == guild))
			{
				playerAppliedGuild.Applications.Remove(player);
				return SaveGuild(playerAppliedGuild);
			}
			return true;
		}

		public static void RegisterCustomData(Type type)
		{
		}

		public static T? GetCustomData<T>(Guild guild) where T : class
		{
			return null;
		}

		public static void SetCustomData<T>(Guild guild, T customData) where T : class
		{
		}

		public static void IncreaseAchievementProgress(Guild guild, string achievement, float increment = 1f)
		{
		}

		public static void RegisterOnAchievementCompleted(AchievementCompleted callback)
		{
		}

		public static void RegisterAchievement(string name, AchievementConfig config)
		{
		}

		internal static AchievementConfig? GetAchievementConfig(string achievement)
		{
			return null;
		}

		internal static IEnumerable<KeyValuePair<string, AchievementConfig>> AllAchievementConfigs()
		{
			return Array.Empty<KeyValuePair<string, AchievementConfig>>();
		}

		public static Sprite? GetGuildIcon(Guild guild)
		{
			return null;
		}

		public static Sprite? GetGuildIconById(int iconId)
		{
			return null;
		}

		public static int GetAchievementStage(Guild guild, AchievementConfig achievement)
		{
			return 0;
		}

		public static void RegisterOnGuildJoined(GuildJoined callback)
		{
		}

		public static void RegisterOnGuildLeft(GuildLeft callback)
		{
		}

		public static void RegisterOnGuildCreated(GuildCreated callback)
		{
		}

		public static void RegisterOnGuildDeleted(GuildDeleted callback)
		{
		}
	}
	[PublicAPI]
	internal class Guild
	{
		public string Name = "";

		public GuildGeneral General = new GuildGeneral();

		public Dictionary<PlayerReference, GuildMember> Members = new Dictionary<PlayerReference, GuildMember>();

		public Dictionary<PlayerReference, Application> Applications = new Dictionary<PlayerReference, Application>();

		public Dictionary<string, AchievementData> Achievements = new Dictionary<string, AchievementData>();

		public CustomData customData = new CustomData();
	}
	[PublicAPI]
	internal class GuildMember
	{
		public Ranks rank = Ranks.Member;

		public DateTime lastOnline = DateTime.Now;

		public Dictionary<int, Dictionary<string, int>> contribution = new Dictionary<int, Dictionary<string, int>>();
	}
	[PublicAPI]
	internal class GuildGeneral
	{
		public int id = 0;

		public string description = "";

		public int icon = 1;

		public int level = 0;

		public string color = "";
	}
	[PublicAPI]
	internal class Application
	{
		public DateTime applied = DateTime.Now;

		public string description = "";
	}
	[PublicAPI]
	internal class AchievementData
	{
		public float? progress = 0f;

		public List<DateTime> completed = new List<DateTime>();
	}
	[PublicAPI]
	internal class CustomData
	{
		internal Dictionary<Type, object> data = new Dictionary<Type, object>();

		internal Dictionary<string, object> unknown = new Dictionary<string, object>();
	}
	[PublicAPI]
	internal class AchievementConfig
	{
		public string name = "";

		public string description = "";

		public List<float> progress = new List<float> { 1f };

		public List<int>? guild = null;

		public List<int> level = new List<int>();

		public string icon = "";

		public bool first;

		public Dictionary<string, string> config = new Dictionary<string, string>();

		public T getConfigValue<T>(string name, T defaultValue = default(T))
		{
			return defaultValue;
		}
	}
	[PublicAPI]
	[TypeConverter(typeof(PlayerReferenceTypeConverter))]
	internal struct PlayerReference
	{
		public string id;

		public string name;

		public static PlayerReference fromPlayerInfo(PlayerInfo playerInfo)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			PlayerReference result = default(PlayerReference);
			result.id = ((object)(PlatformUserID)(ref playerInfo.m_userInfo.m_id)).ToString();
			result.name = playerInfo.m_name ?? "";
			return result;
		}

		public static PlayerReference fromPlayer(Player player)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Player player2 = player;
			return ((Object)(object)player2 == (Object)(object)Player.m_localPlayer) ? forOwnPlayer() : fromPlayerInfo(((IEnumerable<PlayerInfo>)ZNet.instance.m_players).FirstOrDefault((Func<PlayerInfo, bool>)((PlayerInfo info) => info.m_characterID == ((Character)player2).GetZDOID())));
		}

		public static PlayerReference forOwnPlayer()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			PlayerReference result = default(PlayerReference);
			IDistributionPlatform distributionPlatform = PlatformManager.DistributionPlatform;
			object obj;
			if (distributionPlatform == null)
			{
				obj = null;
			}
			else
			{
				PlatformUserID platformUserID = ((IUser)distributionPlatform.LocalUser).PlatformUserID;
				obj = ((object)(PlatformUserID)(ref platformUserID)).ToString();
			}
			if (obj == null)
			{
				obj = "";
			}
			result.id = (string)obj;
			result.name = Game.instance.GetPlayerProfile().GetName();
			return result;
		}

		public static bool operator !=(PlayerReference a, PlayerReference b)
		{
			return !(a == b);
		}

		public static bool operator ==(PlayerReference a, PlayerReference b)
		{
			return a.id == b.id && a.name == b.name;
		}

		public bool Equals(PlayerReference other)
		{
			return this == other;
		}

		public override bool Equals(object? obj)
		{
			return obj is PlayerReference other && Equals(other);
		}

		public override int GetHashCode()
		{
			return (id.GetHashCode() * 397) ^ name.GetHashCode();
		}

		public override string ToString()
		{
			return id + ":" + name;
		}

		public static PlayerReference fromString(string str)
		{
			string[] array = str.Split(new char[1] { ':' });
			PlayerReference result = default(PlayerReference);
			result.id = array[0];
			result.name = array[1];
			return result;
		}
	}
	internal class PlayerReferenceTypeConverter : System.ComponentModel.TypeConverter
	{
		public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object? value)
		{
			return PlayerReference.fromString(value?.ToString() ?? ":");
		}
	}
	internal enum Toggle
	{
		On = 1,
		Off = 0
	}
	internal enum Ranks
	{
		Leader,
		Coleader,
		Officer,
		Member
	}
}
namespace Jewelcrafting
{
	[PublicAPI]
	internal static class API
	{
		[PublicAPI]
		public class GemInfo
		{
			public readonly string gemPrefab;

			public readonly Dictionary<string, uint>? gemSeed;

			public readonly Sprite gemSprite;

			public readonly Dictionary<string, float> gemEffects;

			public readonly Dictionary<string, float[]> gemEffectsPowerRange;

			public GemInfo(string gemPrefab, Sprite gemSprite, Dictionary<string, float> gemEffects, Dictionary<string, float[]> gemEffectsPowerRange, Dictionary<string, uint>? gemSeed = null)
			{
				this.gemPrefab = gemPrefab;
				this.gemSeed = gemSeed;
				this.gemSprite = gemSprite;
				this.gemEffects = gemEffects;
				this.gemEffectsPowerRange = gemEffectsPowerRange;
				base..ctor();
			}
		}

		public delegate bool GemBreakHandler(ItemData? container, ItemData gem, int count = 1);

		public delegate bool ItemBreakHandler(ItemData? container);

		public delegate bool ItemMirroredHandler(ItemData? item);

		public static event Action? OnEffectRecalc;

		public static bool IsLoaded()
		{
			return false;
		}

		internal static void InvokeEffectRecalc()
		{
			API.OnEffectRecalc?.Invoke();
		}

		public static GameObject CreateNecklaceFromTemplate(string colorName, Color color)
		{
			return null;
		}

		public static GameObject CreateNecklaceFromTemplate(string colorName, Material material)
		{
			return null;
		}

		public static GameObject CreateRingFromTemplate(string colorName, Color color)
		{
			return null;
		}

		public static GameObject CreateRingFromTemplate(string colorName, Material material)
		{
			return null;
		}

		public static void MarkJewelry(GameObject jewelry)
		{
		}

		public static void AddGems(string type, string colorName, Color color)
		{
		}

		public static List<GameObject> AddGems(string type, string colorName, Material material, Color color)
		{
			return null;
		}

		public static GameObject AddDestructibleFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddDestructibleFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject AddUncutFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddUncutFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject AddAndRegisterUncutFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddAndRegisterUncutFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject AddShardFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddShardFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject[] AddTieredGemFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject[] AddTieredGemFromTemplate(string type, string colorName, Material material, Color color)
		{
			return null;
		}

		public static void AddGem(GameObject prefab, string colorName)
		{
		}

		public static void AddShard(GameObject prefab, string colorName)
		{
		}

		public static void AddDestructible(GameObject prefab, string colorName)
		{
		}

		public static void AddUncutGem(GameObject prefab, string colorName, ConfigEntry<float>? dropChance = null)
		{
		}

		public static void AddGemEffect<T>(string name, string? englishDescription = null, string? englishDescriptionDetailed = null) where T : struct
		{
		}

		public static void AddGemConfig(string yaml)
		{
		}

		public static T GetEffectPower<T>(this Player player, string name) where T : struct
		{
			return default(T);
		}

		public static List<GemInfo?> GetGems(ItemData item)
		{
			return new List<GemInfo>();
		}

		public static bool SetGems(ItemData item, List<GemInfo?> gems)
		{
			return false;
		}

		public static Sprite GetSocketBorder()
		{
			return null;
		}

		public static GameObject GetGemcuttersTable()
		{
			return null;
		}

		public static void AddParticleEffect(string prefabName, GameObject effect, VisualEffectCondition displayCondition)
		{
		}

		public static void SetSocketsLock(ItemData item, bool enabled)
		{
		}

		public static void OnGemBreak(GemBreakHandler callback)
		{
		}

		public static void OnItemBreak(ItemBreakHandler callback)
		{
		}

		public static void OnItemMirrored(ItemMirroredHandler callback)
		{
		}

		public static bool IsJewelryEquipped(Player player, string prefabName)
		{
			return false;
		}

		public static bool BlacklistItem(GameObject item)
		{
			return false;
		}

		public static Transform? GetJewelcraftingTooltipRoot(GameObject tooltip)
		{
			return null;
		}

		public static bool FillItemContainerTooltip(ItemData? item, Transform root, bool showInteract)
		{
			return false;
		}

		public static Color? GetSocketableItemColor(ItemData item)
		{
			return null;
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	internal abstract class PowerAttribute : Attribute
	{
		public abstract float Add(float a, float b);
	}
	internal class AdditivePowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return a + b;
		}
	}
	internal class MultiplicativePercentagePowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return ((1f + a / 100f) * (1f + b / 100f) - 1f) * 100f;
		}
	}
	internal class InverseMultiplicativePercentagePowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return (1f - (1f - a / 100f) * (1f - b / 100f)) * 100f;
		}
	}
	internal class MinPowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return Mathf.Min(a, b);
		}
	}
	internal class MaxPowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return Mathf.Max(a, b);
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	internal class OptionalPowerAttribute : Attribute
	{
		public readonly float DefaultValue;

		public OptionalPowerAttribute(float defaultValue)
		{
			DefaultValue = defaultValue;
		}
	}
	[Flags]
	internal enum VisualEffectCondition : uint
	{
		IsSkill = 0xFFFu,
		Swords = 1u,
		Knives = 2u,
		Clubs = 3u,
		Polearms = 4u,
		Spears = 5u,
		Blocking = 6u,
		Axes = 7u,
		Bows = 8u,
		Unarmed = 0xBu,
		Pickaxes = 0xCu,
		WoodCutting = 0xDu,
		Crossbows = 0xEu,
		IsItem = 0xFF000u,
		Helmet = 0x6000u,
		Chest = 0x7000u,
		Legs = 0xB000u,
		Hands = 0xC000u,
		Shoulder = 0x11000u,
		Tool = 0x13000u,
		GenericExtraAttributes = 0xFF000000u,
		Blackmetal = 0x40000000u,
		TwoHanded = 0x80000000u,
		SpecificExtraAttributes = 0xF00000u,
		Hammer = 0x113000u,
		Hoe = 0x213000u,
		Buckler = 0x100006u,
		Towershield = 0x200006u,
		FineWoodBow = 0x100008u,
		BowHuntsman = 0x200008u,
		BowDraugrFang = 0x300008u,
		PickaxeIron = 0x10000Cu,
		Club = 0x100003u
	}
}
[CompilerGenerated]
[ExcludeFromCodeCoverage]
internal static class GitVersionInformation
{
	public const string AssemblySemFileVer = "6.0.0.0";

	public const string AssemblySemVer = "6.0.0.0";

	public const string BranchName = "dev";

	public const string BuildMetaData = "";

	public const string CommitDate = "2026-02-27";

	public const string CommitsSinceVersionSource = "77";

	public const string EscapedBranchName = "dev";

	public const string FullBuildMetaData = "Branch.dev.Sha.49f74a68fe3ee189d4bba08c413c3069e25d65d4";

	public const string FullSemVer = "6.0.0-prerelease.77";

	public const string InformationalVersion = "6.0.0-prerelease.77+Branch.dev.Sha.49f74a68fe3ee189d4bba08c413c3069e25d65d4";

	public const string Major = "6";

	public const string MajorMinorPatch = "6.0.0";

	public const string Minor = "0";

	public const string Patch = "0";

	public const string PreReleaseLabel = "prerelease";

	public const string PreReleaseLabelWithDash = "-prerelease";

	public const string PreReleaseNumber = "77";

	public const string PreReleaseTag = "prerelease.77";

	public const string PreReleaseTagWithDash = "-prerelease.77";

	public const string SemVer = "6.0.0-prerelease.77";

	public const string Sha = "49f74a68fe3ee189d4bba08c413c3069e25d65d4";

	public const string ShortSha = "49f74a6";

	public const string UncommittedChanges = "0";

	public const string VersionSourceSha = "8abcf944ae911e06eba76d7d9d8bec08a2955be1";

	public const string WeightedPreReleaseNumber = "77";
}
namespace LiteDB
{
	internal sealed class LiteCollection<T> : ILiteCollection<T>
	{
		[CompilerGenerated]
		private sealed class <GetBsonDocs>d__60 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<T> documents;

			public IEnumerable<T> <>3__documents;

			public LiteCollection<T> <>4__this;

			private IEnumerator<T> <>7__wrap1;

			private T <document>5__3;

			private BsonDocument <doc>5__4;

			private bool <removed>5__5;

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

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

			[DebuggerHidden]
			public <GetBsonDocs>d__60(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();
					}
				}
				<>7__wrap1 = null;
				<document>5__3 = default(T);
				<doc>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteCollection<T> liteCollection = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = documents.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						if (<removed>5__5 && liteCollection._id != null)
						{
							liteCollection._id.Setter(<document>5__3, <doc>5__4["_id"].RawValue);
						}
						<doc>5__4 = null;
						<document>5__3 = default(T);
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						<document>5__3 = <>7__wrap1.Current;
						<doc>5__4 = liteCollection._mapper.ToDocument(<document>5__3);
						<removed>5__5 = liteCollection.RemoveDocId(<doc>5__4);
						<>2__current = <doc>5__4;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<GetBsonDocs>d__60 <GetBsonDocs>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetBsonDocs>d__ = this;
				}
				else
				{
					<GetBsonDocs>d__ = new <GetBsonDocs>d__60(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetBsonDocs>d__.documents = <>3__documents;
				return <GetBsonDocs>d__;
			}

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

		private readonly string _collection;

		private readonly ILiteEngine _engine;

		private readonly List<BsonExpression> _includes;

		private readonly BsonMapper _mapper;

		private readonly EntityMapper _entity;

		private readonly MemberMapper _id;

		private readonly BsonAutoId _autoId;

		public string Name => _collection;

		public BsonAutoId AutoId => _autoId;

		public EntityMapper EntityMapper => _entity;

		public int Count()
		{
			return Query().Count();
		}

		public int Count(BsonExpression predicate)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return Query().Where(predicate).Count();
		}

		public int Count(string predicate, BsonDocument parameters)
		{
			return Count(BsonExpression.Create(predicate, parameters));
		}

		public int Count(string predicate, params BsonValue[] args)
		{
			return Count(BsonExpression.Create(predicate, args));
		}

		public int Count(Expression<Func<T, bool>> predicate)
		{
			return Count(_mapper.GetExpression(predicate));
		}

		public int Count(Query query)
		{
			return new LiteQueryable<T>(_engine, _mapper, _collection, query).Count();
		}

		public long LongCount()
		{
			return Query().LongCount();
		}

		public long LongCount(BsonExpression predicate)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return Query().Where(predicate).LongCount();
		}

		public long LongCount(string predicate, BsonDocument parameters)
		{
			return LongCount(BsonExpression.Create(predicate, parameters));
		}

		public long LongCount(string predicate, params BsonValue[] args)
		{
			return LongCount(BsonExpression.Create(predicate, args));
		}

		public long LongCount(Expression<Func<T, bool>> predicate)
		{
			return LongCount(_mapper.GetExpression(predicate));
		}

		public long LongCount(Query query)
		{
			return new LiteQueryable<T>(_engine, _mapper, _collection, query).Count();
		}

		public bool Exists(BsonExpression predicate)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return Query().Where(predicate).Exists();
		}

		public bool Exists(string predicate, BsonDocument parameters)
		{
			return Exists(BsonExpression.Create(predicate, parameters));
		}

		public bool Exists(string predicate, params BsonValue[] args)
		{
			return Exists(BsonExpression.Create(predicate, args));
		}

		public bool Exists(Expression<Func<T, bool>> predicate)
		{
			return Exists(_mapper.GetExpression(predicate));
		}

		public bool Exists(Query query)
		{
			return new LiteQueryable<T>(_engine, _mapper, _collection, query).Exists();
		}

		public BsonValue Min(BsonExpression keySelector)
		{
			if (string.IsNullOrEmpty(keySelector))
			{
				throw new ArgumentNullException("keySelector");
			}
			BsonDocument bsonDocument = Query().OrderBy(keySelector).Select(keySelector).ToDocuments()
				.First();
			return bsonDocument[bsonDocument.Keys.First()];
		}

		public BsonValue Min()
		{
			return Min("_id");
		}

		public K Min<K>(Expression<Func<T, K>> keySelector)
		{
			if (keySelector == null)
			{
				throw new ArgumentNullException("keySelector");
			}
			BsonExpression expression = _mapper.GetExpression(keySelector);
			BsonValue value = Min(expression);
			return (K)_mapper.Deserialize(typeof(K), value);
		}

		public BsonValue Max(BsonExpression keySelector)
		{
			if (string.IsNullOrEmpty(keySelector))
			{
				throw new ArgumentNullException("keySelector");
			}
			BsonDocument bsonDocument = Query().OrderByDescending(keySelector).Select(keySelector).ToDocuments()
				.First();
			return bsonDocument[bsonDocument.Keys.First()];
		}

		public BsonValue Max()
		{
			return Max("_id");
		}

		public K Max<K>(Expression<Func<T, K>> keySelector)
		{
			if (keySelector == null)
			{
				throw new ArgumentNullException("keySelector");
			}
			BsonExpression expression = _mapper.GetExpression(keySelector);
			BsonValue value = Max(expression);
			return (K)_mapper.Deserialize(typeof(K), value);
		}

		public bool Delete(BsonValue id)
		{
			if (id == null || id.IsNull)
			{
				throw new ArgumentNullException("id");
			}
			return _engine.Delete(_collection, new BsonValue[1] { id }) == 1;
		}

		public int DeleteAll()
		{
			return _engine.DeleteMany(_collection, null);
		}

		public int DeleteMany(BsonExpression predicate)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return _engine.DeleteMany(_collection, predicate);
		}

		public int DeleteMany(string predicate, BsonDocument parameters)
		{
			return DeleteMany(BsonExpression.Create(predicate, parameters));
		}

		public int DeleteMany(string predicate, params BsonValue[] args)
		{
			return DeleteMany(BsonExpression.Create(predicate, args));
		}

		public int DeleteMany(Expression<Func<T, bool>> predicate)
		{
			return DeleteMany(_mapper.GetExpression(predicate));
		}

		public ILiteQueryable<T> Query()
		{
			return new LiteQueryable<T>(_engine, _mapper, _collection, new Query()).Include(_includes);
		}

		public IEnumerable<T> Find(BsonExpression predicate, int skip = 0, int limit = int.MaxValue)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return Query().Include(_includes).Where(predicate).Skip(skip)
				.Limit(limit)
				.ToEnumerable();
		}

		public IEnumerable<T> Find(Query query, int skip = 0, int limit = int.MaxValue)
		{
			if (query == null)
			{
				throw new ArgumentNullException("query");
			}
			if (skip != 0)
			{
				query.Offset = skip;
			}
			if (limit != int.MaxValue)
			{
				query.Limit = limit;
			}
			return new LiteQueryable<T>(_engine, _mapper, _collection, query).ToEnumerable();
		}

		public IEnumerable<T> Find(Expression<Func<T, bool>> predicate, int skip = 0, int limit = int.MaxValue)
		{
			return Find(_mapper.GetExpression(predicate), skip, limit);
		}

		public T FindById(BsonValue id)
		{
			if (id == null || id.IsNull)
			{
				throw new ArgumentNullException("id");
			}
			return Find(BsonExpression.Create("_id = @0", id)).FirstOrDefault();
		}

		public T FindOne(BsonExpression predicate)
		{
			return Find(predicate).FirstOrDefault();
		}

		public T FindOne(string predicate, BsonDocument parameters)
		{
			return FindOne(BsonExpression.Create(predicate, parameters));
		}

		public T FindOne(BsonExpression predicate, params BsonValue[] args)
		{
			return FindOne(BsonExpression.Create(predicate, args));
		}

		public T FindOne(Expression<Func<T, bool>> predicate)
		{
			return FindOne(_mapper.GetExpression(predicate));
		}

		public T FindOne(Query query)
		{
			return Find(query).FirstOrDefault();
		}

		public IEnumerable<T> FindAll()
		{
			return Query().Include(_includes).ToEnumerable();
		}

		public ILiteCollection<T> Include<K>(Expression<Func<T, K>> keySelector)
		{
			if (keySelector == null)
			{
				throw new ArgumentNullException("keySelector");
			}
			BsonExpression expression = _mapper.GetExpression(keySelector);
			return Include(expression);
		}

		public ILiteCollection<T> Include(BsonExpression keySelector)
		{
			if (string.IsNullOrEmpty(keySelector))
			{
				throw new ArgumentNullException("keySelector");
			}
			LiteCollection<T> liteCollection = new LiteCollection<T>(_collection, _autoId, _engine, _mapper);
			liteCollection._includes.AddRange(_includes);
			liteCollection._includes.Add(keySelector);
			return liteCollection;
		}

		public bool EnsureIndex(string name, BsonExpression expression, bool unique = false)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name");
			}
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			return _engine.EnsureIndex(_collection, name, expression, unique);
		}

		internal bool EnsureVectorIndex(string name, BsonExpression expression, VectorIndexOptions options)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name");
			}
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			return _engine.EnsureVectorIndex(_collection, name, expression, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteCollectionVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex(string name, BsonExpression expression, VectorIndexOptions options)
		{
			return EnsureVectorIndex(name, expression, options);
		}

		public bool EnsureIndex(BsonExpression expression, bool unique = false)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			string name = Regex.Replace(expression.Source, "[^a-z0-9]", "", RegexOptions.IgnoreCase | RegexOptions.Compiled);
			return EnsureIndex(name, expression, unique);
		}

		internal bool EnsureVectorIndex(BsonExpression expression, VectorIndexOptions options)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			string name = Regex.Replace(expression.Source, "[^a-z0-9]", "", RegexOptions.IgnoreCase | RegexOptions.Compiled);
			return EnsureVectorIndex(name, expression, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteCollectionVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex(BsonExpression expression, VectorIndexOptions options)
		{
			return EnsureVectorIndex(expression, options);
		}

		public bool EnsureIndex<K>(Expression<Func<T, K>> keySelector, bool unique = false)
		{
			BsonExpression indexExpression = GetIndexExpression(keySelector);
			return EnsureIndex(indexExpression, unique);
		}

		internal bool EnsureVectorIndex<K>(Expression<Func<T, K>> keySelector, VectorIndexOptions options)
		{
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			BsonExpression indexExpression = GetIndexExpression(keySelector, convertEnumerableToMultiKey: false);
			return EnsureVectorIndex(indexExpression, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteCollectionVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex<K>(Expression<Func<T, K>> keySelector, VectorIndexOptions options)
		{
			return EnsureVectorIndex(keySelector, options);
		}

		public bool EnsureIndex<K>(string name, Expression<Func<T, K>> keySelector, bool unique = false)
		{
			BsonExpression indexExpression = GetIndexExpression(keySelector);
			return EnsureIndex(name, indexExpression, unique);
		}

		internal bool EnsureVectorIndex<K>(string name, Expression<Func<T, K>> keySelector, VectorIndexOptions options)
		{
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			BsonExpression indexExpression = GetIndexExpression(keySelector, convertEnumerableToMultiKey: false);
			return EnsureVectorIndex(name, indexExpression, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteCollectionVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex<K>(string name, Expression<Func<T, K>> keySelector, VectorIndexOptions options)
		{
			return EnsureVectorIndex(name, keySelector, options);
		}

		private BsonExpression GetIndexExpression<K>(Expression<Func<T, K>> keySelector, bool convertEnumerableToMultiKey = true)
		{
			BsonExpression bsonExpression = _mapper.GetIndexExpression(keySelector);
			if (convertEnumerableToMultiKey && typeof(K).IsEnumerable() && bsonExpression.IsScalar)
			{
				if (bsonExpression.Type != BsonExpressionType.Path)
				{
					throw new LiteException(0, "Expression `" + bsonExpression.Source + "` must return a enumerable expression");
				}
				bsonExpression = bsonExpression.Source + "[*]";
			}
			return bsonExpression;
		}

		public bool DropIndex(string name)
		{
			return _engine.DropIndex(_collection, name);
		}

		public BsonValue Insert(T entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			BsonDocument bsonDocument = _mapper.ToDocument(entity);
			bool flag = RemoveDocId(bsonDocument);
			_engine.Insert(_collection, new BsonDocument[1] { bsonDocument }, _autoId);
			BsonValue bsonValue = bsonDocument["_id"];
			if (flag)
			{
				_id.Setter(entity, bsonValue.RawValue);
			}
			return bsonValue;
		}

		public void Insert(BsonValue id, T entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			if (id == null || id.IsNull)
			{
				throw new ArgumentNullException("id");
			}
			BsonDocument bsonDocument = _mapper.ToDocument(entity);
			bsonDocument["_id"] = id;
			_engine.Insert(_collection, new BsonDocument[1] { bsonDocument }, _autoId);
		}

		public int Insert(IEnumerable<T> entities)
		{
			if (entities == null)
			{
				throw new ArgumentNullException("entities");
			}
			return _engine.Insert(_collection, GetBsonDocs(entities), _autoId);
		}

		[Obsolete("Use normal Insert()")]
		public int InsertBulk(IEnumerable<T> entities, int batchSize = 5000)
		{
			if (entities == null)
			{
				throw new ArgumentNullException("entities");
			}
			return _engine.Insert(_collection, GetBsonDocs(entities), _autoId);
		}

		[IteratorStateMachine(typeof(LiteCollection<>.<GetBsonDocs>d__60))]
		private IEnumerable<BsonDocument> GetBsonDocs(IEnumerable<T> documents)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetBsonDocs>d__60(-2)
			{
				<>4__this = this,
				<>3__documents = documents
			};
		}

		private bool RemoveDocId(BsonDocument doc)
		{
			if (_id != null && doc.TryGetValue("_id", out var value) && ((_autoId == BsonAutoId.Int32 && value.IsInt32 && value.AsInt32 == 0) || (_autoId == BsonAutoId.ObjectId && (value.IsNull || (value.IsObjectId && value.AsObjectId == ObjectId.Empty))) || (_autoId == BsonAutoId.Guid && value.IsGuid && value.AsGuid == Guid.Empty) || (_autoId == BsonAutoId.Int64 && value.IsInt64 && value.AsInt64 == 0L)))
			{
				doc.Remove("_id");
				return true;
			}
			return false;
		}

		public bool Update(T entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			BsonDocument bsonDocument = _mapper.ToDocument(entity);
			return _engine.Update(_collection, new BsonDocument[1] { bsonDocument }) > 0;
		}

		public bool Update(BsonValue id, T entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			if (id == null || id.IsNull)
			{
				throw new ArgumentNullException("id");
			}
			BsonDocument bsonDocument = _mapper.ToDocument(entity);
			bsonDocument["_id"] = id;
			return _engine.Update(_collection, new BsonDocument[1] { bsonDocument }) > 0;
		}

		public int Update(IEnumerable<T> entities)
		{
			if (entities == null)
			{
				throw new ArgumentNullException("entities");
			}
			return _engine.Update(_collection, entities.Select((T x) => _mapper.ToDocument(x)));
		}

		public int UpdateMany(BsonExpression transform, BsonExpression predicate)
		{
			if (transform == null)
			{
				throw new ArgumentNullException("transform");
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			if (transform.Type != BsonExpressionType.Document)
			{
				throw new ArgumentException("Extend expression must return a document. Eg: `col.UpdateMany('{ Name: UPPER(Name) }', 'Age > 10')`");
			}
			return _engine.UpdateMany(_collection, transform, predicate);
		}

		public int UpdateMany(Expression<Func<T, T>> extend, Expression<Func<T, bool>> predicate)
		{
			if (extend == null)
			{
				throw new ArgumentNullException("extend");
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			BsonExpression expression = _mapper.GetExpression(extend);
			BsonExpression expression2 = _mapper.GetExpression(predicate);
			if (expression.Type != BsonExpressionType.Document)
			{
				throw new ArgumentException("Extend expression must return an anonymous class to be merge with entities. Eg: `col.UpdateMany(x => new { Name = x.Name.ToUpper() }, x => x.Age > 10)`");
			}
			return _engine.UpdateMany(_collection, expression, expression2);
		}

		public bool Upsert(T entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			return Upsert(new T[1] { entity }) == 1;
		}

		public int Upsert(IEnumerable<T> entities)
		{
			if (entities == null)
			{
				throw new ArgumentNullException("entities");
			}
			return _engine.Upsert(_collection, GetBsonDocs(entities), _autoId);
		}

		public bool Upsert(BsonValue id, T entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			if (id == null || id.IsNull)
			{
				throw new ArgumentNullException("id");
			}
			BsonDocument bsonDocument = _mapper.ToDocument(entity);
			bsonDocument["_id"] = id;
			return _engine.Upsert(_collection, new BsonDocument[1] { bsonDocument }, _autoId) > 0;
		}

		internal LiteCollection(string name, BsonAutoId autoId, ILiteEngine engine, BsonMapper mapper)
		{
			_collection = name ?? mapper.ResolveCollectionName(typeof(T));
			_engine = engine;
			_mapper = mapper;
			_includes = new List<BsonExpression>();
			if (typeof(T) == typeof(BsonDocument))
			{
				_entity = null;
				_id = null;
				_autoId = autoId;
				return;
			}
			_entity = mapper.GetEntityMapper(typeof(T));
			_entity.WaitForInitialization();
			_id = _entity.Id;
			if (_id != null && _id.AutoId)
			{
				_autoId = ((_id.DataType == typeof(int) || _id.DataType == typeof(int?)) ? BsonAutoId.Int32 : ((_id.DataType == typeof(long) || _id.DataType == typeof(long?)) ? BsonAutoId.Int64 : ((_id.DataType == typeof(Guid) || _id.DataType == typeof(Guid?)) ? BsonAutoId.Guid : BsonAutoId.ObjectId)));
			}
			else
			{
				_autoId = autoId;
			}
		}
	}
	internal interface ILiteCollection<T>
	{
		string Name { get; }

		BsonAutoId AutoId { get; }

		EntityMapper EntityMapper { get; }

		ILiteCollection<T> Include<K>(Expression<Func<T, K>> keySelector);

		ILiteCollection<T> Include(BsonExpression keySelector);

		bool Upsert(T entity);

		int Upsert(IEnumerable<T> entities);

		bool Upsert(BsonValue id, T entity);

		bool Update(T entity);

		bool Update(BsonValue id, T entity);

		int Update(IEnumerable<T> entities);

		int UpdateMany(BsonExpression transform, BsonExpression predicate);

		int UpdateMany(Expression<Func<T, T>> extend, Expression<Func<T, bool>> predicate);

		BsonValue Insert(T entity);

		void Insert(BsonValue id, T entity);

		int Insert(IEnumerable<T> entities);

		int InsertBulk(IEnumerable<T> entities, int batchSize = 5000);

		bool EnsureIndex(string name, BsonExpression expression, bool unique = false);

		bool EnsureIndex(BsonExpression expression, bool unique = false);

		bool EnsureIndex<K>(Expression<Func<T, K>> keySelector, bool unique = false);

		bool EnsureIndex<K>(string name, Expression<Func<T, K>> keySelector, bool unique = false);

		bool DropIndex(string name);

		ILiteQueryable<T> Query();

		IEnumerable<T> Find(BsonExpression predicate, int skip = 0, int limit = int.MaxValue);

		IEnumerable<T> Find(Query query, int skip = 0, int limit = int.MaxValue);

		IEnumerable<T> Find(Expression<Func<T, bool>> predicate, int skip = 0, int limit = int.MaxValue);

		T FindById(BsonValue id);

		T FindOne(BsonExpression predicate);

		T FindOne(string predicate, BsonDocument parameters);

		T FindOne(BsonExpression predicate, params BsonValue[] args);

		T FindOne(Expression<Func<T, bool>> predicate);

		T FindOne(Query query);

		IEnumerable<T> FindAll();

		bool Delete(BsonValue id);

		int DeleteAll();

		int DeleteMany(BsonExpression predicate);

		int DeleteMany(string predicate, BsonDocument parameters);

		int DeleteMany(string predicate, params BsonValue[] args);

		int DeleteMany(Expression<Func<T, bool>> predicate);

		int Count();

		int Count(BsonExpression predicate);

		int Count(string predicate, BsonDocument parameters);

		int Count(string predicate, params BsonValue[] args);

		int Count(Expression<Func<T, bool>> predicate);

		int Count(Query query);

		long LongCount();

		long LongCount(BsonExpression predicate);

		long LongCount(string predicate, BsonDocument parameters);

		long LongCount(string predicate, params BsonValue[] args);

		long LongCount(Expression<Func<T, bool>> predicate);

		long LongCount(Query query);

		bool Exists(BsonExpression predicate);

		bool Exists(string predicate, BsonDocument parameters);

		bool Exists(string predicate, params BsonValue[] args);

		bool Exists(Expression<Func<T, bool>> predicate);

		bool Exists(Query query);

		BsonValue Min(BsonExpression keySelector);

		BsonValue Min();

		K Min<K>(Expression<Func<T, K>> keySelector);

		BsonValue Max(BsonExpression keySelector);

		BsonValue Max();

		K Max<K>(Expression<Func<T, K>> keySelector);
	}
	internal interface ILiteDatabase : IDisposable
	{
		BsonMapper Mapper { get; }

		ILiteStorage<string> FileStorage { get; }

		int UserVersion { get; set; }

		TimeSpan Timeout { get; set; }

		bool UtcDate { get; set; }

		long LimitSize { get; set; }

		int CheckpointSize { get; set; }

		Collation Collation { get; }

		ILiteCollection<T> GetCollection<T>(string name, BsonAutoId autoId = BsonAutoId.ObjectId);

		ILiteCollection<T> GetCollection<T>();

		ILiteCollection<T> GetCollection<T>(BsonAutoId autoId);

		ILiteCollection<BsonDocument> GetCollection(string name, BsonAutoId autoId = BsonAutoId.ObjectId);

		bool BeginTrans();

		bool Commit();

		bool Rollback();

		ILiteStorage<TFileId> GetStorage<TFileId>(string filesCollection = "_files", string chunksCollection = "_chunks");

		IEnumerable<string> GetCollectionNames();

		bool CollectionExists(string name);

		bool DropCollection(string name);

		bool RenameCollection(string oldName, string newName);

		IBsonDataReader Execute(TextReader commandReader, BsonDocument parameters = null);

		IBsonDataReader Execute(string command, BsonDocument parameters = null);

		IBsonDataReader Execute(string command, params BsonValue[] args);

		void Checkpoint();

		long Rebuild(RebuildOptions options = null);

		BsonValue Pragma(string name);

		BsonValue Pragma(string name, BsonValue value);
	}
	internal interface ILiteQueryable<T> : ILiteQueryableResult<T>
	{
		ILiteQueryable<T> Include(BsonExpression path);

		ILiteQueryable<T> Include(List<BsonExpression> paths);

		ILiteQueryable<T> Include<K>(Expression<Func<T, K>> path);

		ILiteQueryable<T> Where(BsonExpression predicate);

		ILiteQueryable<T> Where(string predicate, BsonDocument parameters);

		ILiteQueryable<T> Where(string predicate, params BsonValue[] args);

		ILiteQueryable<T> Where(Expression<Func<T, bool>> predicate);

		ILiteQueryable<T> OrderBy(BsonExpression keySelector, int order = 1);

		ILiteQueryable<T> OrderBy<K>(Expression<Func<T, K>> keySelector, int order = 1);

		ILiteQueryable<T> OrderByDescending(BsonExpression keySelector);

		ILiteQueryable<T> OrderByDescending<K>(Expression<Func<T, K>> keySelector);

		ILiteQueryable<T> ThenBy(BsonExpression keySelector);

		ILiteQueryable<T> ThenBy<K>(Expression<Func<T, K>> keySelector);

		ILiteQueryable<T> ThenByDescending(BsonExpression keySelector);

		ILiteQueryable<T> ThenByDescending<K>(Expression<Func<T, K>> keySelector);

		ILiteQueryable<IGrouping<K, T>> GroupBy<K>(Expression<Func<T, K>> keySelector);

		ILiteQueryable<T> GroupBy(BsonExpression keySelector);

		ILiteQueryable<T> Having(BsonExpression predicate);

		ILiteQueryable<BsonDocument> Select(BsonExpression selector);

		ILiteQueryable<K> Select<K>(Expression<Func<T, K>> selector);
	}
	internal interface ILiteQueryableResult<T>
	{
		ILiteQueryableResult<T> Limit(int limit);

		ILiteQueryableResult<T> Skip(int offset);

		ILiteQueryableResult<T> Offset(int offset);

		ILiteQueryableResult<T> ForUpdate();

		BsonDocument GetPlan();

		IBsonDataReader ExecuteReader();

		IEnumerable<BsonDocument> ToDocuments();

		IEnumerable<T> ToEnumerable();

		List<T> ToList();

		T[] ToArray();

		int Into(string newCollection, BsonAutoId autoId = BsonAutoId.ObjectId);

		T First();

		T FirstOrDefault();

		T Single();

		T SingleOrDefault();

		int Count();

		long LongCount();

		bool Exists();
	}
	internal interface ILiteRepository : IDisposable
	{
		ILiteDatabase Database { get; }

		BsonValue Insert<T>(T entity, string collectionName = null);

		int Insert<T>(IEnumerable<T> entities, string collectionName = null);

		bool Update<T>(T entity, string collectionName = null);

		int Update<T>(IEnumerable<T> entities, string collectionName = null);

		bool Upsert<T>(T entity, string collectionName = null);

		int Upsert<T>(IEnumerable<T> entities, string collectionName = null);

		bool Delete<T>(BsonValue id, string collectionName = null);

		int DeleteMany<T>(BsonExpression predicate, string collectionName = null);

		int DeleteMany<T>(Expression<Func<T, bool>> predicate, string collectionName = null);

		ILiteQueryable<T> Query<T>(string collectionName = null);

		bool EnsureIndex<T>(string name, BsonExpression expression, bool unique = false, string collectionName = null);

		bool EnsureIndex<T>(BsonExpression expression, bool unique = false, string collectionName = null);

		bool EnsureIndex<T, K>(Expression<Func<T, K>> keySelector, bool unique = false, string collectionName = null);

		bool EnsureIndex<T, K>(string name, Expression<Func<T, K>> keySelector, bool unique = false, string collectionName = null);

		T SingleById<T>(BsonValue id, string collectionName = null);

		List<T> Fetch<T>(BsonExpression predicate, string collectionName = null);

		List<T> Fetch<T>(Expression<Func<T, bool>> predicate, string collectionName = null);

		T First<T>(BsonExpression predicate, string collectionName = null);

		T First<T>(Expression<Func<T, bool>> predicate, string collectionName = null);

		T FirstOrDefault<T>(BsonExpression predicate, string collectionName = null);

		T FirstOrDefault<T>(Expression<Func<T, bool>> predicate, string collectionName = null);

		T Single<T>(BsonExpression predicate, string collectionName = null);

		T Single<T>(Expression<Func<T, bool>> predicate, string collectionName = null);

		T SingleOrDefault<T>(BsonExpression predicate, string collectionName = null);

		T SingleOrDefault<T>(Expression<Func<T, bool>> predicate, string collectionName = null);
	}
	internal class LiteDatabase : ILiteDatabase, IDisposable
	{
		private readonly ILiteEngine _engine;

		private readonly BsonMapper _mapper;

		private readonly bool _disposeOnClose;

		private readonly int? _checkpointOverride;

		private ILiteStorage<string> _fs;

		public BsonMapper Mapper => _mapper;

		public ILiteStorage<string> FileStorage => _fs ?? (_fs = GetStorage<string>());

		public int UserVersion
		{
			get
			{
				return _engine.Pragma("USER_VERSION");
			}
			set
			{
				_engine.Pragma("USER_VERSION", value);
			}
		}

		public TimeSpan Timeout
		{
			get
			{
				return TimeSpan.FromSeconds(_engine.Pragma("TIMEOUT").AsInt32);
			}
			set
			{
				_engine.Pragma("TIMEOUT", (int)value.TotalSeconds);
			}
		}

		public bool UtcDate
		{
			get
			{
				return _engine.Pragma("UTC_DATE");
			}
			set
			{
				_engine.Pragma("UTC_DATE", value);
			}
		}

		public long LimitSize
		{
			get
			{
				return _engine.Pragma("LIMIT_SIZE");
			}
			set
			{
				_engine.Pragma("LIMIT_SIZE", value);
			}
		}

		public int CheckpointSize
		{
			get
			{
				return _engine.Pragma("CHECKPOINT");
			}
			set
			{
				_engine.Pragma("CHECKPOINT", value);
			}
		}

		public Collation Collation => new Collation(_engine.Pragma("COLLATION").AsString);

		public LiteDatabase(string connectionString, BsonMapper mapper = null)
			: this(new ConnectionString(connectionString), mapper)
		{
		}

		public LiteDatabase(ConnectionString connectionString, BsonMapper mapper = null)
		{
			if (connectionString == null)
			{
				throw new ArgumentNullException("connectionString");
			}
			_engine = connectionString.CreateEngine();
			_mapper = mapper ?? BsonMapper.Global;
			_disposeOnClose = true;
		}

		public LiteDatabase(Stream stream, BsonMapper mapper = null, Stream logStream = null)
		{
			EngineSettings settings = new EngineSettings
			{
				DataStream = (stream ?? throw new ArgumentNullException("stream")),
				LogStream = logStream
			};
			_engine = new LiteEngine(settings);
			_mapper = mapper ?? BsonMapper.Global;
			_disposeOnClose = true;
			if (logStream == null && !(stream is MemoryStream) && stream.CanWrite)
			{
				BsonValue bsonValue = _engine.Pragma("CHECKPOINT");
				if (bsonValue != 1)
				{
					_engine.Pragma("CHECKPOINT", 1);
					_checkpointOverride = bsonValue;
				}
			}
		}

		public LiteDatabase(ILiteEngine engine, BsonMapper mapper = null, bool disposeOnClose = true)
		{
			_engine = engine ?? throw new ArgumentNullException("engine");
			_mapper = mapper ?? BsonMapper.Global;
			_disposeOnClose = disposeOnClose;
		}

		public ILiteCollection<T> GetCollection<T>(string name, BsonAutoId autoId = BsonAutoId.ObjectId)
		{
			return new LiteCollection<T>(name, autoId, _engine, _mapper);
		}

		public ILiteCollection<T> GetCollection<T>()
		{
			return GetCollection<T>(null);
		}

		public ILiteCollection<T> GetCollection<T>(BsonAutoId autoId)
		{
			return GetCollection<T>(null, autoId);
		}

		public ILiteCollection<BsonDocument> GetCollection(string name, BsonAutoId autoId = BsonAutoId.ObjectId)
		{
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			return new LiteCollection<BsonDocument>(name, autoId, _engine, _mapper);
		}

		public bool BeginTrans()
		{
			return _engine.BeginTrans();
		}

		public bool Commit()
		{
			return _engine.Commit();
		}

		public bool Rollback()
		{
			return _engine.Rollback();
		}

		public ILiteStorage<TFileId> GetStorage<TFileId>(string filesCollection = "_files", string chunksCollection = "_chunks")
		{
			return new LiteStorage<TFileId>(this, filesCollection, chunksCollection);
		}

		public IEnumerable<string> GetCollectionNames()
		{
			return (from x in GetCollection("$cols").Query().Where("type = 'user'").ToDocuments()
				select x["name"].AsString).ToArray();
		}

		public bool CollectionExists(string name)
		{
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			return GetCollectionNames().Contains<string>(name, StringComparer.OrdinalIgnoreCase);
		}

		public bool DropCollection(string name)
		{
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			return _engine.DropCollection(name);
		}

		public bool RenameCollection(string oldName, string newName)
		{
			if (oldName.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("oldName");
			}
			if (newName.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("newName");
			}
			return _engine.RenameCollection(oldName, newName);
		}

		public IBsonDataReader Execute(TextReader commandReader, BsonDocument parameters = null)
		{
			if (commandReader == null)
			{
				throw new ArgumentNullException("commandReader");
			}
			Tokenizer tokenizer = new Tokenizer(commandReader);
			return new SqlParser(_engine, tokenizer, parameters).Execute();
		}

		public IBsonDataReader Execute(string command, BsonDocument parameters = null)
		{
			if (command == null)
			{
				throw new ArgumentNullException("command");
			}
			Tokenizer tokenizer = new Tokenizer(command);
			return new SqlParser(_engine, tokenizer, parameters).Execute();
		}

		public IBsonDataReader Execute(string command, params BsonValue[] args)
		{
			BsonDocument bsonDocument = new BsonDocument();
			int num = 0;
			foreach (BsonValue value in args)
			{
				bsonDocument[num.ToString()] = value;
				num++;
			}
			return Execute(command, bsonDocument);
		}

		public void Checkpoint()
		{
			_engine.Checkpoint();
		}

		public long Rebuild(RebuildOptions options = null)
		{
			return _engine.Rebuild(options ?? new RebuildOptions());
		}

		public BsonValue Pragma(string name)
		{
			return _engine.Pragma(name);
		}

		public BsonValue Pragma(string name, BsonValue value)
		{
			return _engine.Pragma(name, value);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		~LiteDatabase()
		{
			Dispose(disposing: false);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing && _disposeOnClose)
			{
				if (_checkpointOverride.HasValue)
				{
					_engine.Pragma("CHECKPOINT", _checkpointOverride.Value);
				}
				_engine.Dispose();
			}
		}
	}
	internal static class LiteGroupingFieldNames
	{
		public const string Key = "key";

		public const string Items = "items";
	}
	internal sealed class LiteGrouping<TKey, TElement> : IGrouping<TKey, TElement>, IEnumerable<TElement>, IEnumerable
	{
		internal const string KeyField = "key";

		internal const string ItemsField = "items";

		private readonly IReadOnlyList<TElement> _items;

		public TKey Key { get; }

		public LiteGrouping(TKey key, IReadOnlyList<TElement> items)
		{
			Key = key;
			_items = items;
		}

		public IEnumerator<TElement> GetEnumerator()
		{
			return _items.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal class LiteQueryable<T> : ILiteQueryable<T>, ILiteQueryableResult<T>
	{
		[CompilerGenerated]
		private sealed class <ToDocuments>d__46 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteQueryable<T> <>4__this;

			private IBsonDataReader <reader>5__2;

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

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

			[DebuggerHidden]
			public <ToDocuments>d__46(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();
					}
				}
				<reader>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteQueryable<T> liteQueryable = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<reader>5__2 = liteQueryable.ExecuteReader();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<reader>5__2.Read())
					{
						<>2__current = <reader>5__2.Current as BsonDocument;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<reader>5__2 = 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 (<reader>5__2 != null)
				{
					<reader>5__2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<ToDocuments>d__46 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <ToDocuments>d__46(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		protected readonly ILiteEngine _engine;

		protected readonly BsonMapper _mapper;

		protected readonly string _collection;

		protected readonly Query _query;

		private readonly bool _isSimpleType = Reflection.IsSimpleType(typeof(T));

		internal LiteQueryable(ILiteEngine engine, BsonMapper mapper, string collection, Query query)
		{
			_engine = engine;
			_mapper = mapper;
			_collection = collection;
			_query = query;
		}

		public ILiteQueryable<T> Include<K>(Expression<Func<T, K>> path)
		{
			_query.Includes.Add(_mapper.GetExpression(path));
			return this;
		}

		public ILiteQueryable<T> Include(BsonExpression path)
		{
			_query.Includes.Add(path);
			return this;
		}

		public ILiteQueryable<T> Include(List<BsonExpression> paths)
		{
			_query.Includes.AddRange(paths);
			return this;
		}

		public ILiteQueryable<T> Where(BsonExpression predicate)
		{
			_query.Where.Add(predicate);
			return this;
		}

		public ILiteQueryable<T> Where(string predicate, BsonDocument parameters)
		{
			_query.Where.Add(BsonExpression.Create(predicate, parameters));
			return this;
		}

		public ILiteQueryable<T> Where(string predicate, params BsonValue[] args)
		{
			_query.Where.Add(BsonExpression.Create(predicate, args));
			return this;
		}

		public ILiteQueryable<T> Where(Expression<Func<T, bool>> predicate)
		{
			return Where(_mapper.GetExpression(predicate));
		}

		public ILiteQueryable<T> OrderBy(BsonExpression keySelector, int order = 1)
		{
			if (_query.OrderBy.Count > 0)
			{
				throw new ArgumentException("Multiple OrderBy calls are not supported. Use ThenBy for additional sort keys.");
			}
			_query.OrderBy.Add(new QueryOrder(keySelector, order));
			return this;
		}

		public ILiteQueryable<T> OrderBy<K>(Expression<Func<T, K>> keySelector, int order = 1)
		{
			return OrderBy(_mapper.GetExpression(keySelector), order);
		}

		public ILiteQueryable<T> OrderByDescending(BsonExpression keySelector)
		{
			return OrderBy(keySelector, -1);
		}

		public ILiteQueryable<T> OrderByDescending<K>(Expression<Func<T, K>> keySelector)
		{
			return OrderBy(keySelector, -1);
		}

		public ILiteQueryable<T> ThenBy(BsonExpression keySelector)
		{
			if (_query.OrderBy.Count == 0)
			{
				return OrderBy(keySelector);
			}
			_query.OrderBy.Add(new QueryOrder(keySelector, 1));
			return this;
		}

		public ILiteQueryable<T> ThenBy<K>(Expression<Func<T, K>> keySelector)
		{
			return ThenBy(_mapper.GetExpression(keySelector));
		}

		public ILiteQueryable<T> ThenByDescending(BsonExpression keySelector)
		{
			if (_query.OrderBy.Count == 0)
			{
				return OrderBy(keySelector, -1);
			}
			_query.OrderBy.Add(new QueryOrder(keySelector, -1));
			return this;
		}

		public ILiteQueryable<T> ThenByDescending<K>(Expression<Func<T, K>> keySelector)
		{
			return ThenByDescending(_mapper.GetExpression(keySelector));
		}

		public ILiteQueryable<IGrouping<K, T>> GroupBy<K>(Expression<Func<T, K>> keySelector)
		{
			BsonExpression expression = _mapper.GetExpression(keySelector);
			GroupBy(expression);
			_mapper.RegisterGroupingType<K, T>();
			return new LiteQueryable<IGrouping<K, T>>(_engine, _mapper, _collection, _query);
		}

		public ILiteQueryable<T> GroupBy(BsonExpression keySelector)
		{
			if (_query.GroupBy != null)
			{
				throw new ArgumentException("GROUP BY already defined in this query");
			}
			_query.GroupBy = keySelector;
			return this;
		}

		public ILiteQueryable<T> Having(BsonExpression predicate)
		{
			if (_query.Having != null)
			{
				throw new ArgumentException("HAVING already defined in this query");
			}
			_query.Having = predicate;
			return this;
		}

		public ILiteQueryable<BsonDocument> Select(BsonExpression selector)
		{
			_query.Select = selector;
			return new LiteQueryable<BsonDocument>(_engine, _mapper, _collection, _query);
		}

		public ILiteQueryable<K> Select<K>(Expression<Func<T, K>> selector)
		{
			_query.Select = _mapper.GetExpression(selector);
			return new LiteQueryable<K>(_engine, _mapper, _collection, _query);
		}

		private static void ValidateVectorArguments(float[] target, double maxDistance)
		{
			if (target == null || target.Length == 0)
			{
				throw new ArgumentException("Target vector must be provided.", "target");
			}
			if (double.IsNaN(maxDistance))
			{
				throw new ArgumentOutOfRangeException("maxDistance", "Similarity threshold must be a valid number.");
			}
		}

		private static BsonExpression CreateVectorSimilarityFilter(BsonExpression fieldExpr, float[] target, double maxDistance)
		{
			if (fieldExpr == null)
			{
				throw new ArgumentNullException("fieldExpr");
			}
			ValidateVectorArguments(target, maxDistance);
			BsonArray bsonArray = new BsonArray(target.Select((float v) => new BsonValue(v)));
			return BsonExpression.Create(fieldExpr.Source + " VECTOR_SIM @0 <= @1", bsonArray, new BsonValue(maxDistance));
		}

		internal ILiteQueryable<T> VectorWhereNear(string vectorField, float[] target, double maxDistance)
		{
			if (string.IsNullOrWhiteSpace(vectorField))
			{
				throw new ArgumentNullException("vectorField");
			}
			BsonExpression fieldExpr = BsonExpression.Create("$." + vectorField);
			return VectorWhereNear(fieldExpr, target, maxDistance);
		}

		internal ILiteQueryable<T> VectorWhereNear(BsonExpression fieldExpr, float[] target, double maxDistance)
		{
			BsonExpression item = CreateVectorSimilarityFilter(fieldExpr, target, maxDistance);
			_query.Where.Add(item);
			_query.VectorField = fieldExpr.Source;
			_query.VectorTarget = target?.ToArray();
			_query.VectorMaxDistance = maxDistance;
			return this;
		}

		internal ILiteQueryable<T> VectorWhereNear<K>(Expression<Func<T, K>> field, float[] target, double maxDistance)
		{
			if (field == null)
			{
				throw new ArgumentNullException("field");
			}
			BsonExpression expression = _mapper.GetExpression(field);
			return VectorWhereNear(expression, target, maxDistance);
		}

		internal ILiteQueryableResult<T> VectorTopKNear<K>(Expression<Func<T, K>> field, float[] target, int k)
		{
			BsonExpression expression = _mapper.GetExpression(field);
			return VectorTopKNear(expression, target, k);
		}

		internal ILiteQueryableResult<T> VectorTopKNear(string field, float[] target, int k)
		{
			BsonExpression fieldExpr = BsonExpression.Create("$." + field);
			return VectorTopKNear(fieldExpr, target, k);
		}

		internal ILiteQueryableResult<T> VectorTopKNear(BsonExpression fieldExpr, float[] target, int k)
		{
			if (fieldExpr == null)
			{
				throw new ArgumentNullException("fieldExpr");
			}
			if (target == null || target.Length == 0)
			{
				throw new ArgumentException("Target vector must be provided.", "target");
			}
			if (k <= 0)
			{
				throw new ArgumentOutOfRangeException("k", "Top-K must be greater than zero.");
			}
			BsonArray bsonArray = new BsonArray(target.Select((float v) => new BsonValue(v)));
			BsonExpression keySelector = BsonExpression.Create("VECTOR_SIM(" + fieldExpr.Source + ", @0)", bsonArray);
			_query.VectorField = fieldExpr.Source;
			_query.VectorTarget = target?.ToArray();
			_query.VectorMaxDistance = double.MaxValue;
			return OrderBy(keySelector).Limit(k);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.WhereNear extension instead.")]
		public ILiteQueryable<T> WhereNear(string vectorField, float[] target, double maxDistance)
		{
			return VectorWhereNear(vectorField, target, maxDistance);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.WhereNear extension instead.")]
		public ILiteQueryable<T> WhereNear(BsonExpression fieldExpr, float[] target, double maxDistance)
		{
			return VectorWhereNear(fieldExpr, target, maxDistance);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.WhereNear extension instead.")]
		public ILiteQueryable<T> WhereNear<K>(Expression<Func<T, K>> field, float[] target, double maxDistance)
		{
			return VectorWhereNear(field, target, maxDistance);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.FindNearest extension instead.")]
		public IEnumerable<T> FindNearest(string vectorField, float[] target, double maxDistance)
		{
			return VectorWhereNear(vectorField, target, maxDistance).ToEnumerable();
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.TopKNear extension instead.")]
		public ILiteQueryableResult<T> TopKNear<K>(Expression<Func<T, K>> field, float[] target, int k)
		{
			return VectorTopKNear(field, target, k);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.TopKNear extension instead.")]
		public ILiteQueryableResult<T> TopKNear(string field, float[] target, int k)
		{
			return VectorTopKNear(field, target, k);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call the LiteQueryableVectorExtensions.TopKNear extension instead.")]
		public ILiteQueryableResult<T> TopKNear(BsonExpression fieldExpr, float[] target, int k)
		{
			return VectorTopKNear(fieldExpr, target, k);
		}

		public ILiteQueryableResult<T> ForUpdate()
		{
			_query.ForUpdate = true;
			return this;
		}

		public ILiteQueryableResult<T> Offset(int offset)
		{
			_query.Offset = offset;
			return this;
		}

		public ILiteQueryableResult<T> Skip(int offset)
		{
			return Offset(offset);
		}

		public ILiteQueryableResult<T> Limit(int limit)
		{
			_query.Limit = limit;
			return this;
		}

		public IBsonDataReader ExecuteReader()
		{
			_query.ExplainPlan = false;
			return _engine.Query(_collection, _query);
		}

		[IteratorStateMachine(typeof(LiteQueryable<>.<ToDocuments>d__46))]
		public IEnumerable<BsonDocument> ToDocuments()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ToDocuments>d__46(-2)
			{
				<>4__this = this
			};
		}

		public IEnumerable<T> ToEnumerable()
		{
			if (_isSimpleType)
			{
				return from x in ToDocuments()
					select x[x.Keys.First()] into x
					select (T)_mapper.Deserialize(typeof(T), x);
			}
			return from x in ToDocuments()
				select (T)_mapper.Deserialize(typeof(T), x);
		}

		public List<T> ToList()
		{
			return ToEnumerable().ToList();
		}

		public T[] ToArray()
		{
			return ToEnumerable().ToArray();
		}

		public BsonDocument GetPlan()
		{
			_query.ExplainPlan = true;
			return _engine.Query(_collection, _query).ToEnumerable().FirstOrDefault()?.AsDocument;
		}

		public T Single()
		{
			return ToEnumerable().Single();
		}

		public T SingleOrDefault()
		{
			return ToEnumerable().SingleOrDefault();
		}

		public T First()
		{
			return ToEnumerable().First();
		}

		public T FirstOrDefault()
		{
			return ToEnumerable().FirstOrDefault();
		}

		public int Count()
		{
			BsonExpression select = _query.Select;
			try
			{
				Select("{ count: COUNT(*._id) }");
				return ToDocuments().Single()["count"].AsInt32;
			}
			finally
			{
				_query.Select = select;
			}
		}

		public long LongCount()
		{
			BsonExpression select = _query.Select;
			try
			{
				Select("{ count: COUNT(*._id) }");
				return ToDocuments().Single()["count"].AsInt64;
			}
			finally
			{
				_query.Select = select;
			}
		}

		public bool Exists()
		{
			BsonExpression select = _query.Select;
			try
			{
				Select("{ exists: ANY(*._id) }");
				return ToDocuments().Single()["exists"].AsBoolean;
			}
			finally
			{
				_query.Select = select;
			}
		}

		public int Into(string newCollection, BsonAutoId autoId = BsonAutoId.ObjectId)
		{
			_query.Into = newCollection;
			_query.IntoAutoId = autoId;
			using IBsonDataReader bsonDataReader = ExecuteReader();
			return bsonDataReader.Current.AsInt32;
		}
	}
	internal class LiteRepository : ILiteRepository, IDisposable
	{
		private readonly ILiteDatabase _db;

		public ILiteDatabase Database => _db;

		private LiteCollection<T> GetLiteCollection<T>(string collectionName)
		{
			if (_db.GetCollection<T>(collectionName) is LiteCollection<T> result)
			{
				return result;
			}
			throw new InvalidOperationException("The current collection implementation does not support vector operations.");
		}

		public LiteRepository(ILiteDatabase database)
		{
			_db = database;
		}

		public LiteRepository(string connectionString, BsonMapper mapper = null)
		{
			_db = new LiteDatabase(connectionString, mapper);
		}

		public LiteRepository(ConnectionString connectionString, BsonMapper mapper = null)
		{
			_db = new LiteDatabase(connectionString, mapper);
		}

		public LiteRepository(Stream stream, BsonMapper mapper = null, Stream logStream = null)
		{
			_db = new LiteDatabase(stream, mapper, logStream);
		}

		public BsonValue Insert<T>(T entity, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Insert(entity);
		}

		public int Insert<T>(IEnumerable<T> entities, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Insert(entities);
		}

		public bool Update<T>(T entity, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Update(entity);
		}

		public int Update<T>(IEnumerable<T> entities, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Update(entities);
		}

		public bool Upsert<T>(T entity, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Upsert(entity);
		}

		public int Upsert<T>(IEnumerable<T> entities, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Upsert(entities);
		}

		public bool Delete<T>(BsonValue id, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Delete(id);
		}

		public int DeleteMany<T>(BsonExpression predicate, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).DeleteMany(predicate);
		}

		public int DeleteMany<T>(Expression<Func<T, bool>> predicate, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).DeleteMany(predicate);
		}

		public ILiteQueryable<T> Query<T>(string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Query();
		}

		public bool EnsureIndex<T>(string name, BsonExpression expression, bool unique = false, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).EnsureIndex(name, expression, unique);
		}

		internal bool EnsureVectorIndex<T>(string name, BsonExpression expression, VectorIndexOptions options, string collectionName = null)
		{
			return GetLiteCollection<T>(collectionName).EnsureVectorIndex(name, expression, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteRepositoryVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex<T>(string name, BsonExpression expression, VectorIndexOptions options, string collectionName = null)
		{
			return EnsureVectorIndex<T>(name, expression, options, collectionName);
		}

		public bool EnsureIndex<T>(BsonExpression expression, bool unique = false, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).EnsureIndex(expression, unique);
		}

		internal bool EnsureVectorIndex<T>(BsonExpression expression, VectorIndexOptions options, string collectionName = null)
		{
			return GetLiteCollection<T>(collectionName).EnsureVectorIndex(expression, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteRepositoryVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex<T>(BsonExpression expression, VectorIndexOptions options, string collectionName = null)
		{
			return EnsureVectorIndex<T>(expression, options, collectionName);
		}

		public bool EnsureIndex<T, K>(Expression<Func<T, K>> keySelector, bool unique = false, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).EnsureIndex(keySelector, unique);
		}

		internal bool EnsureVectorIndex<T, K>(Expression<Func<T, K>> keySelector, VectorIndexOptions options, string collectionName = null)
		{
			return GetLiteCollection<T>(collectionName).EnsureVectorIndex(keySelector, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteRepositoryVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex<T, K>(Expression<Func<T, K>> keySelector, VectorIndexOptions options, string collectionName = null)
		{
			return EnsureVectorIndex(keySelector, options, collectionName);
		}

		public bool EnsureIndex<T, K>(string name, Expression<Func<T, K>> keySelector, bool unique = false, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).EnsureIndex(name, keySelector, unique);
		}

		internal bool EnsureVectorIndex<T, K>(string name, Expression<Func<T, K>> keySelector, VectorIndexOptions options, string collectionName = null)
		{
			return GetLiteCollection<T>(collectionName).EnsureVectorIndex(name, keySelector, options);
		}

		[Obsolete("Add `using LiteDB.Vector;` and call LiteRepositoryVectorExtensions.EnsureIndex instead.")]
		public bool EnsureIndex<T, K>(string name, Expression<Func<T, K>> keySelector, VectorIndexOptions options, string collectionName = null)
		{
			return EnsureVectorIndex(name, keySelector, options, collectionName);
		}

		public T SingleById<T>(BsonValue id, string collectionName = null)
		{
			return _db.GetCollection<T>(collectionName).Query().Where("_id = @0", id)
				.Single();
		}

		public List<T> Fetch<T>(BsonExpression predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).ToList();
		}

		public List<T> Fetch<T>(Expression<Func<T, bool>> predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).ToList();
		}

		public T First<T>(BsonExpression predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).First();
		}

		public T First<T>(Expression<Func<T, bool>> predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).First();
		}

		public T FirstOrDefault<T>(BsonExpression predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).FirstOrDefault();
		}

		public T FirstOrDefault<T>(Expression<Func<T, bool>> predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).FirstOrDefault();
		}

		public T Single<T>(BsonExpression predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).Single();
		}

		public T Single<T>(Expression<Func<T, bool>> predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).Single();
		}

		public T SingleOrDefault<T>(BsonExpression predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).SingleOrDefault();
		}

		public T SingleOrDefault<T>(Expression<Func<T, bool>> predicate, string collectionName = null)
		{
			return Query<T>(collectionName).Where(predicate).SingleOrDefault();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		~LiteRepository()
		{
			Dispose(disposing: false);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				_db.Dispose();
			}
		}
	}
	internal class BsonCtorAttribute : Attribute
	{
	}
	internal class BsonFieldAttribute : Attribute
	{
		public string Name { get; set; }

		public BsonFieldAttribute(string name)
		{
			Name = name;
		}

		public BsonFieldAttribute()
		{
		}
	}
	internal class BsonIdAttribute : Attribute
	{
		public bool AutoId { get; private set; }

		public BsonIdAttribute()
		{
			AutoId = true;
		}

		public BsonIdAttribute(bool autoId)
		{
			AutoId = autoId;
		}
	}
	internal class BsonIgnoreAttribute : Attribute
	{
	}
	internal class BsonRefAttribute : Attribute
	{
		public string Collection { get; set; }

		public BsonRefAttribute(string collection)
		{
			Collection = collection;
		}

		public BsonRefAttribute()
		{
			Collection = null;
		}
	}
	internal class BsonMapper
	{
		public delegate BsonValue DeserializationCallback(BsonMapper sender, Type target, BsonValue value);

		private readonly ConcurrentDictionary<Type, Func<object, BsonValue>> _customSerializer = new ConcurrentDictionary<Type, Func<object, BsonValue>>();

		private readonly ConcurrentDictionary<Type, Func<BsonValue, object>> _customDeserializer = new ConcurrentDictionary<Type, Func<BsonValue, object>>();

		private readonly Func<Type, object> _typeInstantiator;

		private readonly ITypeNameBinder _typeNameBinder;

		public static BsonMapper Global = new BsonMapper();

		public Func<string, string> ResolveFieldName;

		public Action<Type, MemberInfo, MemberMapper> ResolveMember;

		public Func<Type, string> ResolveCollectionName;

		private readonly Regex _lowerCaseDelimiter = new Regex("(?!(^[A-Z]))([A-Z])", RegexOptions.Compiled);

		private readonly HashSet<Type> _bsonTypes = new HashSet<Type>
		{
			typeof(string),
			typeof(int),
			typeof(long),
			typeof(bool),
			typeof(Guid),
			typeof(DateTime),
			typeof(byte[]),
			typeof(ObjectId),
			typeof(double),
			typeof(decimal)
		};

		private readonly HashSet<Type> _basicTypes = new HashSet<Type>
		{
			typeof(short),
			typeof(ushort),
			typeof(uint),
			typeof(float),
			typeof(char),
			typeof(byte),
			typeof(sbyte)
		};

		private readonly ConcurrentDictionary<Type, EntityMapper> _entities = new ConcurrentDictionary<Type, EntityMapper>();

		public bool SerializeNullValues { get; set; }

		public bool TrimWhitespace { get; set; }

		public bool EmptyStringToNull { get; set; }

		public bool EnumAsInteger { get; set; }

		public bool IncludeFields { get; set; }

		public bool IncludeNonPublic { get; set; }

		public int MaxDepth { get; set; }

		public DeserializationCallback? OnDeserialization { get; set; }

		public BsonMapper(Func<Type, object> customTypeInstantiator = null, ITypeNameBinder typeNameBinder = null)
		{
			SerializeNullValues = false;
			TrimWhitespace = true;
			EmptyStringToNull = true;
			EnumAsInteger = false;
			ResolveFieldName = (string s) => s;
			ResolveMember = delegate
			{
			};
			ResolveCollectionName = (Type t) => (!Reflection.IsEnumerable(t)) ? t.Name : Reflection.GetListItemType(t).Name;
			IncludeFields = false;
			MaxDepth = 20;
			_typeInstantiator = customTypeInstantiator ?? ((Func<Type, object>)((Type t) => null));
			_typeNameBinder = typeNameBinder ?? DefaultTypeNameBinder.Instance;
			RegisterType((Uri uri) => uri.IsAbsoluteUri ? uri.AbsoluteUri : uri.ToString(), (BsonValue bson) => new Uri(bson.AsString));
			RegisterType((DateTimeOffset value) => new BsonValue(value.UtcDateTime), (BsonValue bson) => bson.AsDateTime.ToUniversalTime());
			RegisterType((TimeSpan value) => new BsonValue(value.Ticks), (BsonValue bson) => new TimeSpan(bson.AsInt64));
			RegisterType((Regex r) => (r.Options != 0) ? new BsonDocument
			{
				{
					"p",
					r.ToString()
				},
				{
					"o",
					(int)r.Options
				}
			} : new BsonValue(r.ToString()), (BsonValue value) => (!value.IsString) ? new Regex(value.AsDocument["p"].AsString, (RegexOptions)value.AsDocument["o"].AsInt32) : new Regex(value));
		}

		public void RegisterType<T>(Func<T, BsonValue> serialize, Func<BsonValue, T> deserialize)
		{
			_customSerializer[typeof(T)] = (object o) => serialize((T)o);
			_customDeserializer[typeof(T)] = (BsonValue b) => deserialize(b);
		}

		public void RegisterType(Type type, Func<object, BsonValue> serialize, Func<BsonValue, object> deserialize)
		{
			_customSerializer[type] = (object o) => serialize(o);
			_customDeserializer[type] = (BsonValue b) => deserialize(b);
		}

		public EntityBuilder<T> Entity<T>()
		{
			return new EntityBuilder<T>(this, _typeNameBinder);
		}

		public BsonExpression GetExpression<T, K>(Expression<Func<T, K>> predicate)
		{
			return new LinqExpressionVisitor(this, predicate).Resolve(typeof(K) == typeof(bool));
		}

		public BsonExpression GetIndexExpression<T, K>(Expression<Func<T, K>> predicate)
		{
			return new LinqExpressionVisitor(this, predicate).Resolve(predicate: false);
		}

		public BsonMapper UseCamelCase()
		{
			ResolveFieldName = (string s) => char.ToLower(s[0]) + s.Substring(1);
			return this;
		}

		public BsonMapper UseLowerCaseDelimiter(char delimiter = '_')
		{
			ResolveFieldName = (string s) => _lowerCaseDelimiter.Replace(s, delimiter + "$2").ToLower();
			return this;
		}

		internal static void RegisterDbRef(BsonMapper mapper, MemberMapper member, ITypeNameBinder typeNameBinder, string collection)
		{
			member.DbRefCollectionName = collection;
			if (member.IsEnumerable)
			{
				RegisterDbRefList(mapper, member, typeNameBinder);
			}
			else
			{
				RegisterDbRefItem(mapper, member, typeNameBinder);
			}
		}

		private static void RegisterDbRefItem(BsonMapper mapper, MemberMapper member, ITypeNameBinder typeNameBinder)
		{
			EntityMapper entity = mapper.GetEntityMapper(member.DataType);
			member.Serialize = delegate(object obj, BsonMapper m)
			{
				if (obj == null)
				{
					return BsonValue.Null;
				}
				entity.WaitForInitialization();
				object obj2 = (entity.Id ?? throw new LiteException(0, "There is no _id field mapped in your type: " + member.DataType.FullName)).Getter(obj);
				BsonDocument bsonDocument = new BsonDocument
				{
					["$id"] = m.Serialize(obj2.GetType(), obj2, 0),
					["$ref"] = member.DbRefCollectionName
				};
				if (member.DataType != obj.GetType())
				{
					bsonDocument["$type"] = mapper.SerializeTypeName(obj.GetType());
				}
				return bsonDocument;
			};
			member.Deserialize = delegate(BsonValue bson, BsonMapper m)
			{
				if (bson == null || !bson.IsDocument)
				{
					return null;
				}
				BsonDocument asDocument = bson.AsDocument;
				BsonValue value = asDocument["$id"];
				bool num = asDocument["$missing"] == true;
				bool flag = !asDocument.ContainsKey("$ref");
				if (num)
				{
					return null;
				}
				if (flag)
				{
					asDocument["_id"] = value;
					if (asDocument.ContainsKey("$type"))
					{
						asDocument["_type"] = bson["$type"];
					}
					return m.Deserialize(entity.ForType, asDocument);
				}
				return m.Deserialize(entity.ForType, asDocument.ContainsKey("$type") ? new BsonDocument
				{
					["_id"] = value,
					["_type"] = bson["$type"]
				} : new BsonDocument { ["_id"] = value });
			};
		}

		private static void RegisterDbRefList(BsonMapper mapper, MemberMapper member, ITypeNameBinder typeNameBinder)
		{
			EntityMapper entity = mapper.GetEntityMapper(member.UnderlyingType);
			member.Serialize = delegate(object list, BsonMapper m)
			{
				if (list == null)
				{
					return BsonValue.Null;
				}
				entity.WaitForInitialization();
				BsonArray bsonArray2 = new BsonArray();
				MemberMapper id = entity.Id;
				foreach (object item in (IEnumerable)list)
				{
					if (item != null)
					{
						object obj = id.Getter(item);
						BsonDocument bsonDocument2 = new BsonDocument
						{
							["$id"] = m.Serialize(obj.GetType(), obj, 0),
							["$ref"] = member.DbRefCollectionName
						};
						if (member.UnderlyingType != item.GetType())
						{
							bsonDocument2["$type"] = mapper.SerializeTypeName(item.GetType());
						}
						bsonArray2.Add(bsonDocument2);
					}
				}
				return bsonArray2;
			};
			member.Deserialize = delegate(BsonValue bson, BsonMapper m)
			{
				if (!bson.IsArray)
				{
					return null;
				}
				BsonArray asArray = bson.AsArray;
				if (asArray.Count == 0)
				{
					return m.Deserialize(member.DataType, asArray);
				}
				BsonArray bsonArray = new BsonArray();
				foreach (BsonValue item2 in asArray)
				{
					if (item2.IsDocument)
					{
						BsonDocument asDocument = item2.AsDocument;
						BsonValue value = asDocument["$id"];
						bool flag = asDocument["$missing"] == true;
						bool flag2 = !asDocument.ContainsKey("$ref");
						if (!flag)
						{
							if (flag2)
							{
								item2["_id"] = value;
								if (item2.AsDocument.ContainsKey("$type"))
								{
									item2["_type"] = item2["$type"];
								}
								bsonArray.Add(item2);
							}
							else
							{
								BsonDocument bsonDocument = new BsonDocument { ["_id"] = value };
								if (item2.AsDocument.ContainsKey("$type"))
								{
									bsonDocument["_type"] = item2["$type"];
								}
								bsonArray.Add(bsonDocument);
							}
						}
					}
				}
				return m.Deserialize(member.DataType, bsonArray);
			};
		}

		public virtual object ToObject(Type type, BsonDocument doc)
		{
			if (doc == null)
			{
				throw new ArgumentNullException("doc");
			}
			if (type == typeof(BsonDocument))
			{
				return doc;
			}
			return Deserialize(type, doc);
		}

		public virtual T ToObject<T>(BsonDocument doc)
		{
			return (T)ToObject(typeof(T), doc);
		}

		public T Deserialize<T>(BsonValue value)
		{
			if (value == null)
			{
				return default(T);
			}
			return (T)Deserialize(typeof(T), value);
		}

		public object Deserialize(Type type, BsonValue value)
		{
			if (OnDeserialization != null)
			{
				BsonValue bsonValue = OnDeserialization(this, type, value);
				if ((object)bsonValue != null)
				{
					value = bsonValue;
				}
			}
			if (value.IsNull)
			{
				return null;
			}
			if (Reflection.IsNullable(type))
			{
				type = Reflection.UnderlyingTypeOf(type);
			}
			if (_customDeserializer.TryGetValue(type, out var value2))
			{
				return value2(value);
			}
			TypeInfo typeInfo = type.GetTypeInfo();
			if (type == typeof(BsonValue))
			{
				return value;
			}
			if (type == typeof(BsonDocument))
			{
				return value.AsDocument;
			}
			if (type == typeof(BsonArray))
			{
				return value.AsArray;
			}
			if (_bsonTypes.Contains(type))
			{
				return value.RawValue;
			}
			if (_basicTypes.Contains(type))
			{
				return Convert.ChangeType(value.RawValue, type);
			}
			if (type == typeof(ulong))
			{
				return (ulong)value.AsInt64;
			}
			if (typeInfo.IsEnum)
			{
				if (value.IsString)
				{
					return Enum.Parse(type, value.AsString);
				}
				if (value.IsNumber)
				{
					return Enum.ToObject(type, value.AsInt32);
				}
			}
			else
			{
				if (value.IsArray)
				{
					if (type == typeof(object))
					{
						return DeserializeArray(typeof(object), value.AsArray);
					}
					if (type.IsArray)
					{
						return DeserializeArray(type.GetElementType(), value.AsArray);
					}
					return DeserializeList(type, value.AsArray);
				}
				if (value.IsDocument)
				{
					if (type.IsAnonymousType())
					{
						return DeserializeAnonymousType(type, value.AsDocument);
					}
					BsonDocument asDocument = value.AsDocument;
					if (asDocument.TryGetValue("_type", out var value3) && value3.IsString)
					{
						Type type2 = _typeNameBinder.GetType(value3.AsString);
						if (type2 == null)
						{
							throw LiteException.InvalidTypedName(value3.AsString);
						}
						if (!type.IsAssignableFrom(type2))
						{
							throw LiteException.DataTypeNotAssignable(type.FullName, type2.FullName);
						}
						type = type2;
					}
					else if (type == typeof(object))
					{
						type = typeof(Dictionary<string, object>);
					}
					EntityMapper entity = GetEntityMapper(type);
					entity.WaitForInitialization();
					entity.CreateInstance = entity.CreateInstance ?? GetTypeCtor(entity) ?? ((CreateObject)((BsonDocument _) => Reflection.CreateInstance(entity.ForType)));
					object obj = _typeInstantiator(type) ?? entity.CreateInstance(asDocument);
					if (obj is IDictionary dict)
					{
						Type keyType = typeof(object);
						Type valueType = typeof(object);
						if (obj.GetType().GetTypeInfo().IsGenericType)
						{
							Type[] genericArguments = type.GetGenericArguments();
							keyType = genericArguments[0];
							valueType = genericArguments[1];
						}
						DeserializeDictionary(keyType, valueType, dict, value.AsDocument);
					}
					else
					{
						DeserializeObject(entity, obj, asDocument);
					}
					return obj;
				}
			}
			return value.RawValue;
		}

		private object DeserializeArray(Type type, BsonArray array)
		{
			Array array2 = Array.CreateInstance(type, array.Count);
			int num = 0;
			foreach (BsonValue item in array)
			{
				array2.SetValue(Deserialize(type, item), num++);
			}
			return array2;
		}

		private object DeserializeList(Type type, BsonArray value)
		{
			Type listItemType = Reflection.GetListItemType(type);
			IEnumerable enumerable = (IEnumerable)Reflection.CreateInstance(type);
			if (enumerable is IList list)
			{
				foreach (BsonValue item in value)
				{
					list.Add(Deserialize(listItemType, item));
				}
			}
			else
			{
				MethodInfo method = type.GetMethod("Add", new Type[1] { listItemType });
				foreach (BsonValue item2 in value)
				{
					method.Invoke(enumerable, new object[1] { Deserialize(listItemType, item2) });
				}
			}
			return enumerable;
		}

		private void DeserializeDictionary(Type keyType, Type valueType, IDictionary dict, BsonDocument value)
		{
			foreach (KeyValuePair<string, BsonValue> element in value.GetElements())
			{
				System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(keyType);
				object key = ((!converter.CanConvertFrom(typeof(string))) ? Convert.ChangeType(element.Key, keyType) : converter.ConvertFromInvariantString(element.Key));
				object value2 = Deserialize(valueType, element.Value);
				dict[key] = value2;
			}
		}

		private void DeserializeObject(EntityMapper entity, object obj, BsonDocument value)
		{
			foreach (MemberMapper item in entity.Members.Where((MemberMapper x) => x.Setter != null))
			{
				if (value.TryGetValue(item.FieldName, out var value2))
				{
					if (item.Deserialize != null)
					{
						item.Setter(obj, item.Deserialize(value2, this));
					}
					else
					{
						item.Setter(obj, Deserialize(item.DataType, value2));
					}
				}
			}
		}

		private object DeserializeAnonymousType(Type type, BsonDocument value)
		{
			List<object> list = new List<object>();
			ParameterInfo[] parameters = type.GetConstructors()[0].GetParameters();
			foreach (ParameterInfo parameterInfo in parameters)
			{
				object obj = Deserialize(parameterInfo.ParameterType, value[parameterInfo.Name]);
				if (obj == null && StringComparer.OrdinalIgnoreCase.Equals(parameterInfo.Name, "Id") && value.TryGetValue("_id", out var value2))
				{
					obj = Deserialize(parameterInfo.ParameterType, value2);
				}
				list.Add(obj);
			}
			return Activator.CreateInstance(type, list.ToArray());
		}

		internal EntityMapper GetEntityMapper(Type type)
		{
			if (_entities.TryGetValue(type, out var value))
			{
				return value;
			}
			using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
			try
			{
				EntityMapper entityMapper = new EntityMapper(type, cancellationTokenSource.Token);
				value = _entities.GetOrAdd(type, entityMapper);
				if (value == entityMapper)
				{
					try
					{
						BuildEntityMapper(value);
					}
					catch (Exception ex)
					{
						_entities.TryRemove(type, out var _);
						throw new LiteException(221, "Error in '" + type.Name + "' mapping: " + ex.Message, ex);
					}
				}
			}
			finally
			{
				cancellationTokenSource.Cancel();
			}
			return value;
		}

		protected void BuildEntityMapper(EntityMapper mapper)
		{
			Type typeFromHandle = typeof(BsonIdAttribute);
			Type typeFromHandle2 = typeof(BsonIgnoreAttribute);
			Type typeFromHandle3 = typeof(BsonFieldAttribute);
			Type typeFromHandle4 = typeof(BsonRefAttribute);
			IEnumerable<MemberInfo> typeMembers = GetTypeMembers(mapper.ForType);
			MemberInfo idMember = GetIdMember(typeMembers);
			foreach (MemberInfo item in typeMembers)
			{
				if (!CustomAttributeExtensions.IsDefined(item, typeFromHandle2, inherit: true))
				{
					string name = ResolveFieldName(item.Name);
					BsonFieldAttribute bsonFieldAttribute = (BsonFieldAttribute)CustomAttributeExtensions.GetCustomAttributes(item, typeFromHandle3, inherit: true).FirstOrDefault();
					if (bsonFieldAttribute != null && bsonFieldAttribute.Name != null)
					{
						name = bsonFieldAttribute.Name;
					}
					if (item == idMember)
					{
						name = "_id";
					}
					GenericGetter getter = Reflection.CreateGenericGetter(mapper.ForType, item);
					GenericSetter setter = Reflection.CreateGenericSetter(mapper.ForType, item);
					BsonIdAttribute bsonIdAttribute = (BsonIdAttribute)CustomAttributeExtensions.GetCustomAttributes(item, typeFromHandle, inherit: true).FirstOrDefault();
					Type type = ((item is PropertyInfo) ? (item as PropertyInfo).PropertyType : (item as FieldInfo).FieldType);
					bool flag = Reflection.IsEnumerable(type);
					MemberMapper memberMapper = new MemberMapper
					{
						AutoId = (bsonIdAttribute?.AutoId ?? true),
						FieldName = name,
						MemberName = item.Name,
						DataType = type,
						IsEnumerable = flag,
						UnderlyingType = (flag ? Reflection.GetListItemType(type) : type),
						Getter = getter,
						Setter = setter
					};
					BsonRefAttribute bsonRefAttribute = (BsonRefAttribute)CustomAttributeExtensions.GetCustomAttributes(item, typeFromHandle4, inherit: false).FirstOrDefault();
					if (bsonRefAttribute != null && item is PropertyInfo)
					{
						RegisterDbRef(this, memberMapper, _typeNameBinder, bsonRefAttribute.Collection ?? ResolveCollectionName((item as PropertyInfo).PropertyType));
					}
					ResolveMember?.Invoke(mapper.ForType, item, memberMapper);
					if (memberMapper.FieldName != null && !mapper.Members.Any((MemberMapper x) => x.FieldName.Equals(name, StringComparison.OrdinalIgnoreCase)) && !memberMapper.IsIgnore)
					{
						mapper.Members.Add(memberMapper);
					}
				}
			}
		}

		protected virtual MemberInfo GetIdMember(IEnumerable<MemberInfo> members)
		{
			return Reflection.SelectMember(members, (MemberInfo x) => CustomAttributeExtensions.IsDefined(x, typeof(BsonIdAttribute), inherit: true), (MemberInfo x) => x.Name.Equals("Id", StringComparison.OrdinalIgnoreCase), (MemberInfo x) => x.Name.Equals(x.DeclaringType.Name + "Id", StringComparison.OrdinalIgnoreCase));
		}

		protected virtual IEnumerable<MemberInfo> GetTypeMembers(Type type)
		{
			List<MemberInfo> list = new List<MemberInfo>();
			BindingFlags bindingAttr = (IncludeNonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public));
			list.AddRange((from x in type.GetProperties(bindingAttr)
				where x.CanRead && x.GetIndexParameters().Length == 0
				select x).Select((Func<PropertyInfo, MemberInfo>)((PropertyInfo x) => x)));
			if ((list.Count == 0 && type.GetTypeInfo().IsValueType) || IncludeFields)
			{
				list.AddRange((from x in type.GetFields(bindingAttr)
					where !x.Name.EndsWith("k__BackingField") && !x.IsStatic
					select x).Select((Func<FieldInfo, MemberInfo>)((FieldInfo x) => x)));
			}
			return list;
		}

		protected virtual CreateObject GetTypeCtor(EntityMapper mapper)
		{
			Type type = mapper.ForType;
			List<CreateObject> list = new List<CreateObject>();
			bool flag = false;
			ConstructorInfo[] constructors = type.GetConstructors();
			foreach (ConstructorInfo constructorInfo in constructors)
			{
				ParameterInfo[] parameters = constructorInfo.GetParameters();
				if (parameters.Length == 0)
				{
					flag = true;
					continue;
				}
				KeyValuePair<string, Type>[] paramMap = new KeyValuePair<string, Type>[parameters.Length];
				int j;
				for (j = 0; j < parameters.Length; j++)
				{
					ParameterInfo parameterInfo = parameters[j];
					MemberMapper memberMapper = null;
					foreach (MemberMapper member in mapper.Members)
					{
						if (member.MemberName.ToLower() == parameterInfo.Name.ToLower() && member.DataType == parameterInfo.ParameterType)
						{
							memberMapper = member;
							break;
						}
					}
					if (memberMapper == null)
					{
						break;
					}
					paramMap[j] = new KeyValuePair<string, Type>(memberMapper.FieldName, memberMapper.DataType);
				}
				if (j < parameters.Length)
				{
					continue;
				}
				CreateObject createObject = (BsonDocument value) => Activator.CreateInstance(type, paramMap.Select((KeyValuePair<string, Type> x) => Deserialize(x.Value, value[x.Key])).ToArray());
				if (constructorInfo.GetCustomAttribute<BsonCtorAttribute>() != null)
				{
					return createObject;
				}
				list.Add(createObject);
			}
			if (flag)
			{
				return null;
			}
			return list.FirstOrDefault();
		}

		internal void RegisterGroupingType<TKey, TElement>()
		{
			Type typeFromHandle = typeof(IGrouping<TKey, TElement>);
			Type typeFromHandle2 = typeof(LiteGrouping<TKey, TElement>);
			if (!_customDeserializer.ContainsKey(typeFromHandle))
			{
				RegisterType(typeFromHandle, SerializeGrouping, DeserializeGrouping);
				if (!_customDeserializer.ContainsKey(typeFromHandle2))
				{
					RegisterType(typeFromHandle2, SerializeGrouping, DeserializeGrouping);
				}
			}
			object DeserializeGrouping(BsonValue value)
			{
				BsonDocument asDocument = value.AsDocument;
				TKey key = (TKey)Deserialize(typeof(TKey), asDocument["key"]);
				BsonArray asArray = asDocument["items"].AsArray;
				List<TElement> list = new List<TElement>(asArray.Count);
				foreach (BsonValue item in asArray)
				{
					list.Add((TElement)Deserialize(typeof(TElement), item));
				}
				return new LiteGrouping<TKey, TElement>(key, list);
			}
			BsonValue SerializeGrouping(object value)
			{
				IGrouping<TKey, TElement> grouping = (IGrouping<TKey, TElement>)value;
				BsonArray bsonArray = new BsonArray();
				foreach (TElement item2 in grouping)
				{
					bsonArray.Add(Serialize(typeof(TElement), item2));
				}
				return new BsonDocument
				{
					["key"] = Serialize(typeof(TKey), grouping.Key),
					["items"] = bsonArray
				};
			}
		}

		public virtual BsonDocument ToDocument(Type type, object entity)
		{
			if (entity == null)
			{
				throw new ArgumentNullException("entity");
			}
			if (entity is BsonDocument)
			{
				return (BsonDocument)entity;
			}
			return Serialize(type, entity, 0).AsDocument;
		}

		public virtual BsonDocument ToDocument<T>(T entity)
		{
			return ToDocument(typeof(T), entity)?.AsDocument;
		}

		public BsonValue Serialize<T>(T obj)
		{
			return Serialize(typeof(T), obj, 0);
		}

		public BsonValue Serialize(Type type, object obj)
		{
			return Serialize(type, obj, 0);
		}

		internal BsonValue Serialize(Type type, object obj, int depth)
		{
			if (++depth > MaxDepth)
			{
				throw LiteException.DocumentMaxDepth(MaxDepth, type);
			}
			if (obj == null)
			{
				return BsonValue.Null;
			}
			if (obj is BsonValue result)
			{
				return result;
			}
			if (_customSerializer.TryGetValue(type, out var value) || _customSerializer.TryGetValue(obj.GetType(), out value))
			{
				return value(obj);
			}
			if (obj is string)
			{
				string text = (TrimWhitespace ? (obj as string).Trim() : ((string)obj));
				if (EmptyStringToNull && text.Length == 0)
				{
					return BsonValue.Null;
				}
				return new BsonValue(text);
			}
			if (obj is int)
			{
				return new BsonValue((int)obj);
			}
			if (obj is long)
			{
				return new BsonValue((long)obj);
			}
			if (obj is double)
			{
				return new BsonValue((double)obj);
			}
			if (obj is decimal)
			{
				return new BsonValue((decimal)obj);
			}
			if (obj is byte[])
			{
				return new BsonValue((byte[])obj);
			}
			if (obj is ObjectId)
			{
				return new BsonValue((ObjectId)obj);
			}
			if (obj is Guid)
			{
				return new BsonValue((Guid)obj);
			}
			if (obj is bool)
			{
				return new BsonValue((bool)obj);
			}
			if (obj is DateTime)
			{
				return new BsonValue((DateTime)obj);
			}
			if (obj is short || obj is ushort || obj is byte || obj is sbyte)
			{
				return new BsonValue(Convert.ToInt32(obj));
			}
			if (obj is uint)
			{
				return new BsonValue(Convert.ToInt64(obj));
			}
			if (obj is ulong)
			{
				return new BsonValue((long)(ulong)obj);
			}
			if (obj is float)
			{
				return new BsonValue(Convert.ToDouble(obj));
			}
			if (obj is char)
			{
				return new BsonValue(obj.ToString());
			}
			if (obj is Enum)
			{
				if (EnumAsInteger)
				{
					return new BsonValue((int)obj);
				}
				return new BsonValue(obj.ToString());
			}
			if (obj is IDictionary dict)
			{
				if (type == typeof(object))
				{
					type = obj.GetType();
				}
				Type valueType = typeof(object);
				if (type.GetTypeInfo().IsGenericType)
				{
					valueType = type.GetGenericArguments()[1];
				}
				return SerializeDictionary(valueType, dict, depth);
			}
			if (obj is IEnumerable)
			{
				return SerializeArray(Reflection.GetListItemType(type), obj as IEnumerable, depth);
			}
			return SerializeObject(type, obj, depth);
		}

		private BsonArray SerializeArray(Type type, IEnumerable array, int depth)
		{
			BsonArray bsonArray = new BsonArray();
			foreach (object item in array)
			{
				bsonArray.Add(Serialize(type, item, depth));
			}
			return bsonArray;
		}

		private BsonDocument SerializeDictionary(Type valueType, IDictionary dict, int depth)
		{
			BsonDocument bsonDocument = new BsonDocument();
			foreach (object key in dict.Keys)
			{
				object obj = dict[key];
				string name = ((key is DateTime dateTime) ? (dateTime.ToString("o") ?? string.Empty) : (key.ToString() ?? string.Empty));
				BsonValue value = Serialize(valueType, obj, depth);
				bsonDocument[name] = value;
			}
			return bsonDocument;
		}

		private BsonDocument SerializeObject(Type type, object obj, int depth)
		{
			Type type2 = obj.GetType();
			BsonDocument bsonDocument = new BsonDocument();
			EntityMapper entityMapper = GetEntityMapper(type2);
			entityMapper.WaitForInitialization();
			if (type != type2)
			{
				bsonDocument["_type"] = SerializeTypeName(type2);
			}
			foreach (MemberMapper item in entityMapper.Members.Where((MemberMapper x) => x.Getter != null))
			{
				object obj2 = item.Getter(obj);
				if (obj2 != null || SerializeNullValues || !(item.FieldName != "_id"))
				{
					if (item.Serialize != null)
					{
						bsonDocument[item.FieldName] = item.Serialize(obj2, this);
					}
					else
					{
						bsonDocument[item.FieldName] = Serialize(item.DataType, obj2, depth);
					}
				}
			}
			return bsonDocument;
		}

		internal BsonValue SerializeTypeName(Type type)
		{
			return new BsonValue(_typeNameBinder.GetName(type));
		}
	}
	internal sealed class BsonRefId<T>
	{
		public BsonRefId(BsonValue id)
		{
		}

		public static implicit operator T(BsonRefId<T> _)
		{
			throw new NotSupportedException("The type BsonRefId<T> can only be used in LiteDB LINQ expressions.");
		}
	}
	internal class EntityBuilder<T>
	{
		private readonly BsonMapper _mapper;

		private readonly EntityMapper _entity;

		private readonly ITypeNameBinder _typeNameBinder;

		internal EntityBuilder(BsonMapper mapper, ITypeNameBinder typeNameBinder)
		{
			_mapper = mapper;
			_typeNameBinder = typeNameBinder;
			_entity = mapper.GetEntityMapper(typeof(T));
		}

		public EntityBuilder<T> Ignore<K>(Expression<Func<T, K>> member)
		{
			return GetMember(member, delegate(MemberMapper p)
			{
				_entity.WaitForInitialization();
				_entity.Members.Remove(p);
			});
		}

		public EntityBuilder<T> Field<K>(Expression<Func<T, K>> member, string field)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return GetMember(member, delegate(MemberMapper p)
			{
				p.FieldName = field;
			});
		}

		public EntityBuilder<T> Id<K>(Expression<Func<T, K>> member, bool autoId = true)
		{
			return GetMember(member, delegate(MemberMapper p)
			{
				_entity.WaitForInitialization();
				MemberMapper memberMapper = _entity.Members.FirstOrDefault((MemberMapper x) => x.FieldName == "_id");
				if (memberMapper != null)
				{
					memberMapper.FieldName = _mapper.ResolveFieldName(memberMapper.MemberName);
					memberMapper.AutoId = false;
				}
				p.FieldName = "_id";
				p.AutoId = autoId;
			});
		}

		public EntityBuilder<T> Ctor(Func<BsonDocument, T> createInstance)
		{
			_entity.WaitForInitialization();
			_entity.CreateInstance = (BsonDocument v) => createInstance(v);
			return this;
		}

		public EntityBuilder<T> DbRef<K>(Expression<Func<T, K>> member, string collection = null)
		{
			return GetMember(member, delegate(MemberMapper p)
			{
				BsonMapper.RegisterDbRef(_mapper, p, _typeNameBinder, collection ?? _mapper.ResolveCollectionName(typeof(K)));
			});
		}

		private EntityBuilder<T> GetMember<TK, K>(Expression<Func<TK, K>> member, Action<MemberMapper> action)
		{
			if (member == null)
			{
				throw new ArgumentNullException("member");
			}
			_entity.WaitForInitialization();
			MemberMapper member2 = _entity.GetMember(member);
			if (member2 == null)
			{
				throw new ArgumentNullException("Member '" + member.GetPath() + "' not found in type '" + _entity.ForType.Name + "' (use IncludeFields in BsonMapper)");
			}
			action(member2);
			return this;
		}
	}
	internal class EntityMapper
	{
		private readonly CancellationToken _initializationToken;

		public Type ForType { get; }

		public List<MemberMapper> Members { get; } = new List<MemberMapper>();


		public MemberMapper Id => Members.SingleOrDefault((MemberMapper x) => x.FieldName == "_id");

		public CreateObject CreateInstance { get; set; }

		public EntityMapper(Type forType, CancellationToken initializationToken = default(CancellationToken))
		{
			_initializationToken = initializationToken;
			ForType = forType;
		}

		public MemberMapper GetMember(Expression expr)
		{
			return Members.FirstOrDefault((MemberMapper x) => x.MemberName == expr.GetPath());
		}

		public void WaitForInitialization()
		{
			if (_initializationToken == default(CancellationToken) || _initializationToken == CancellationToken.None)
			{
				return;
			}
			CancellationToken initializationToken = _initializationToken;
			if (!initializationToken.IsCancellationRequested)
			{
				initializationToken = _initializationToken;
				if (!initializationToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(5.0)))
				{
					throw new LiteException(219, "Initialization timeout");
				}
			}
		}
	}
	internal class LinqExpressionVisitor : ExpressionVisitor
	{
		private static readonly Dictionary<Type, ITypeResolver> _resolver = new Dictionary<Type, ITypeResolver>
		{
			[typeof(BsonValue)] = new BsonValueResolver(),
			[typeof(BsonArray)] = new BsonValueResolver(),
			[typeof(BsonDocument)] = new BsonValueResolver(),
			[typeof(Convert)] = new ConvertResolver(),
			[typeof(DateTime)] = new DateTimeResolver(),
			[typeof(int)] = new NumberResolver("INT32"),
			[typeof(long)] = new NumberResolver("INT64"),
			[typeof(decimal)] = new NumberResolver("DECIMAL"),
			[typeof(double)] = new NumberResolver("DOUBLE"),
			[typeof(ICollection)] = new ICollectionResolver(),
			[typeof(IGrouping<, >)] = new GroupingResolver(),
			[typeof(Enumerable)] = new EnumerableResolver(),
			[typeof(MemoryExtensions)] = new MemoryExtensionsResolver(),
			[typeof(Guid)] = new GuidResolver(),
			[typeof(Math)] = new MathResolver(),
			[typeof(Regex)] = new RegexResolver(),
			[typeof(ObjectId)] = new ObjectIdResolver(),
			[typeof(string)] = new StringResolver(),
			[typeof(Nullable)] = new NullableResolver()
		};

		private readonly BsonMapper _mapper;

		private readonly Expression _expr;

		private readonly ParameterExpression _rootParameter;

		private readonly BsonDocument _parameters = new BsonDocument();

		private int _paramIndex;

		private Type _dbRefType;

		private readonly StringBuilder _builder = new StringBuilder();

		private readonly Stack<MemberExpression> _memberAccessNodes = new Stack<MemberExpression>();

		public LinqExpressionVisitor(BsonMapper mapper, Expression expr)
		{
			_mapper = mapper;
			_expr = expr;
			if (expr is LambdaExpression lambdaExpression)
			{
				_rootParameter = lambdaExpression.Parameters.First();
				return;
			}
			throw new NotSupportedException("Expression " + expr.ToString() + " must be a lambda expression");
		}

		public BsonExpression Resolve(bool predicate)
		{
			Visit(_expr);
			Constants.ENSURE(_memberAccessNodes.Count == 0, "Member access node stack must be empty when finish expression resolve");
			string text = _builder.ToString();
			try
			{
				BsonExpression bsonExpression = BsonExpression.Create(text, _parameters);
				if (predicate && (bsonExpression.Type == BsonExpressionType.Path || bsonExpression.Type == BsonExpressionType.Call || bsonExpression.Type == BsonExpressionType.Parameter))
				{
					text = "(" + text + " = true)";
					bsonExpression = BsonExpression.Create(text, _parameters);
				}
				return bsonExpression;
			}
			catch (Exception innerException)
			{
				throw new NotSupportedException("Invalid BsonExpression when converted from Linq expression: " + _expr.ToString() + " - `" + text + "`", innerException);
			}
		}

		protected override Expression VisitLambda<T>(Expression<T> node)
		{
			Expression result = base.VisitLambda(node);
			_builder.Length--;
			return result;
		}

		protected override Expression VisitInvocation(InvocationExpression node)
		{
			Expression result = base.VisitInvocation(node);
			_builder.Length--;
			return result;
		}

		protected override Expression VisitParameter(ParameterExpression node)
		{
			_builder.Append(_rootParameter.Equals(node) ? "$" : "@");
			return base.VisitParameter(node);
		}

		protected override Expression VisitMember(MemberExpression node)
		{
			bool flag = ParameterExpressionVisitor.Test(node);
			MemberInfo member = node.Member;
			if (TryGetResolver(member.DeclaringType, out var typeResolver))
			{
				string text = typeResolver.ResolveMember(member);
				if (text == null)
				{
					throw new NotSupportedException("Member " + member.Name + " are not support in " + member.DeclaringType.Name + " when convert to BsonExpression (" + node.ToString() + ").");
				}
				ResolvePattern(text, node.Expression, new Expression[0]);
			}
			else if (node.Expression != null)
			{
				_memberAccessNodes.Push(node);
				base.Visit(node.Expression);
				if (flag)
				{
					MemberMapper memberMapper;
					string value = ResolveMember(member, out memberMapper);
					_builder.Append(value);
				}
				_memberAccessNodes.Pop();
			}
			else
			{
				object value2 = Evaluate(node);
				base.Visit(Expression.Constant(value2));
			}
			return node;
		}

		protected override Expression VisitMethodCall(MethodCallExpression node)
		{
			if (IsSpanImplicitConversion(node.Method))
			{
				Visit(node.Arguments[0]);
				return node;
			}
			if (IsMethodIndexEval(node, out var obj, out var idx))
			{
				Visit(obj);
				object obj2 = Evaluate(idx, typeof(string), typeof(int));
				if (obj2 is string)
				{
					_builder.Append(".");
					_builder.Append($"['{obj2}']");
				}
				else
				{
					_builder.Append($"[{obj2}]");
				}
				return node;
			}
			ITypeResolver typeResolver;
			bool flag = TryGetResolver(node.Method.DeclaringType, out typeResolver);
			if (node.Method.DeclaringType == typeof(Enumerable) && node.Arguments.Count > 0)
			{
				Type type = node.Arguments[0].Type;
				if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IGrouping<, >))
				{
					typeResolver = _resolver[typeof(IGrouping<, >)];
					flag = true;
				}
			}
			if (!flag)
			{
				if (ParameterExpressionVisitor.Test(node))
				{
					throw new NotSupportedException("Method " + node.Method.Name + " not available to convert to BsonExpression (" + node.ToString() + ").");
				}
				object value = Evaluate(node);
				base.Visit(Expression.Constant(value));
				return node;
			}
			string text = typeResolver.ResolveMethod(node.Method);
			if (text == null)
			{
				throw new NotSupportedException("Method " + Reflection.MethodName(node.Method) + " in " + node.Method.DeclaringType.Name + " are not supported when convert to BsonExpression (" + node.ToString() + ").");
			}
			ResolvePattern(text, node.Object, node.Arguments);
			return node;
		}

		protected override Expression VisitConstant(ConstantExpression node)
		{
			object value = node.Value;
			foreach (MemberExpression memberAccessNode in _memberAccessNodes)
			{
				if (memberAccessNode.Member is FieldInfo fieldInfo)
				{
					value = fieldInfo.GetValue(value);
				}
				else if (memberAccessNode.Member is PropertyInfo propertyInfo)
				{
					value = propertyInfo.GetValue(value);
				}
			}
			string text = "p" + _paramIndex++;
			_builder.AppendFormat("@" + text);
			Type type = value?.GetType();
			BsonValue value2 = ((type == null) ? BsonValue.Null : ((type == typeof(string)) ? new BsonValue((string)value) : _mapper.Serialize(value.GetType(), value)));
			_parameters[text] = value2;
			return node;
		}

		protected override Expression VisitUnary(UnaryExpression node)
		{
			if (node.NodeType == ExpressionType.Not)
			{
				if (node.Operand.NodeType == ExpressionType.MemberAccess)
				{
					_builder.Append("(");
					Visit(node.Operand);
					_builder.Append(" = false)");
				}
				else
				{
					_builder.Append("(");
					Visit(node.Operand);
					_builder.Append(")");
					_builder.Append(" = false");
				}
			}
			else if (node.NodeType == ExpressionType.Convert)
			{
				Type fromType = node.Operand.Type;
				Type type = node.Type;
				if ((fromType == typeof(double) || fromType == typeof(decimal)) && (type == typeof(int) || type == typeof(long)))
				{
					string methodName = "To" + type.Name.ToString();
					MethodInfo methodInfo = (from x in typeof(Convert).GetMethods()
						where x.Name == methodName
						where x.GetParameters().Length == 1 && x.GetParameters().Any((ParameterInfo z) => z.ParameterType == fromType)
						select x).FirstOrDefault();
					if (methodInfo == null)
					{
						throw new NotSupportedException("Cast from " + fromType.Name + " are not supported when convert to BsonExpression");
					}
					MethodCallExpression node2 = Expression.Call(null, methodInfo, node.Operand);
					VisitMethodCall(node2);
				}
				else
				{
					base.VisitUnary(node);
				}
			}
			else if (node.NodeType == ExpressionType.ArrayLength)
			{
				_builder.Append("LENGTH(");
				Visit(node.Operand);
				_builder.Append(")");
			}
			else
			{
				base.VisitUnary(node);
			}
			return node;
		}

		protected override Expression VisitNew(NewExpression node)
		{
			if (node.Members == null)
			{
				if (!TryGetResolver(node.Type, out var typeResolver))
				{
					throw new NotSupportedException($"New instance are not supported for {node.Type} when convert to BsonExpression ({node.ToString()}).");
				}
				string text = typeResolver.ResolveCtor(node.Constructor);
				if (text == null)
				{
					throw new NotSupportedException("Constructor for " + node.Type.Name + " are not supported when convert to BsonExpression (" + node.ToString() + ").");
				}
				ResolvePattern(text, null, node.Arguments);
			}
			else
			{
				_builder.Append("{ ");
				for (int i = 0; i < node.Members.Count; i++)
				{
					MemberInfo memberInfo = node.Members[i];
					_builder.Append((i > 0) ? ", " : "");
					_builder.AppendFormat("'{0}': ", memberInfo.Name);
					Visit(node.Arguments[i]);
				}
				_builder.Append(" }");
			}
			return node;
		}

		protected override Expression VisitMemberInit(MemberInitExpression node)
		{
			if (node.NewExpression.Constructor.GetParameters().Length != 0)
			{
				throw new NotSupportedException($"New instance of {node.Type} are not supported because contains ctor with parameter. Try use only property initializers: `new {node.Type.Name} {{ PropA = 1, PropB == \"John\" }}`.");
			}
			_builder.Append("{");
			for (int i = 0; i < node.Bindings.Count; i++)
			{
				MemberAssignment memberAssignment = node.Bindings[i] as MemberAssignment;
				MemberMapper memberMapper;
				string text = ResolveMember(memberAssignment.Member, out memberMapper);
				_builder.Append((i > 0) ? ", " : "");
				_builder.Append(text.Substring(1));
				_builder.Append(":");
				if (!TryVisitDbRefIdExpression(memberAssignment.Expression, memberMapper))
				{
					Visit(memberAssignment.Expression);
				}
			}
			_builder.Append("}");
			return node;
		}

		protected override Expression VisitNewArray(NewArrayExpression node)
		{
			_builder.Append("[ ");
			for (int i = 0; i < node.Expressions.Count; i++)
			{
				_builder.Append((i > 0) ? ", " : "");
				Visit(node.Expressions[i]);
			}
			_builder.Append(" ]");
			return node;
		}

		protected override Expression VisitBinary(BinaryExpression node)
		{
			bool ensurePredicate = node.NodeType == ExpressionType.AndAlso || node.NodeType == ExpressionType.OrElse;
			if (node.NodeType == ExpressionType.Coalesce)
			{
				return VisitCoalesce(node);
			}
			if (node.NodeType == ExpressionType.ArrayIndex)
			{
				return VisitArrayIndex(node);
			}
			string @operator = GetOperator(node.NodeType);
			_builder.Append("(");
			VisitAsPredicate(node.Left, ensurePredicate);
			_builder.Append(@operator);
			if (!_mapper.EnumAsInteger && node.Left.NodeType == ExpressionType.Convert && node.Left is UnaryExpression unaryExpression && unaryExpression.Operand.Type.GetTypeInfo().IsEnum && unaryExpression.Type == typeof(int))
			{
				VisitAsPredicate(Expression.Constant(Enum.GetName(unaryExpression.Operand.Type, Evaluate(node.Right))), ensurePredicate);
			}
			else
			{
				VisitAsPredicate(node.Right, ensurePredicate);
			}
			_builder.Append(")");
			return node;
		}

		protected override Expression VisitConditional(ConditionalExpression node)
		{
			_builder.Append("IIF(");
			Visit(node.Test);
			_builder.Append(", ");
			Visit(node.IfTrue);
			_builder.Append(", ");
			Visit(node.IfFalse);
			_builder.Append(")");
			return node;
		}

		private Expression VisitCoalesce(BinaryExpression node)
		{
			_builder.Append("COALESCE(");
			Visit(node.Left);
			_builder.Append(", ");
			Visit(node.Right);
			_builder.Append(")");
			return node;
		}

		private Expression VisitArrayIndex(BinaryExpression node)
		{
			Visit(node.Left);
			_builder.Append("[");
			object value = Evaluate(node.Right, typeof(int));
			_builder.Append(value);
			_builder.Append("]");
			return node;
		}

		private void ResolvePattern(string pattern, Expression obj, IList<Expression> args)
		{
			Tokenizer tokenizer = new Tokenizer(pattern);
			while (!tokenizer.EOF)
			{
				Token token = tokenizer.ReadToken(eatWhitespace: false);
				if (token.Type == TokenType.Hashtag)
				{
					Visit(obj);
				}
				else if (token.Type == TokenType.At && tokenizer.LookAhead(eatWhitespace: false).Type == TokenType.Int)
				{
					int index = Convert.ToInt32(tokenizer.ReadToken(eatWhitespace: false).Expect(TokenType.Int).Value);
					Visit(args[index]);
				}
				else if (token.Type == TokenType.Percent)
				{
					VisitEnumerablePredicate(args[1] as LambdaExpression);
				}
				else
				{
					_builder.Append((token.Type == TokenType.String) ? ("'" + token.Value + "'") : token.Value);
				}
			}
		}

		private void VisitEnumerablePredicate(LambdaExpression lambda)
		{
			Expression body = lambda.Body;
			if (body is BinaryExpression binaryExpression)
			{
				if (binaryExpression.Left.NodeType != ExpressionType.Parameter)
				{
					throw new LiteException(0, "Any/All requires simple parameter on left side. Eg: `x => x.Phones.Select(p => p.Number).Any(n => n > 5)`");
				}
				string @operator = GetOperator(binaryExpression.NodeType);
				_builder.Append(@operator);
				VisitAsPredicate(binaryExpression.Right, ensurePredicate: false);
				return;
			}
			if (body is MethodCallExpression methodCallExpression)
			{
				if (methodCallExpression.Object.NodeType != ExpressionType.Parameter)
				{
					throw new NotSupportedException("Any/All requires simple parameter on left side. Eg: `x.Customers.Select(c => c.Name).Any(n => n.StartsWith('J'))`");
				}
				if (!TryGetResolver(methodCallExpression.Method.DeclaringType, out var typeResolver))
				{
					throw new NotSupportedException("Method " + methodCallExpression.Method.Name + " not available to convert to BsonExpression inside Any/All call.");
				}
				string text = typeResolver.ResolveMethod(methodCallExpression.Method);
				if (text == null || !text.StartsWith("#"))
				{
					throw new NotSupportedException("Method " + methodCallExpression.Method.Name + " not available to convert to BsonExpression inside Any/All call.");
				}
				ResolvePattern(text.Substring(1), methodCallExpression.Object, methodCallExpression.Arguments);
				return;
			}
			throw new LiteException(0, "When using Any/All method test do only simple predicate variable. Eg: `x => x.Phones.Select(p => p.Number).Any(n => n > 5)`");
		}

		private string GetOperator(ExpressionType nodeType)
		{
			return nodeType switch
			{
				ExpressionType.Add => " + ", 
				ExpressionType.Multiply => " * ", 
				ExpressionType.Subtract => " - ", 
				ExpressionType.Divide => " / ", 
				ExpressionType.Equal => " = ", 
				ExpressionType.NotEqual => " != ", 
				ExpressionType.GreaterThan => " > ", 
				ExpressionType.GreaterThanOrEqual => " >= ", 
				ExpressionType.LessThan => " < ", 
				ExpressionType.LessThanOrEqual => " <= ", 
				ExpressionType.And => " AND ", 
				ExpressionType.AndAlso => " AND ", 
				ExpressionType.Or => " OR ", 
				ExpressionType.OrElse => " OR ", 
				_ => throw new NotSupportedException($"Operator not supported {nodeType}"), 
			};
		}

		private string ResolveMember(MemberInfo member, out MemberMapper memberMapper)
		{
			string name = member.Name;
			bool flag = _dbRefType != null && member.DeclaringType.IsAssignableFrom(_dbRefType);
			EntityMapper entityMapper = _mapper.GetEntityMapper(member.DeclaringType);
			entityMapper.WaitForInitialization();
			MemberMapper memberMapper2 = entityMapper.Members.FirstOrDefault((MemberMapper x) => x.MemberName == name);
			memberMapper = memberMapper2 ?? throw new NotSupportedException($"Member {name} not found on BsonMapper for type {member.DeclaringType}.");
			_dbRefType = (memberMapper2.IsDbRef ? memberMapper2.UnderlyingType : null);
			return "." + ((flag && memberMapper2.FieldName == "_id") ? "$id" : memberMapper2.FieldName);
		}

		private bool IsMethodIndexEval(MethodCallExpression node, out Expression obj, out Expression idx)
		{
			MethodInfo method = node.Method;
			_ = method.DeclaringType;
			ParameterInfo[] parameters = method.GetParameters();
			if (method.Name == "get_Item" && parameters.Length == 1 && (parameters[0].ParameterType == typeof(int) || parameters[0].ParameterType == typeof(string)))
			{
				obj = node.Object;
				idx = node.Arguments[0];
				return true;
			}
			obj = null;
			idx = null;
			return false;
		}

		private void VisitAsPredicate(Expression expr, bool ensurePredicate)
		{
			ensurePredicate = ensurePredicate && (expr.NodeType == ExpressionType.MemberAccess || expr.NodeType == ExpressionType.Call || expr.NodeType == ExpressionType.Invoke || expr.NodeType == ExpressionType.Constant);
			if (ensurePredicate)
			{
				_builder.Append("(");
				_builder.Append("(");
				base.Visit(expr);
				_builder.Append(")");
				_builder.Append(" = true)");
			}
			else
			{
				base.Visit(expr);
			}
		}

		private object Evaluate(Expression expr, params Type[] validTypes)
		{
			object value = null;
			if (expr.NodeType == ExpressionType.Constant)
			{
				ConstantExpression constantExpression = (ConstantExpression)expr;
				value = constantExpression.Value;
			}
			else
			{
				Delegate @delegate = Expression.Lambda(expr).Compile();
				value = @delegate.DynamicInvoke();
			}
			if (validTypes.Length != 0 && value == null)
			{
				throw new NotSupportedException($"Expression {expr} can't return null value");
			}
			if (validTypes.Length != 0 && !validTypes.Any((Type x) => x == value.GetType()))
			{
				throw new NotSupportedException(string.Format("Expression {0} must return on of this types: {1}", expr, string.Join(", ", validTypes.Select((Type x) => "`" + x.Name + "`"))));
			}
			return value;
		}

		private bool TryVisitDbRefIdExpression(Expression node, MemberMapper memberMapper, bool isInList = false)
		{
			if (!memberMapper.IsDbRef)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(memberMapper.DbRefCollectionName))
			{
				throw new NotSupportedException("BsonRefId<T> requires a DbRef collection name. Member '" + memberMapper.MemberName + "' is missing it (use [BsonRef] or Entity<T>().DbRef(...)).");
			}
			if (node is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType == ExpressionType.Convert)
				{
					MethodInfo method = unaryExpression.Method;
					if ((object)method != null && method.Name == "op_Implicit")
					{
						Expression operand = unaryExpression.Operand;
						return TryVisitDbRefIdExpression(operand, memberMapper, isInList);
					}
				}
			}
			else if (node is NewExpression newExpression)
			{
				if (newExpression.Members == null)
				{
					Type type = newExpression.Type;
					if ((object)type != null && type.IsConstructedGenericType && newExpression.Type.GetGenericTypeDefinition() == typeof(BsonRefId<>))
					{
						Type c = newExpression.Type.GetGenericArguments()[0];
						if (memberMapper.DataType.IsAssignableFrom(c) || (isInList && memberMapper.UnderlyingType.IsAssignableFrom(c)))
						{
							ResolveDbRefId(newExpression, memberMapper);
							return true;
						}
						return false;
					}
				}
			}
			else if (!(node is NewArrayExpression newArrayExpression))
			{
				if (node is ListInitExpression listInitExpression)
				{
					Type type2 = listInitExpression.Type;
					if ((object)type2 != null && type2.IsConstructedGenericType)
					{
						Type[] genericTypeArguments = type2.GenericTypeArguments;
						if (genericTypeArguments != null && genericTypeArguments.Length == 1 && !isInList && listInitExpression.Type.GetGenericTypeDefinition() == typeof(List<>) && memberMapper.UnderlyingType.IsAssignableFrom(listInitExpression.Type.GetGenericArguments()[0]))
						{
							_builder.Append("[ ");
							for (int i = 0; i < listInitExpression.Initializers.Count; i++)
							{
								if (i > 0)
								{
									_builder.Append(", ");
								}
								ElementInit elementInit = listInitExpression.Initializers[i];
								if (elementInit.Arguments.Count != 1 || elementInit.AddMethod.Name != "Add")
								{
									throw new NotSupportedException($"List initializers {elementInit.AddMethod.Name} not supported when convert to BsonExpression ({node}).");
								}
								if (!TryVisitDbRefIdExpression(elementInit.Arguments[0], memberMapper, isInList: true))
								{
									throw new NotSupportedException($"Expression {listInitExpression} not supported for BsonRefId<T>.");
								}
							}
							_builder.Append(" ]");
							return true;
						}
					}
				}
			}
			else if (!isInList && newArrayExpression.Type.IsArray && memberMapper.UnderlyingType.IsAssignableFrom(newArrayExpression.Type.GetElementType()))
			{
				_builder.Append("[ ");
				for (int j = 0; j < newArrayExpression.Expressions.Count; j++)
				{
					if (j > 0)
					{
						_builder.Append(", ");
					}
					if (!TryVisitDbRefIdExpression(newArrayExpression.Expressions[j], memberMapper, isInList: true))
					{
						throw new NotSupportedException($"Expression {newArrayExpression} not supported for BsonRefId<T>.");
					}
				}
				_builder.Append(" ]");
				return true;
			}
			return false;
		}

		private void ResolveDbRefId(NewExpression node, MemberMapper memberMapper)
		{
			if (string.IsNullOrWhiteSpace(memberMapper.DbRefCollectionName))
			{
				throw new NotSupportedException("BsonRefId<T> requires a DbRef collection name. Member '" + memberMapper.MemberName + "' is missing it (use [BsonRef] or Entity<T>().DbRef(...)).");
			}
			_builder.Append("{ $id:");
			ResolvePattern("@0", null, node.Arguments);
			_builder.Append(", $ref: ");
			Visit(Expression.Constant(memberMapper.DbRefCollectionName));
			Type type = node.Type.GetGenericArguments()[0];
			if (type != memberMapper.UnderlyingType)
			{
				_builder.Append(", $type: ");
				Visit(Expression.Constant(_mapper.SerializeTypeName(type)));
			}
			_builder.Append(" }");
		}

		private static bool TryGetResolver(Type declaringType, out ITypeResolver typeResolver)
		{
			bool num = (object)declaringType != null && declaringType.IsGenericType && declaringType.GetGenericTypeDefinition() == typeof(IGrouping<, >);
			bool flag = Reflection.IsCollection(declaringType);
			bool flag2 = Reflection.IsEnumerable(declaringType);
			bool flag3 = Reflection.IsNullable(declaringType);
			Type key = (num ? typeof(IGrouping<, >) : (flag ? typeof(ICollection) : (flag2 ? typeof(Enumerable) : (flag3 ? typeof(Nullable) : declaringType))));
			return _resolver.TryGetValue(key, out typeResolver);
		}

		private bool IsSpanImplicitConversion(MethodInfo method)
		{
			if (method == null || method.Name != "op_Implicit" || method.GetParameters().Length != 1)
			{
				return false;
			}
			Type returnType = method.ReturnType;
			return IsSpanLike(returnType);
		}

		private bool IsSpanLike(Type type)
		{
			if (type == null || !type.IsGenericType)
			{
				return false;
			}
			string fullName = type.GetGenericTypeDefinition().FullName;
			if (!(fullName == "System.Span`1"))
			{
				return fullName == "System.ReadOnlySpan`1";
			}
			return true;
		}
	}
	internal class ParameterExpressionVisitor : ExpressionVisitor
	{
		public bool IsParameter { get; private set; }

		protected override Expression VisitParameter(ParameterExpression node)
		{
			IsParameter = true;
			return base.VisitParameter(node);
		}

		public static bool Test(Expression node)
		{
			ParameterExpressionVisitor parameterExpressionVisitor = new ParameterExpressionVisitor();
			parameterExpressionVisitor.Visit(node);
			return parameterExpressionVisitor.IsParameter;
		}
	}
	internal class BsonValueResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			return null;
		}

		public string ResolveMember(MemberInfo member)
		{
			switch (member.Name)
			{
			case "AsInt32":
			case "AsInt64":
			case "AsArray":
			case "AsDateTime":
			case "AsDocument":
			case "AsObjectId":
			case "AsString":
			case "AsBinary":
			case "AsDouble":
			case "AsBoolean":
			case "AsDecimal":
			case "AsGuid":
				return "#";
			case "IsNull":
				return "IS_NULL(#)";
			case "IsArray":
				return "IS_ARRAY(#)";
			case "IsDocument":
				return "IS_DOCUMENT(#)";
			case "IsInt32":
				return "IS_INT32(#)";
			case "IsInt64":
				return "IS_INT64(#)";
			case "IsDouble":
				return "IS_DOUBLE(#)";
			case "IsDecimal":
				return "IS_DECIMAL(#)";
			case "IsNumber":
				return "IS_NUMBER(#)";
			case "IsBinary":
				return "IS_BINARY(#)";
			case "IsBoolean":
				return "IS_BOOLEAN(#)";
			case "IsString":
				return "IS_STRING(#)";
			case "IsObjectId":
				return "IS_OBJECTID(#)";
			case "IsGuid":
				return "IS_GUID(#)";
			case "IsDateTime":
				return "IS_DATETIME(#)";
			case "IsMinValue":
				return "IS_MINVALUE(#)";
			case "IsMaxValue":
				return "IS_MAXVALUE(#)";
			default:
				return null;
			}
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class ConvertResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			return method.Name switch
			{
				"ToInt32" => "INT32(@0)", 
				"ToInt64" => "INT64(@0)", 
				"ToDouble" => "DOUBLE(@0)", 
				"ToDecimal" => "DECIMAL(@0)", 
				"ToDateTime" => "DATE(@0)", 
				"FromBase64String" => "BINARY(@0)", 
				"ToBoolean" => "BOOL(@0)", 
				"ToString" => "STRING(@0)", 
				_ => null, 
			};
		}

		public string ResolveMember(MemberInfo member)
		{
			return null;
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class DateTimeResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			switch (method.Name)
			{
			case "AddYears":
				return "DATEADD('y', @0, #)";
			case "AddMonths":
				return "DATEADD('M', @0, #)";
			case "AddDays":
				return "DATEADD('d', @0, #)";
			case "AddHours":
				return "DATEADD('h', @0, #)";
			case "AddMinutes":
				return "DATEADD('m', @0, #)";
			case "AddSeconds":
				return "DATEADD('s', @0, #)";
			case "ToString":
			{
				ParameterInfo[] parameters = method.GetParameters();
				if (parameters.Length == 0)
				{
					return "STRING(#)";
				}
				if (parameters.Length == 1 && parameters[0].ParameterType == typeof(string))
				{
					return "FORMAT(#, @0)";
				}
				break;
			}
			case "ToUniversalTime":
				return "TO_UTC(#)";
			case "Parse":
				return "DATETIME(@0)";
			case "Equals":
				return "# = @0";
			}
			return null;
		}

		public string ResolveMember(MemberInfo member)
		{
			return member.Name switch
			{
				"Now" => "NOW()", 
				"UtcNow" => "NOW_UTC()", 
				"Today" => "TODAY()", 
				"Year" => "YEAR(#)", 
				"Month" => "MONTH(#)", 
				"Day" => "DAY(#)", 
				"Hour" => "HOUR(#)", 
				"Minute" => "MINUTE(#)", 
				"Second" => "SECOND(#)", 
				"Date" => "DATETIME(YEAR(#), MONTH(#), DAY(#))", 
				"ToLocalTime" => "TO_LOCAL(#)", 
				"ToUniversalTime" => "TO_UTC(#)", 
				_ => null, 
			};
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			ParameterInfo[] parameters = ctor.GetParameters();
			if (parameters.Length == 3 && parameters[0].ParameterType == typeof(int) && parameters[1].ParameterType == typeof(int) && parameters[2].ParameterType == typeof(int))
			{
				return "DATETIME(@0, @1, @2)";
			}
			return null;
		}
	}
	internal class EnumerableResolver : ITypeResolver
	{
		public virtual string ResolveMethod(MethodInfo method)
		{
			switch (Reflection.MethodName(method, 1))
			{
			case "AsEnumerable()":
				return "@0[*]";
			case "get_Item(int)":
				return "#[@0]";
			case "ElementAt(int)":
				return "@0[@1]";
			case "Single()":
			case "First()":
			case "SingleOrDefault()":
			case "FirstOrDefault()":
				return "@0[0]";
			case "Last()":
			case "LastOrDefault()":
				return "@0[-1]";
			case "Single(Func<T,TResult>)":
			case "First(Func<T,TResult>)":
			case "SingleOrDefault(Func<T,TResult>)":
			case "FirstOrDefault(Func<T,TResult>)":
				return "FIRST(FILTER(@0 => @1))";
			case "Last(Func<T,TResult>)":
			case "LastOrDefault(Func<T,TResult>)":
				return "LAST(FILTER(@0 => @1))";
			case "Where(Func<T,TResult>)":
				return "FILTER(@0 => @1)";
			case "Select(Func<T,TResult>)":
				return "MAP(@0 => @1)";
			case "Count()":
				return "COUNT(@0)";
			case "Sum()":
				return "SUM(@0)";
			case "Average()":
				return "AVG(@0)";
			case "Max()":
				return "MAX(@0)";
			case "Min()":
				return "MIN(@0)";
			case "Count(Func<T,TResult>)":
				return "COUNT(FILTER(@0 => @1))";
			case "Sum(Func<T,TResult>)":
				return "SUM(MAP(@0 => @1))";
			case "Average(Func<T,TResult>)":
				return "AVG(MAP(@0 => @1))";
			case "Max(Func<T,TResult>)":
				return "MAX(MAP(@0 => @1))";
			case "Min(Func<T,TResult>)":
				return "MIN(MAP(@0 => @1))";
			case "ToList()":
			case "ToArray()":
				return "ARRAY(@0)";
			case "Any(Func<T,TResult>)":
				return "@0 ANY %";
			case "All(Func<T,TResult>)":
				return "@0 ALL %";
			case "Any()":
				return "COUNT(@0) > 0";
			default:
				if (method.Name == "Contains")
				{
					return "@0 ANY = @1";
				}
				return null;
			}
		}

		public virtual string ResolveMember(MemberInfo member)
		{
			string name = member.Name;
			if (!(name == "Length"))
			{
				if (name == "Count")
				{
					return "COUNT(#)";
				}
				return null;
			}
			return "LENGTH(#)";
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class GroupingResolver : EnumerableResolver
	{
		public override string ResolveMethod(MethodInfo method)
		{
			return Reflection.MethodName(method, 1) switch
			{
				"AsEnumerable()" => "*", 
				"Where(Func<T,TResult>)" => "FILTER(* => @1)", 
				"Select(Func<T,TResult>)" => "MAP(* => @1)", 
				"Count()" => "COUNT(*)", 
				"Count(Func<T,TResult>)" => "COUNT(FILTER(* => @1))", 
				"Any()" => "COUNT(*) > 0", 
				"Any(Func<T,TResult>)" => "FILTER(* => @1) ANY %", 
				"All(Func<T,TResult>)" => "FILTER(* => @1) ALL %", 
				"Sum()" => "SUM(*)", 
				"Sum(Func<T,TResult>)" => "SUM(MAP(* => @1))", 
				"Average()" => "AVG(*)", 
				"Average(Func<T,TResult>)" => "AVG(MAP(* => @1))", 
				"Max()" => "MAX(*)", 
				"Max(Func<T,TResult>)" => "MAX(MAP(* => @1))", 
				"Min()" => "MIN(*)", 
				"Min(Func<T,TResult>)" => "MIN(MAP(* => @1))", 
				_ => base.ResolveMethod(method), 
			};
		}

		public override string ResolveMember(MemberInfo member)
		{
			if (member.Name == "Key")
			{
				return "@key";
			}
			if (member.Name == "Count")
			{
				return "COUNT(*)";
			}
			return base.ResolveMember(member);
		}
	}
	internal class GuidResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			return method.Name switch
			{
				"ToString" => "STRING(#)", 
				"NewGuid" => "GUID()", 
				"Parse" => "GUID(@0)", 
				"TryParse" => throw new NotSupportedException("There is no TryParse translate. Use Guid.Parse()"), 
				"Equals" => "# = @0", 
				_ => null, 
			};
		}

		public string ResolveMember(MemberInfo member)
		{
			if (member.Name == "Empty")
			{
				return "GUID('00000000-0000-0000-0000-000000000000')";
			}
			return null;
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			ParameterInfo[] parameters = ctor.GetParameters();
			if (parameters.Length == 1 && parameters[0].ParameterType == typeof(string))
			{
				return "GUID(@0)";
			}
			return null;
		}
	}
	internal class ICollectionResolver : EnumerableResolver
	{
		public override string ResolveMethod(MethodInfo method)
		{
			if (method.Name == "Contains")
			{
				return "# ANY = @0";
			}
			return base.ResolveMethod(method);
		}
	}
	internal interface ITypeResolver
	{
		string ResolveMethod(MethodInfo method);

		string ResolveMember(MemberInfo member);

		string ResolveCtor(ConstructorInfo ctor);
	}
	internal class MathResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			int num = method.GetParameters().Length;
			switch (method.Name)
			{
			case "Abs":
				return "ABS(@0)";
			case "Pow":
				return "POW(@0, @1)";
			case "Round":
				if (num != 2)
				{
					throw new ArgumentOutOfRangeException("Method Round need 2 arguments when convert to BsonExpression");
				}
				return "ROUND(@0, @1)";
			default:
				return null;
			}
		}

		public string ResolveMember(MemberInfo member)
		{
			return null;
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class MemoryExtensionsResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			if (method.Name != "Contains")
			{
				return null;
			}
			ParameterInfo[] parameters = method.GetParameters();
			if (parameters.Length == 2)
			{
				return "@0 ANY = @1";
			}
			if (parameters.Length == 3)
			{
				ParameterInfo parameterInfo = parameters[2];
				if (parameterInfo.HasDefaultValue && parameterInfo.DefaultValue == null)
				{
					return "@0 ANY = @1";
				}
			}
			return null;
		}

		public string ResolveMember(MemberInfo member)
		{
			return null;
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class NullableResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			return null;
		}

		public string ResolveMember(MemberInfo member)
		{
			string name = member.Name;
			if (!(name == "HasValue"))
			{
				if (name == "Value")
				{
					return "#";
				}
				return null;
			}
			return "(IS_NULL(#) = false)";
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class NumberResolver : ITypeResolver
	{
		private readonly string _parseMethod;

		public NumberResolver(string parseMethod)
		{
			_parseMethod = parseMethod;
		}

		public string ResolveMethod(MethodInfo method)
		{
			switch (method.Name)
			{
			case "ToString":
			{
				ParameterInfo[] parameters = method.GetParameters();
				if (parameters.Length == 0)
				{
					return "STRING(#)";
				}
				if (parameters.Length == 1 && parameters[0].ParameterType == typeof(string))
				{
					return "FORMAT(#, @0)";
				}
				break;
			}
			case "Parse":
				return _parseMethod + "(@0)";
			case "Equals":
				return "# = @0";
			}
			return null;
		}

		public string ResolveMember(MemberInfo member)
		{
			return null;
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class ObjectIdResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			string name = method.Name;
			if (!(name == "ToString"))
			{
				if (name == "Equals")
				{
					return "# = @0";
				}
				return null;
			}
			return "STRING(#)";
		}

		public string ResolveMember(MemberInfo member)
		{
			string name = member.Name;
			if (!(name == "Empty"))
			{
				if (name == "CreationTime")
				{
					return "OID_CREATIONTIME(#)";
				}
				return null;
			}
			return "OBJECTID('000000000000000000000000')";
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			ParameterInfo[] parameters = ctor.GetParameters();
			if (parameters.Length == 1 && parameters[0].ParameterType == typeof(string))
			{
				return "OBJECTID(@0)";
			}
			return null;
		}
	}
	internal class RegexResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			string name = method.Name;
			if (!(name == "Split"))
			{
				if (name == "IsMatch")
				{
					return "IS_MATCH(@0, @1)";
				}
				return null;
			}
			return "SPLIT(@0, @1, true)";
		}

		public string ResolveMember(MemberInfo member)
		{
			return null;
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class StringResolver : ITypeResolver
	{
		public string ResolveMethod(MethodInfo method)
		{
			int num = method.GetParameters().Length;
			switch (method.Name)
			{
			case "Count":
				return "LENGTH(#)";
			case "Trim":
				return "TRIM(#)";
			case "TrimStart":
				return "LTRIM(#)";
			case "TrimEnd":
				return "RTRIM(#)";
			case "ToUpper":
				return "UPPER(#)";
			case "ToUpperInvariant":
				return "UPPER(#)";
			case "ToLower":
				return "LOWER(#)";
			case "ToLowerInvariant":
				return "LOWER(#)";
			case "Replace":
				return "REPLACE(#, @0, @1)";
			case "PadLeft":
				return "LPAD(#, @0, @1)";
			case "RightLeft":
				return "RPAD(#, @0, @1)";
			case "IndexOf":
				if (num != 1)
				{
					return "INDEXOF(#, @0, @1)";
				}
				return "INDEXOF(#, @0)";
			case "Substring":
				if (num != 1)
				{
					return "SUBSTRING(#, @0, @1)";
				}
				return "SUBSTRING(#, @0)";
			case "StartsWith":
				return "# LIKE (@0 + '%')";
			case "Contains":
				return "# LIKE ('%' + @0 + '%')";
			case "EndsWith":
				return "# LIKE ('%' + @0)";
			case "ToString":
				return "#";
			case "Equals":
				return "# = @0";
			case "IsNullOrEmpty":
				return "(LENGTH(@0) = 0)";
			case "IsNullOrWhiteSpace":
				return "(LENGTH(TRIM(@0)) = 0)";
			case "Format":
				throw new NotImplementedException();
			case "Join":
				throw new NotImplementedException();
			default:
				return null;
			}
		}

		public string ResolveMember(MemberInfo member)
		{
			string name = member.Name;
			if (!(name == "Length"))
			{
				if (name == "Empty")
				{
					return "''";
				}
				return null;
			}
			return "LENGTH(#)";
		}

		public string ResolveCtor(ConstructorInfo ctor)
		{
			return null;
		}
	}
	internal class MemberMapper
	{
		private bool _isDbRef;

		public bool AutoId { get; set; }

		public string MemberName { get; set; }

		public Type DataType { get; set; }

		public string FieldName { get; set; }

		public GenericGetter Getter { get; set; }

		public GenericSetter Setter { get; set; }

		public Func<object, BsonMapper, BsonValue> Serialize { get; set; }

		public Func<BsonValue, BsonMapper, object> Deserialize { get; set; }

		public bool IsDbRef
		{
			get
			{
				if (!_isDbRef)
				{
					return DbRefCollectionName != null;
				}
				return true;
			}
			set
			{
				_isDbRef = value;
				if (!value)
				{
					DbRefCollectionName = null;
				}
			}
		}

		public bool IsEnumerable { get; set; }

		public Type UnderlyingType { get; set; }

		public bool IsIgnore { get; set; }

		internal string DbRefCollectionName { get; set; }
	}
	internal delegate object CreateObject(BsonDocument value);
	internal delegate void GenericSetter(object target, object value);
	internal delegate object GenericGetter(object obj);
	internal class Reflection
	{
		private static readonly Dictionary<Type, CreateObject> _cacheCtor = new Dictionary<Type, CreateObject>();

		public static readonly Dictionary<Type, PropertyInfo> ConvertType = new Dictionary<Type, PropertyInfo>
		{
			[typeof(DateTime)] = typeof(BsonValue).GetProperty("AsDateTime"),
			[typeof(decimal)] = typeof(BsonValue).GetProperty("AsDecimal"),
			[typeof(double)] = typeof(BsonValue).GetProperty("AsDouble"),
			[typeof(long)] = typeof(BsonValue).GetProperty("AsInt64"),
			[typeof(int)] = typeof(BsonValue).GetProperty("AsInt32"),
			[typeof(bool)] = typeof(BsonValue).GetProperty("AsBoolean"),
			[typeof(byte[])] = typeof(BsonValue).GetProperty("AsBinary"),
			[typeof(BsonDocument)] = typeof(BsonValue).GetProperty("AsDocument"),
			[typeof(BsonArray)] = typeof(BsonValue).GetProperty("AsArray"),
			[typeof(ObjectId)] = typeof(BsonValue).GetProperty("AsObjectId"),
			[typeof(string)] = typeof(BsonValue).GetProperty("AsString"),
			[typeof(Guid)] = typeof(BsonValue).GetProperty("AsGuid")
		};

		public static readonly PropertyInfo DocumentItemProperty = (from x in typeof(BsonDocument).GetProperties()
			where x.Name == "Item" && x.GetGetMethod().GetParameters().First()
				.ParameterType == typeof(string)
			select x).First();

		private static readonly Dictionary<MethodInfo, string> _cacheName = new Dictionary<MethodInfo, string>();

		public static object CreateInstance(Type type)
		{
			try
			{
				if (_cacheCtor.TryGetValue(type, out var value))
				{
					return value(null);
				}
			}
			catch (Exception inner)
			{
				throw LiteException.InvalidCtor(type, inner);
			}
			lock (_cacheCtor)
			{
				try
				{
					if (_cacheCtor.TryGetValue(type, out var value2))
					{
						return value2(null);
					}
					TypeInfo typeInfo = type.GetTypeInfo();
					if (typeInfo.IsClass)
					{
						_cacheCtor.Add(type, value2 = CreateClass(type));
					}
					else
					{
						if (typeInfo.IsInterface)
						{
							if (typeInfo.IsGenericType)
							{
								Type genericTypeDefinition = type.GetGenericTypeDefinition();
								if (genericTypeDefinition == typeof(ISet<>))
								{
									return CreateInstance(GetGenericSetOfType(UnderlyingTypeOf(type)));
								}
								if (genericTypeDefinition == typeof(IDictionary<, >))
								{
									Type k = type.GetGenericArguments()[0];
									Type v = type.GetGenericArguments()[1];
									return CreateInstance(GetGenericDictionaryOfType(k, v));
								}
								if (genericTypeDefinition == typeof(IList<>) || genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(IEnumerable<>) || typeof(IEnumerable).IsAssignableFrom(genericTypeDefinition))
								{
									return CreateInstance(GetGenericListOfType(UnderlyingTypeOf(type)));
								}
							}
							throw LiteException.InvalidCtor(type, null);
						}
						_cacheCtor.Add(type, value2 = CreateStruct(type));
					}
					return value2(null);
				}
				catch (Exception inner2)
				{
					throw LiteException.InvalidCtor(type, inner2);
				}
			}
		}

		public static bool IsNullable(Type type)
		{
			if (!type.GetTypeInfo().IsGenericType)
			{
				return false;
			}
			return type.GetGenericTypeDefinition().Equals(typeof(Nullable<>));
		}

		public static Type UnderlyingTypeOf(Type type)
		{
			if (!type.GetTypeInfo().IsGenericType)
			{
				return type;
			}
			return type.GetGenericArguments()[0];
		}

		public static Type GetGenericListOfType(Type type)
		{
			return typeof(List<>).MakeGenericType(type);
		}

		public static Type GetGenericSetOfType(Type type)
		{
			return typeof(HashSet<>).MakeGenericType(type);
		}

		public static Type GetGenericDictionaryOfType(Type k, Type v)
		{
			return typeof(Dictionary<, >).MakeGenericType(k, v);
		}

		public static Type GetListItemType(Type listType)
		{
			if (listType.IsArray)
			{
				return listType.GetElementType();
			}
			Type[] interfaces = listType.GetInterfaces();
			foreach (Type type in interfaces)
			{
				if (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
				{
					return type.GetGenericArguments()[0];
				}
				if (listType.GetTypeInfo().IsGenericType && type == typeof(IEnumerable))
				{
					return listType.GetGenericArguments()[0];
				}
			}
			return typeof(object);
		}

		public static bool IsEnumerable(Type type)
		{
			if (type == typeof(IEnumerable) || type.IsArray)
			{
				return true;
			}
			if (type == typeof(string))
			{
				return false;
			}
			Type[] interfaces = type.GetInterfaces();
			foreach (Type type2 in interfaces)
			{
				if (type2.GetTypeInfo().IsGenericType && type2.GetGenericTypeDefinition() == typeof(IEnumerable<>))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsSimpleType(Type type)
		{
			if (!(type == typeof(string)) && !(type == typeof(bool)) && !(type == typeof(byte)) && !(type == typeof(sbyte)) && !(type == typeof(short)) && !(type == typeof(int)) && !(type == typeof(long)) && !(type == typeof(ushort)) && !(type == typeof(uint)) && !(type == typeof(ulong)) && !(type == typeof(double)) && !(type == typeof(float)) && !(type == typeof(decimal)) && !(type == typeof(ObjectId)) && !(type == typeof(DateTime)))
			{
				return type == typeof(Guid);
			}
			return true;
		}

		public static bool IsCollection(Type type)
		{
			if (!type.GetTypeInfo().IsGenericType || !type.GetGenericTypeDefinition().Equals(typeof(ICollection<>)))
			{
				return type.GetInterfaces().Any((Type x) => x == typeof(ICollection) || (x.GetTypeInfo().IsGenericType && x.GetGenericTypeDefinition() == typeof(ICollection<>)));
			}
			return true;
		}

		public static bool IsDictionary(Type type)
		{
			if (!type.GetTypeInfo().IsGenericType || !type.GetGenericTypeDefinition().Equals(typeof(IDictionary<, >)))
			{
				return type.GetInterfaces().Any((Type x) => x == typeof(IDictionary) || (x.GetTypeInfo().IsGenericType && x.GetGenericTypeDefinition().Equals(typeof(IDictionary<, >))));
			}
			return true;
		}

		public static MemberInfo SelectMember(IEnumerable<MemberInfo> members, params Func<MemberInfo, bool>[] predicates)
		{
			foreach (Func<MemberInfo, bool> predicate in predicates)
			{
				MemberInfo memberInfo = members.FirstOrDefault(predicate);
				if (memberInfo != null)
				{
					return memberInfo;
				}
			}
			return null;
		}

		public static string MethodName(MethodInfo method, int skipParameters = 0)
		{
			lock (_cacheName)
			{
				if (_cacheName.TryGetValue(method, out var value))
				{
					return value;
				}
				value = MethodNameInternal(method, skipParameters);
				_cacheName.Add(method, value);
				return value;
			}
		}

		private static string MethodNameInternal(MethodInfo method, int skipParameters = 0)
		{
			StringBuilder stringBuilder = new StringBuilder(method.Name + "(");
			int num = 0;
			foreach (ParameterInfo item in method.GetParameters().Skip(skipParameters))
			{
				if (num++ > 0)
				{
					stringBuilder.Append(",");
				}
				stringBuilder.Append(FriendlyTypeName(item.ParameterType));
				if (item.ParameterType.GetTypeInfo().IsGenericType)
				{
					Type[] genericArguments = item.ParameterType.GetGenericTypeDefinition().GetGenericArguments();
					stringBuilder.Append("<");
					stringBuilder.Append(string.Join(",", genericArguments.Select((Type x) => FriendlyTypeName(x))));
					stringBuilder.Append(">");
				}
			}
			stringBuilder.Append(")");
			return stringBuilder.ToString();
		}

		private static string FriendlyTypeName(Type type)
		{
			int num = type.Name.IndexOf("`");
			switch (type.FullName)
			{
			case "System.Object":
				return "object";
			case "System.String":
				return "string";
			case "System.Boolean":
				return "bool";
			case "System.Byte":
				return "byte";
			case "System.Char":
				return "char";
			case "System.Decimal":
				return "decimal";
			case "System.Double":
				return "double";
			case "System.Int16":
				return "short";
			case "System.Int32":
				return "int";
			case "System.Int64":
				return "long";
			case "System.SByte":
				return "sbyte";
			case "System.Single":
				return "float";
			case "System.UInt16":
				return "ushort";
			case "System.UInt32":
				return "uint";
			case "System.UInt64":
				return "ulong";
			default:
				if (num <= 0)
				{
					return type.Name;
				}
				return type.Name.Substring(0, num);
			}
		}

		public static CreateObject CreateClass(Type type)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(BsonDocument), "_doc");
			return Expression.Lambda<CreateObject>(Expression.New(type), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		public static CreateObject CreateStruct(Type type)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(BsonDocument), "_doc");
			return Expression.Lambda<CreateObject>(Expression.Convert(Expression.New(type), typeof(object)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		public static GenericGetter CreateGenericGetter(Type type, MemberInfo memberInfo)
		{
			if (memberInfo == null)
			{
				throw new ArgumentNullException("memberInfo");
			}
			if (memberInfo is PropertyInfo && !(memberInfo as PropertyInfo).CanRead)
			{
				return null;
			}
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "o");
			return Expression.Lambda<GenericGetter>(Expression.Convert(Expression.MakeMemberAccess(Expression.Convert(parameterExpression, memberInfo.DeclaringType), memberInfo), typeof(object)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		public static GenericSetter CreateGenericSetter(Type type, MemberInfo memberInfo)
		{
			if (memberInfo == null)
			{
				throw new ArgumentNullException("memberInfo");
			}
			FieldInfo fieldInfo = memberInfo as FieldInfo;
			PropertyInfo propertyInfo = memberInfo as PropertyInfo;
			if (memberInfo is PropertyInfo && !propertyInfo.CanWrite)
			{
				return null;
			}
			if (type.GetTypeInfo().IsValueType)
			{
				if (!(memberInfo is FieldInfo))
				{
					return delegate(object t, object v)
					{
						propertyInfo.SetValue(t, v, null);
					};
				}
				return fieldInfo.SetValue;
			}
			Type type2 = ((memberInfo is PropertyInfo) ? propertyInfo.PropertyType : fieldInfo.FieldType);
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "obj");
			ParameterExpression parameterExpression2 = Expression.Parameter(typeof(object), "val");
			UnaryExpression expression = Expression.Convert(parameterExpression, type);
			UnaryExpression right = Expression.ConvertChecked(parameterExpression2, type2);
			return Expression.Lambda<GenericSetter>(Expression.Convert(Expression.Assign((memberInfo is PropertyInfo) ? Expression.Property(expression, propertyInfo) : Expression.Field(expression, fieldInfo), right), typeof(object)), new ParameterExpression[2] { parameterExpression, parameterExpression2 }).Compile();
		}
	}
	internal class DefaultTypeNameBinder : ITypeNameBinder
	{
		private static readonly HashSet<string> _disallowedTypeNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
		{
			"System.Workflow.ComponentModel.AppSettings", "System.Core", "WinRT.BaseActivationFactory", "System.Data", "System.Windows.Data.ObjectDataProvider", "System.CodeDom.Compiler.CompilerResults", "System.Collections.ArrayList", "System.Diagnostics.Process", "System.Diagnostics.ProcessStartInfo", "System.Management.Automation",
			"System.Windows.Markup.XamlReader", "System.Web.Security.RolePrincipal", "System.Security.Principal.WindowsIdentity", "System.Security.Principal.WindowsPrincipal", "Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties", "System.Drawing.Design.ToolboxItemContainer", "Microsoft.IdentityModel.Claims.WindowsClaimsIdentity", "System.Resources.ResXResourceReader", "System.Resources.ResXResourceWriter", "System.Windows.Forms",
			"Microsoft.ApplicationId.Framework.InfiniteProgressPage", "Microsoft.VisualBasic.Logging.FileLogTraceListener", "Grpc.Core.Internal.UnmanagedLibrary", "MongoDB.Libmongocrypt.LibraryLoader+WindowsLibrary", "Xunit.Xunit1Executor", "Apache.NMS.ActiveMQ.Commands.ActiveMQObjectMessage", "Apache.NMS.ActiveMQ.Transport.Failover.FailoverTransport", "Apache.NMS.ActiveMQ.Util.IdGenerator", "Xunit.Sdk.TestFrameworkDiscoverer+PreserveWorkingFolder", "Xunit.Xunit1AssemblyInfo",
			"Amazon.Runtime.Internal.Util.OptimisticLockedTextFile", "Microsoft.Azure.Cosmos.Query.Core.QueryPlan.QueryPartitionProvider", "NLog.Internal.FileAppenders.SingleProcessFileAppender", "NLog.Targets.FileTarget", "Google.Apis.Util.Store.FileDataStore"
		};

		public static DefaultTypeNameBinder Instance { get; } = new DefaultTypeNameBinder();


		private DefaultTypeNameBinder()
		{
		}

		public string GetName(Type type)
		{
			return type.FullName + ", " + type.GetTypeInfo().Assembly.GetName().Name;
		}

		public Type GetType(string name)
		{
			Type type = Type.GetType(name);
			if (type == null)
			{
				return null;
			}
			if (_disallowedTypeNames.Contains(type.FullName))
			{
				throw LiteException.IllegalDeserializationType(type.FullName);
			}
			return type;
		}
	}
	internal interface ITypeNameBinder
	{
		string GetName(Type type);

		Type GetType(string name);
	}
	internal class SharedDataReader : IBsonDataReader, IDisposable
	{
		private readonly IBsonDataReader _reader;

		private readonly Action _dispose;

		private bool _disposed;

		public BsonValue this[string field] => _reader[field];

		public string Collection => _reader.Collection;

		public BsonValue Current => _reader.Current;

		public bool HasValues => _reader.HasValues;

		public SharedDataReader(IBsonDataReader reader, Action dispose)
		{
			_reader = reader;
			_dispose = dispose;
		}

		public bool Read()
		{
			return _reader.Read();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		~SharedDataReader()
		{
			Dispose(disposing: false);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				_disposed = true;
				if (disposing)
				{
					_reader.Dispose();
					_dispose();
				}
			}
		}
	}
	internal class SharedEngine : ILiteEngine, IDisposable
	{
		private readonly EngineSettings _settings;

		private readonly Mutex _mutex;

		private LiteEngine _engine;

		private bool _transactionRunning;

		public SharedEngine(EngineSettings settings)
		{
			_settings = settings;
			string name = SharedMutexNameFactory.Create(settings.Filename, settings.SharedMutexNameStrategy);
			try
			{
				_mutex = SharedMutexFactory.Create(name);
			}
			catch (NotSupportedException ex)
			{
				if (ex is PlatformNotSupportedException)
				{
					throw;
				}
				throw new PlatformNotSupportedException("Shared mode is not supported in platforms that do not implement named mutex.", ex);
			}
		}

		private bool OpenDatabase()
		{
			try
			{
				_mutex.WaitOne();
			}
			catch (AbandonedMutexException)
			{
			}
			if (!_transactionRunning && _engine == null)
			{
				try
				{
					_engine = new LiteEngine(_settings);
					return true;
				}
				catch
				{
					_mutex.ReleaseMutex();
					throw;
				}
			}
			return false;
		}

		private void CloseDatabase()
		{
			if (!_transactionRunning && _engine != null)
			{
				_engine.Dispose();
				_engine = null;
			}
			_mutex.ReleaseMutex();
		}

		public bool BeginTrans()
		{
			OpenDatabase();
			try
			{
				_transactionRunning = _engine.BeginTrans();
				return _transactionRunning;
			}
			catch
			{
				CloseDatabase();
				throw;
			}
		}

		public bool Commit()
		{
			if (_engine == null)
			{
				return false;
			}
			try
			{
				return _engine.Commit();
			}
			finally
			{
				_transactionRunning = false;
				CloseDatabase();
			}
		}

		public bool Rollback()
		{
			if (_engine == null)
			{
				return false;
			}
			try
			{
				return _engine.Rollback();
			}
			finally
			{
				_transactionRunning = false;
				CloseDatabase();
			}
		}

		public IBsonDataReader Query(string collection, Query query)
		{
			bool opened = OpenDatabase();
			return new SharedDataReader(_engine.Query(collection, query), delegate
			{
				if (opened)
				{
					CloseDatabase();
				}
			});
		}

		public BsonValue Pragma(string name)
		{
			return QueryDatabase(() => _engine.Pragma(name));
		}

		public bool Pragma(string name, BsonValue value)
		{
			return QueryDatabase(() => _engine.Pragma(name, value));
		}

		public int Checkpoint()
		{
			return QueryDatabase(() => _engine.Checkpoint());
		}

		public long Rebuild(RebuildOptions options)
		{
			return QueryDatabase(() => _engine.Rebuild(options));
		}

		public int Insert(string collection, IEnumerable<BsonDocument> docs, BsonAutoId autoId)
		{
			return QueryDatabase(() => _engine.Insert(collection, docs, autoId));
		}

		public int Update(string collection, IEnumerable<BsonDocument> docs)
		{
			return QueryDatabase(() => _engine.Update(collection, docs));
		}

		public int UpdateMany(string collection, BsonExpression extend, BsonExpression predicate)
		{
			return QueryDatabase(() => _engine.UpdateMany(collection, extend, predicate));
		}

		public int Upsert(string collection, IEnumerable<BsonDocument> docs, BsonAutoId autoId)
		{
			return QueryDatabase(() => _engine.Upsert(collection, docs, autoId));
		}

		public int Delete(string collection, IEnumerable<BsonValue> ids)
		{
			return QueryDatabase(() => _engine.Delete(collection, ids));
		}

		public int DeleteMany(string collection, BsonExpression predicate)
		{
			return QueryDatabase(() => _engine.DeleteMany(collection, predicate));
		}

		public bool DropCollection(string name)
		{
			return QueryDatabase(() => _engine.DropCollection(name));
		}

		public bool RenameCollection(string name, string newName)
		{
			return QueryDatabase(() => _engine.RenameCollection(name, newName));
		}

		public bool DropIndex(string collection, string name)
		{
			return QueryDatabase(() => _engine.DropIndex(collection, name));
		}

		public bool EnsureIndex(string collection, string name, BsonExpression expression, bool unique)
		{
			return QueryDatabase(() => _engine.EnsureIndex(collection, name, expression, unique));
		}

		public bool EnsureVectorIndex(string collection, string name, BsonExpression expression, VectorIndexOptions options)
		{
			return QueryDatabase(() => _engine.EnsureVectorIndex(collection, name, expression, options));
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		~SharedEngine()
		{
			Dispose(disposing: false);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing && _engine != null)
			{
				_engine.Dispose();
				_engine = null;
				_mutex.ReleaseMutex();
			}
		}

		private T QueryDatabase<T>(Func<T> Query)
		{
			bool flag = OpenDatabase();
			try
			{
				return Query();
			}
			finally
			{
				if (flag)
				{
					CloseDatabase();
				}
			}
		}
	}
	internal static class SharedMutexFactory
	{
		private static class WindowsMutex
		{
			private const string WorldAccessSecurityDescriptor = "D:(A;;GA;;;WD)";

			private const uint SddlRevision1 = 1u;

			public static Mutex Create(string name)
			{
				IntPtr SecurityDescriptor = IntPtr.Zero;
				try
				{
					if (!NativeMethods.ConvertStringSecurityDescriptorToSecurityDescriptor("D:(A;;GA;;;WD)", 1u, out SecurityDescriptor, out var _))
					{
						throw new Win32Exception(Marshal.GetLastWin32Error(), "Failed to create security descriptor for shared mutex.");
					}
					NativeMethods.SECURITY_ATTRIBUTES sECURITY_ATTRIBUTES = default(NativeMethods.SECURITY_ATTRIBUTES);
					sECURITY_ATTRIBUTES.nLength = (uint)Marshal.SizeOf<NativeMethods.SECURITY_ATTRIBUTES>();
					sECURITY_ATTRIBUTES.bInheritHandle = 0;
					sECURITY_ATTRIBUTES.lpSecurityDescriptor = SecurityDescriptor;
					NativeMethods.SECURITY_ATTRIBUTES lpMutexAttributes = sECURITY_ATTRIBUTES;
					IntPtr intPtr = NativeMethods.CreateMutexEx(ref lpMutexAttributes, name, 0u, 2031617u);
					if (intPtr == IntPtr.Zero || intPtr == NativeMethods.InvalidHandleValue)
					{
						throw new Win32Exception(Marshal.GetLastWin32Error(), "Failed to create shared mutex with global access.");
					}
					return new Mutex
					{
						SafeWaitHandle = new SafeWaitHandle(intPtr, ownsHandle: true)
					};
				}
				finally
				{
					if (SecurityDescriptor != IntPtr.Zero)
					{
						NativeMethods.LocalFree(SecurityDescriptor);
					}
				}
			}
		}

		private static class NativeMethods
		{
			public struct SECURITY_ATTRIBUTES
			{
				public uint nLength;

				public IntPtr lpSecurityDescriptor;

				public int bInheritHandle;
			}

			public static readonly IntPtr InvalidHandleValue = new IntPtr(-1);

			public const uint MUTEX_ALL_ACCESS = 2031617u;

			[DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
			[return: MarshalAs(UnmanagedType.Bool)]
			public static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(string StringSecurityDescriptor, uint StringSDRevision, out IntPtr SecurityDescriptor, out uint SecurityDescriptorSize);

			[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
			public static extern IntPtr CreateMutexEx(ref SECURITY_ATTRIBUTES lpMutexAttributes, string lpName, uint dwFlags, uint dwDesiredAccess);

			[DllImport("kernel32.dll", SetLastError = true)]
			public static extern IntPtr LocalFree(IntPtr hMem);
		}

		private const string MutexPrefix = "Global\\";

		private const string MutexSuffix = ".Mutex";

		public static Mutex Create(string name)
		{
			string name2 = "Global\\" + name + ".Mutex";
			if (!IsWindows())
			{
				return new Mutex(initiallyOwned: false, name2);
			}
			try
			{
				return WindowsMutex.Create(name2);
			}
			catch (Win32Exception inner)
			{
				throw new PlatformNotSupportedException("Shared mode is not supported because named mutex access control is unavailable on this platform.", inner);
			}
			catch (EntryPointNotFoundException inner2)
			{
				throw new PlatformNotSupportedException("Shared mode is not supported because named mutex access control is unavailable on this platform.", inner2);
			}
			catch (DllNotFoundException inner3)
			{
				throw new PlatformNotSupportedException("Shared mode is not supported because named mutex access control is unavailable on this platform.", inner3);
			}
		}

		private static bool IsWindows()
		{
			return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
		}
	}
	internal class SqlParser
	{
		[CompilerGenerated]
		private sealed class <ParseListOfDocuments>d__9 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public SqlParser <>4__this;

			private JsonReader <reader>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SqlParser sqlParser = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					Token token = sqlParser._tokenizer.LookAhead();
					if (token.Type != TokenType.Comma)
					{
						token.Expect(TokenType.EOF, TokenType.SemiColon);
						sqlParser._tokenizer.ReadToken();
						return false;
					}
					sqlParser._tokenizer.ReadToken();
				}
				else
				{
					<>1__state = -1;
					<reader>5__2 = new JsonReader(sqlParser._tokenizer);
				}
				BsonValue bsonValue = <reader>5__2.Deserialize();
				if (bsonValue.IsDocument)
				{
					<>2__current = bsonValue as BsonDocument;
					<>1__state = 1;
					return true;
				}
				throw LiteException.UnexpectedToken("Value must be a valid document", sqlParser._tokenizer.Current);
			}

			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]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<ParseListOfDocuments>d__9 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <ParseListOfDocuments>d__9(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <ParseListOfExpressions>d__8 : IEnumerable<BsonExpression>, IEnumerable, IEnumerator<BsonExpression>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonExpression <>2__current;

			private int <>l__initialThreadId;

			public SqlParser <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SqlParser sqlParser = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (sqlParser._tokenizer.LookAhead().Type != TokenType.Comma)
					{
						return false;
					}
					sqlParser._tokenizer.ReadToken();
				}
				else
				{
					<>1__state = -1;
				}
				BsonExpression bsonExpression = BsonExpression.Create(sqlParser._tokenizer, BsonExpressionParserMode.Full, sqlParser._parameters);
				<>2__current = bsonExpression;
				<>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();
			}

			[DebuggerHidden]
			IEnumerator<BsonExpression> IEnumerable<BsonExpression>.GetEnumerator()
			{
				<ParseListOfExpressions>d__8 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <ParseListOfExpressions>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private readonly ILiteEngine _engine;

		private readonly Tokenizer _tokenizer;

		private readonly BsonDocument _parameters;

		private readonly Lazy<Collation> _collation;

		private BsonDataReader ParseBegin()
		{
			_tokenizer.ReadToken().Expect("BEGIN");
			Token token = _tokenizer.ReadToken().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);
			if (token.Is("TRANS") || token.Is("TRANSACTION"))
			{
				_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			}
			return new BsonDataReader(_engine.BeginTrans());
		}

		private BsonDataReader ParseCheckpoint()
		{
			_tokenizer.ReadToken().Expect("CHECKPOINT");
			_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			return new BsonDataReader(_engine.Checkpoint());
		}

		private BsonDataReader ParseCommit()
		{
			_tokenizer.ReadToken().Expect("COMMIT");
			Token token = _tokenizer.ReadToken().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);
			if (token.Is("TRANS") || token.Is("TRANSACTION"))
			{
				_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			}
			return new BsonDataReader(_engine.Commit());
		}

		private BsonDataReader ParseCreate()
		{
			_tokenizer.ReadToken().Expect("CREATE");
			Token token = _tokenizer.ReadToken().Expect(TokenType.Word);
			bool flag = token.Is("UNIQUE");
			if (flag)
			{
				token = _tokenizer.ReadToken();
			}
			token.Expect("INDEX");
			string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			_tokenizer.ReadToken().Expect("ON");
			string value2 = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			_tokenizer.ReadToken().Expect(TokenType.OpenParenthesis);
			BsonExpression expression = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, new BsonDocument());
			_tokenizer.ReadToken().Expect(TokenType.CloseParenthesis);
			_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			return new BsonDataReader(_engine.EnsureIndex(value2, value, expression, flag));
		}

		private BsonDataReader ParseDelete()
		{
			_tokenizer.ReadToken().Expect("DELETE");
			string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			BsonExpression predicate = null;
			if (_tokenizer.LookAhead().Is("WHERE"))
			{
				_tokenizer.ReadToken();
				predicate = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);
			}
			_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			_tokenizer.ReadToken();
			return new BsonDataReader(_engine.DeleteMany(value, predicate));
		}

		private BsonDataReader ParseDrop()
		{
			_tokenizer.ReadToken().Expect("DROP");
			Token token = _tokenizer.ReadToken().Expect(TokenType.Word);
			if (token.Is("INDEX"))
			{
				string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
				_tokenizer.ReadToken().Expect(TokenType.Period);
				string value2 = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
				_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
				return new BsonDataReader(_engine.DropIndex(value, value2));
			}
			if (token.Is("COLLECTION"))
			{
				string value3 = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
				_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
				return new BsonDataReader(_engine.DropCollection(value3));
			}
			throw LiteException.UnexpectedToken(token, "INDEX|COLLECTION");
		}

		private BsonDataReader ParseInsert()
		{
			_tokenizer.ReadToken().Expect("INSERT");
			_tokenizer.ReadToken().Expect("INTO");
			string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			BsonAutoId autoId = ParseWithAutoId();
			_tokenizer.ReadToken().Expect("VALUES");
			IEnumerable<BsonDocument> docs = ParseListOfDocuments();
			return new BsonDataReader(_engine.Insert(value, docs, autoId));
		}

		private BsonAutoId ParseWithAutoId()
		{
			if (_tokenizer.LookAhead().Type == TokenType.Colon)
			{
				_tokenizer.ReadToken();
				Token token = _tokenizer.ReadToken().Expect(TokenType.Word);
				return token.Value.ToUpper() switch
				{
					"GUID" => BsonAutoId.Guid, 
					"INT" => BsonAutoId.Int32, 
					"LONG" => BsonAutoId.Int64, 
					"OBJECTID" => BsonAutoId.ObjectId, 
					_ => throw LiteException.UnexpectedToken(token, "DATE, GUID, INT, LONG, OBJECTID"), 
				};
			}
			return BsonAutoId.ObjectId;
		}

		[IteratorStateMachine(typeof(<ParseListOfExpressions>d__8))]
		private IEnumerable<BsonExpression> ParseListOfExpressions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ParseListOfExpressions>d__8(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<ParseListOfDocuments>d__9))]
		private IEnumerable<BsonDocument> ParseListOfDocuments()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ParseListOfDocuments>d__9(-2)
			{
				<>4__this = this
			};
		}

		private IBsonDataReader ParsePragma()
		{
			_tokenizer.ReadToken().Expect("PRAGMA");
			string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			Token token = _tokenizer.LookAhead();
			if (token.Type == TokenType.EOF || token.Type == TokenType.SemiColon)
			{
				_tokenizer.ReadToken();
				return new BsonDataReader(_engine.Pragma(value));
			}
			if (token.Type == TokenType.Equals)
			{
				_tokenizer.ReadToken().Expect(TokenType.Equals);
				BsonValue value2 = new JsonReader(_tokenizer).Deserialize();
				_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
				return new BsonDataReader(_engine.Pragma(value, value2));
			}
			throw LiteException.UnexpectedToken(token);
		}

		private BsonDataReader ParseRebuild()
		{
			_tokenizer.ReadToken().Expect("REBUILD");
			RebuildOptions rebuildOptions = new RebuildOptions();
			Token token = _tokenizer.LookAhead();
			if (token.Type == TokenType.EOF || token.Type == TokenType.SemiColon)
			{
				rebuildOptions = null;
				_tokenizer.ReadToken();
			}
			else
			{
				BsonValue bsonValue = new JsonReader(_tokenizer).Deserialize();
				if (!bsonValue.IsDocument)
				{
					throw LiteException.UnexpectedToken(token);
				}
				if (bsonValue["password"].IsString)
				{
					rebuildOptions.Password = bsonValue["password"];
				}
				if (bsonValue["collation"].IsString)
				{
					rebuildOptions.Collation = new Collation(bsonValue["collation"].AsString);
				}
			}
			return new BsonDataReader((int)_engine.Rebuild(rebuildOptions));
		}

		private BsonDataReader ParseRename()
		{
			_tokenizer.ReadToken().Expect("RENAME");
			_tokenizer.ReadToken().Expect("COLLECTION");
			string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			_tokenizer.ReadToken().Expect("TO");
			string value2 = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			return new BsonDataReader(_engine.RenameCollection(value, value2));
		}

		private BsonDataReader ParseRollback()
		{
			_tokenizer.ReadToken().Expect("ROLLBACK");
			Token token = _tokenizer.ReadToken().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);
			if (token.Is("TRANS") || token.Is("TRANSACTION"))
			{
				_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			}
			return new BsonDataReader(_engine.Rollback());
		}

		private IBsonDataReader ParseSelect()
		{
			Query query = new Query();
			Token token = _tokenizer.ReadToken();
			query.ExplainPlan = token.Is("EXPLAIN");
			if (query.ExplainPlan)
			{
				token = _tokenizer.ReadToken();
			}
			token.Expect("SELECT");
			query.Select = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.SelectDocument, _parameters);
			Token token2 = _tokenizer.ReadToken();
			if (token2.Type == TokenType.EOF || token2.Type == TokenType.SemiColon)
			{
				IEnumerable<BsonValue> source = query.Select.Execute(_collation.Value);
				string defaultName = "expr";
				return new BsonDataReader(source.Select((BsonValue x) => (!x.IsDocument) ? new BsonDocument { [defaultName] = x } : x.AsDocument).FirstOrDefault());
			}
			if (token2.Is("INTO"))
			{
				query.Into = ParseCollection(_tokenizer);
				query.IntoAutoId = ParseWithAutoId();
				_tokenizer.ReadToken().Expect("FROM");
			}
			else
			{
				token2.Expect("FROM");
			}
			string collection = ParseCollection(_tokenizer);
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("INCLUDE"))
			{
				_tokenizer.ReadToken();
				foreach (BsonExpression item2 in ParseListOfExpressions())
				{
					query.Includes.Add(item2);
				}
			}
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("WHERE"))
			{
				_tokenizer.ReadToken();
				BsonExpression item = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);
				query.Where.Add(item);
			}
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("GROUP"))
			{
				_tokenizer.ReadToken();
				_tokenizer.ReadToken().Expect("BY");
				BsonExpression groupBy = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);
				query.GroupBy = groupBy;
				if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("HAVING"))
				{
					_tokenizer.ReadToken();
					BsonExpression having = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);
					query.Having = having;
				}
			}
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("ORDER"))
			{
				_tokenizer.ReadToken();
				_tokenizer.ReadToken().Expect("BY");
				while (true)
				{
					BsonExpression expression = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);
					int order = 1;
					Token token3 = _tokenizer.LookAhead();
					if (token3.Is("ASC") || token3.Is("DESC"))
					{
						order = (_tokenizer.ReadToken().Is("ASC") ? 1 : (-1));
					}
					query.OrderBy.Add(new QueryOrder(expression, order));
					if (_tokenizer.LookAhead().Type != TokenType.Comma)
					{
						break;
					}
					_tokenizer.ReadToken();
				}
			}
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("LIMIT"))
			{
				_tokenizer.ReadToken();
				string value = _tokenizer.ReadToken().Expect(TokenType.Int).Value;
				query.Limit = Convert.ToInt32(value);
			}
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("OFFSET"))
			{
				_tokenizer.ReadToken();
				string value2 = _tokenizer.ReadToken().Expect(TokenType.Int).Value;
				query.Offset = Convert.ToInt32(value2);
			}
			if (_tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon).Is("FOR"))
			{
				_tokenizer.ReadToken();
				_tokenizer.ReadToken().Expect("UPDATE");
				query.ForUpdate = true;
			}
			_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			return _engine.Query(collection, query);
		}

		public static string ParseCollection(Tokenizer tokenizer)
		{
			string name;
			BsonValue options;
			return ParseCollection(tokenizer, out name, out options);
		}

		public static string ParseCollection(Tokenizer tokenizer, out string name, out BsonValue options)
		{
			name = tokenizer.ReadToken().Expect(TokenType.Word).Value;
			if (name.StartsWith("$"))
			{
				if (tokenizer.LookAhead().Type == TokenType.OpenParenthesis)
				{
					tokenizer.ReadToken();
					if (tokenizer.LookAhead().Type == TokenType.CloseParenthesis)
					{
						options = null;
					}
					else
					{
						options = new JsonReader(tokenizer).Deserialize();
					}
					tokenizer.ReadToken().Expect(TokenType.CloseParenthesis);
				}
				else
				{
					options = null;
				}
			}
			else
			{
				options = null;
			}
			return name + ((options == null) ? "" : ("(" + JsonSerializer.Serialize(options) + ")"));
		}

		private BsonDataReader ParseUpdate()
		{
			_tokenizer.ReadToken().Expect("UPDATE");
			string value = _tokenizer.ReadToken().Expect(TokenType.Word).Value;
			_tokenizer.ReadToken().Expect("SET");
			BsonExpression transform = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.UpdateDocument, _parameters);
			BsonExpression predicate = null;
			if (_tokenizer.LookAhead().Is("WHERE"))
			{
				_tokenizer.ReadToken();
				predicate = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);
			}
			_tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);
			return new BsonDataReader(_engine.UpdateMany(value, transform, predicate));
		}

		public SqlParser(ILiteEngine engine, Tokenizer tokenizer, BsonDocument parameters)
		{
			_engine = engine;
			_tokenizer = tokenizer;
			_parameters = parameters ?? new BsonDocument();
			_collation = new Lazy<Collation>(() => new Collation(_engine.Pragma("COLLATION")));
		}

		public IBsonDataReader Execute()
		{
			Token token = _tokenizer.LookAhead().Expect(TokenType.Word);
			switch (token.Value.ToUpper())
			{
			case "SELECT":
			case "EXPLAIN":
				return ParseSelect();
			case "INSERT":
				return ParseInsert();
			case "DELETE":
				return ParseDelete();
			case "UPDATE":
				return ParseUpdate();
			case "DROP":
				return ParseDrop();
			case "RENAME":
				return ParseRename();
			case "CREATE":
				return ParseCreate();
			case "CHECKPOINT":
				return ParseCheckpoint();
			case "REBUILD":
				return ParseRebuild();
			case "BEGIN":
				return ParseBegin();
			case "ROLLBACK":
				return ParseRollback();
			case "COMMIT":
				return ParseCommit();
			case "PRAGMA":
				return ParsePragma();
			default:
				throw LiteException.UnexpectedToken(token);
			}
		}
	}
	internal interface ILiteStorage<TFileId>
	{
		LiteFileInfo<TFileId> FindById(TFileId id);

		IEnumerable<LiteFileInfo<TFileId>> Find(BsonExpression predicate);

		IEnumerable<LiteFileInfo<TFileId>> Find(string predicate, BsonDocument parameters);

		IEnumerable<LiteFileInfo<TFileId>> Find(string predicate, params BsonValue[] args);

		IEnumerable<LiteFileInfo<TFileId>> Find(Expression<Func<LiteFileInfo<TFileId>, bool>> predicate);

		IEnumerable<LiteFileInfo<TFileId>> FindAll();

		bool Exists(TFileId id);

		LiteFileStream<TFileId> OpenWrite(TFileId id, string filename, BsonDocument metadata = null);

		LiteFileInfo<TFileId> Upload(TFileId id, string filename, Stream stream, BsonDocument metadata = null);

		LiteFileInfo<TFileId> Upload(TFileId id, string filename);

		bool SetMetadata(TFileId id, BsonDocument metadata);

		LiteFileStream<TFileId> OpenRead(TFileId id);

		LiteFileInfo<TFileId> Download(TFileId id, Stream stream);

		LiteFileInfo<TFileId> Download(TFileId id, string filename, bool overwritten);

		bool Delete(TFileId id);
	}
	internal class LiteFileInfo<TFileId>
	{
		private BsonValue _fileId;

		private ILiteCollection<LiteFileInfo<TFileId>> _files;

		private ILiteCollection<BsonDocument> _chunks;

		public TFileId Id { get; internal set; }

		[BsonField("filename")]
		public string Filename { get; internal set; }

		[BsonField("mimeType")]
		public string MimeType { get; internal set; }

		[BsonField("length")]
		public long Length { get; internal set; }

		[BsonField("chunks")]
		public int Chunks { get; internal set; }

		[BsonField("uploadDate")]
		public DateTime UploadDate { get; internal set; } = DateTime.Now;


		[BsonField("metadata")]
		public BsonDocument Metadata { get; set; } = new BsonDocument();


		internal void SetReference(BsonValue fileId, ILiteCollection<LiteFileInfo<TFileId>> files, ILiteCollection<BsonDocument> chunks)
		{
			_fileId = fileId;
			_files = files;
			_chunks = chunks;
		}

		public LiteFileStream<TFileId> OpenRead()
		{
			return new LiteFileStream<TFileId>(_files, _chunks, this, _fileId, FileAccess.Read);
		}

		public LiteFileStream<TFileId> OpenWrite()
		{
			return new LiteFileStream<TFileId>(_files, _chunks, this, _fileId, FileAccess.Write);
		}

		public void CopyTo(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			using LiteFileStream<TFileId> liteFileStream = OpenRead();
			liteFileStream.CopyTo(stream);
		}

		public void SaveAs(string filename, bool overwritten = true)
		{
			if (filename.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("filename");
			}
			using FileStream destination = File.Open(filename, (!overwritten) ? FileMode.CreateNew : FileMode.Create);
			using LiteFileStream<TFileId> liteFileStream = OpenRead();
			liteFileStream.CopyTo(destination);
		}
	}
	internal class LiteFileStream<TFileId> : Stream
	{
		public const int MAX_CHUNK_SIZE = 261120;

		private readonly ILiteCollection<LiteFileInfo<TFileId>> _files;

		private readonly ILiteCollection<BsonDocument> _chunks;

		private readonly LiteFileInfo<TFileId> _file;

		private readonly BsonValue _fileId;

		private readonly FileAccess _mode;

		private long _streamPosition;

		private int _currentChunkIndex;

		private byte[] _currentChunkData;

		private int _positionInChunk;

		private MemoryStream _buffer;

		private bool _disposed;

		private Dictionary<int, long> _chunkLengths = new Dictionary<int, long>();

		public LiteFileInfo<TFileId> FileInfo => _file;

		public override long Length => _file.Length;

		public override bool CanRead => _mode == FileAccess.Read;

		public override bool CanWrite => _mode == FileAccess.Write;

		public override bool CanSeek => _mode == FileAccess.Read;

		public override long Position
		{
			get
			{
				return _streamPosition;
			}
			set
			{
				if (_mode == FileAccess.Read)
				{
					SetReadStreamPosition(value);
					return;
				}
				throw new NotSupportedException();
			}
		}

		internal LiteFileStream(ILiteCollection<LiteFileInfo<TFileId>> files, ILiteCollection<BsonDocument> chunks, LiteFileInfo<TFileId> file, BsonValue fileId, FileAccess mode)
		{
			_files = files;
			_chunks = chunks;
			_file = file;
			_fileId = fileId;
			_mode = mode;
			switch (mode)
			{
			case FileAccess.Read:
				_currentChunkData = GetChunkData(_currentChunkIndex);
				break;
			case FileAccess.Write:
				_buffer = new MemoryStream(261120);
				if (_file.Length > 0)
				{
					Constants.ENSURE(_chunks.DeleteMany("_id BETWEEN { f: @0, n: 0 } AND { f: @0, n: 99999999 }", _fileId) == _file.Chunks);
					_file.Length = 0L;
					_file.Chunks = 0;
				}
				break;
			}
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			if (_mode == FileAccess.Write)
			{
				throw new NotSupportedException();
			}
			switch (origin)
			{
			case SeekOrigin.Begin:
				SetReadStreamPosition(offset);
				break;
			case SeekOrigin.Current:
				SetReadStreamPosition(_streamPosition + offset);
				break;
			case SeekOrigin.End:
				SetReadStreamPosition(Length + offset);
				break;
			}
			return _streamPosition;
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			if (!_disposed)
			{
				if (disposing && CanWrite)
				{
					Flush();
					_buffer?.Dispose();
				}
				_disposed = true;
			}
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			if (_mode != FileAccess.Read)
			{
				throw new NotSupportedException();
			}
			if (_streamPosition == Length)
			{
				return 0;
			}
			int num = count;
			while (_currentChunkData != null && num > 0)
			{
				int num2 = Math.Min(num, _currentChunkData.Length - _positionInChunk);
				Buffer.BlockCopy(_currentChunkData, _positionInChunk, buffer, offset, num2);
				_positionInChunk += num2;
				num -= num2;
				offset += num2;
				_streamPosition += num2;
				if (_positionInChunk >= _currentChunkData.Length)
				{
					_positionInChunk = 0;
					_currentChunkData = GetChunkData(++_currentChunkIndex);
				}
			}
			return count - num;
		}

		private byte[] GetChunkData(int index)
		{
			byte[] array = _chunks.FindOne("_id = { f: @0, n: @1 }", _fileId, index)?["data"].AsBinary;
			if (array != null)
			{
				_chunkLengths[index] = array.Length;
			}
			return array;
		}

		private void SetReadStreamPosition(long newPosition)
		{
			if (newPosition < 0)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (newPosition >= Length)
			{
				_streamPosition = Length;
				return;
			}
			_streamPosition = newPosition;
			long num = 0L;
			int num2 = _currentChunkIndex;
			int num3 = 0;
			while (num <= _streamPosition)
			{
				if (_chunkLengths.TryGetValue(num3, out var value))
				{
					num += value;
				}
				else
				{
					num2 = num3;
					_currentChunkData = GetChunkData(num3);
					num += _currentChunkData.Length;
				}
				num3++;
			}
			num3--;
			num -= _chunkLengths[num3];
			_positionInChunk = (int)(_streamPosition - num);
			_currentChunkIndex = num3;
			if (num2 != _currentChunkIndex)
			{
				_currentChunkData = GetChunkData(_currentChunkIndex);
			}
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			_streamPosition += count;
			_buffer.Write(buffer, offset, count);
			if (_buffer.Length >= 261120)
			{
				WriteChunks(flush: false);
			}
		}

		public override void Flush()
		{
			WriteChunks(flush: true);
		}

		private void WriteChunks(bool flush)
		{
			byte[] array = new byte[261120];
			int num = 0;
			_buffer.Seek(0L, SeekOrigin.Begin);
			while ((num = _buffer.Read(array, 0, 261120)) > 0)
			{
				BsonDocument bsonDocument = new BsonDocument { ["_id"] = new BsonDocument
				{
					["f"] = _fileId,
					["n"] = _file.Chunks++
				} };
				if (num != 261120)
				{
					byte[] array2 = new byte[num];
					Buffer.BlockCopy(array, 0, array2, 0, num);
					bsonDocument["data"] = array2;
				}
				else
				{
					bsonDocument["data"] = array;
				}
				_chunks.Insert(bsonDocument);
			}
			if (flush)
			{
				_file.UploadDate = DateTime.Now;
				_file.Length = _streamPosition;
				_files.Upsert(_file);
			}
			_buffer = new MemoryStream();
		}
	}
	internal class LiteStorage<TFileId> : ILiteStorage<TFileId>
	{
		[CompilerGenerated]
		private sealed class <Find>d__5 : IEnumerable<LiteFileInfo<TFileId>>, IEnumerable, IEnumerator<LiteFileInfo<TFileId>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private LiteFileInfo<TFileId> <>2__current;

			private int <>l__initialThreadId;

			public LiteStorage<TFileId> <>4__this;

			private BsonExpression predicate;

			public BsonExpression <>3__predicate;

			private IEnumerator<LiteFileInfo<TFileId>> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <Find>d__5(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteStorage<TFileId> liteStorage = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						ILiteQueryable<LiteFileInfo<TFileId>> liteQueryable = liteStorage._files.Query();
						if (predicate != null)
						{
							liteQueryable = liteQueryable.Where(predicate);
						}
						<>7__wrap1 = liteQueryable.ToEnumerable().GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						LiteFileInfo<TFileId> current = <>7__wrap1.Current;
						BsonValue fileId = liteStorage._db.Mapper.Serialize(typeof(TFileId), current.Id);
						current.SetReference(fileId, liteStorage._files, liteStorage._chunks);
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<LiteFileInfo<TFileId>> IEnumerable<LiteFileInfo<TFileId>>.GetEnumerator()
			{
				<Find>d__5 <Find>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Find>d__ = this;
				}
				else
				{
					<Find>d__ = new <Find>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<Find>d__.predicate = <>3__predicate;
				return <Find>d__;
			}

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

		private readonly ILiteDatabase _db;

		private readonly ILiteCollection<LiteFileInfo<TFileId>> _files;

		private readonly ILiteCollection<BsonDocument> _chunks;

		public LiteStorage(ILiteDatabase db, string filesCollection, string chunksCollection)
		{
			_db = db;
			_files = db.GetCollection<LiteFileInfo<TFileId>>(filesCollection);
			_chunks = db.GetCollection(chunksCollection);
		}

		public LiteFileInfo<TFileId> FindById(TFileId id)
		{
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			BsonValue bsonValue = _db.Mapper.Serialize(typeof(TFileId), id);
			LiteFileInfo<TFileId> liteFileInfo = _files.FindById(bsonValue);
			if (liteFileInfo == null)
			{
				return null;
			}
			liteFileInfo.SetReference(bsonValue, _files, _chunks);
			return liteFileInfo;
		}

		[IteratorStateMachine(typeof(LiteStorage<>.<Find>d__5))]
		public IEnumerable<LiteFileInfo<TFileId>> Find(BsonExpression predicate)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Find>d__5(-2)
			{
				<>4__this = this,
				<>3__predicate = predicate
			};
		}

		public IEnumerable<LiteFileInfo<TFileId>> Find(string predicate, BsonDocument parameters)
		{
			return Find(BsonExpression.Create(predicate, parameters));
		}

		public IEnumerable<LiteFileInfo<TFileId>> Find(string predicate, params BsonValue[] args)
		{
			return Find(BsonExpression.Create(predicate, args));
		}

		public IEnumerable<LiteFileInfo<TFileId>> Find(Expression<Func<LiteFileInfo<TFileId>, bool>> predicate)
		{
			return Find(_db.Mapper.GetExpression(predicate));
		}

		public IEnumerable<LiteFileInfo<TFileId>> FindAll()
		{
			return Find((BsonExpression)null);
		}

		public bool Exists(TFileId id)
		{
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			BsonValue bsonValue = _db.Mapper.Serialize(typeof(TFileId), id);
			return _files.Exists("_id = @0", bsonValue);
		}

		public LiteFileStream<TFileId> OpenWrite(TFileId id, string filename, BsonDocument metadata = null)
		{
			BsonValue fileId = _db.Mapper.Serialize(typeof(TFileId), id);
			LiteFileInfo<TFileId> liteFileInfo = FindById(id);
			if (liteFileInfo == null)
			{
				liteFileInfo = new LiteFileInfo<TFileId>
				{
					Id = id,
					Filename = Path.GetFileName(filename),
					MimeType = MimeTypeConverter.GetMimeType(filename),
					Metadata = (metadata ?? new BsonDocument())
				};
				liteFileInfo.SetReference(fileId, _files, _chunks);
			}
			else
			{
				liteFileInfo.Filename = Path.GetFileName(filename);
				liteFileInfo.MimeType = MimeTypeConverter.GetMimeType(filename);
				liteFileInfo.Metadata = metadata ?? liteFileInfo.Metadata;
			}
			return liteFileInfo.OpenWrite();
		}

		public LiteFileInfo<TFileId> Upload(TFileId id, string filename, Stream stream, BsonDocument metadata = null)
		{
			using LiteFileStream<TFileId> liteFileStream = OpenWrite(id, filename, metadata);
			stream.CopyTo(liteFileStream);
			return liteFileStream.FileInfo;
		}

		public LiteFileInfo<TFileId> Upload(TFileId id, string filename)
		{
			if (filename.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("filename");
			}
			using FileStream stream = File.OpenRead(filename);
			return Upload(id, Path.GetFileName(filename), stream);
		}

		public bool SetMetadata(TFileId id, BsonDocument metadata)
		{
			LiteFileInfo<TFileId> liteFileInfo = FindById(id);
			if (liteFileInfo == null)
			{
				return false;
			}
			liteFileInfo.Metadata = metadata ?? new BsonDocument();
			_files.Update(liteFileInfo);
			return true;
		}

		public LiteFileStream<TFileId> OpenRead(TFileId id)
		{
			return (FindById(id) ?? throw LiteException.FileNotFound(id.ToString())).OpenRead();
		}

		public LiteFileInfo<TFileId> Download(TFileId id, Stream stream)
		{
			LiteFileInfo<TFileId> obj = FindById(id) ?? throw LiteException.FileNotFound(id.ToString());
			obj.CopyTo(stream);
			return obj;
		}

		public LiteFileInfo<TFileId> Download(TFileId id, string filename, bool overwritten)
		{
			LiteFileInfo<TFileId> obj = FindById(id) ?? throw LiteException.FileNotFound(id.ToString());
			obj.SaveAs(filename, overwritten);
			return obj;
		}

		public bool Delete(TFileId id)
		{
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			BsonValue bsonValue = _db.Mapper.Serialize(typeof(TFileId), id);
			bool flag = _files.Delete(bsonValue);
			if (flag)
			{
				_chunks.DeleteMany("_id BETWEEN { f: @0, n: 0} AND {f: @0, n: @1 }", bsonValue, int.MaxValue);
			}
			return flag;
		}
	}
	internal class ConnectionString
	{
		private readonly Dictionary<string, string> _values;

		public ConnectionType Connection { get; set; }

		public string Filename { get; set; } = "";


		public string Password { get; set; }

		public long InitialSize { get; set; }

		public bool ReadOnly { get; set; }

		public bool Upgrade { get; set; }

		public bool AutoRebuild { get; set; }

		public Collation Collation { get; set; }

		public string this[string key] => _values.GetOrDefault(key);

		public ConnectionString()
		{
			_values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
		}

		public ConnectionString(string connectionString)
			: this()
		{
			if (string.IsNullOrEmpty(connectionString))
			{
				throw new ArgumentNullException("connectionString");
			}
			if (connectionString.Contains("="))
			{
				_values.ParseKeyValue(connectionString);
			}
			else
			{
				_values["filename"] = connectionString;
			}
			Connection = _values.GetValue("connection", Connection);
			Filename = _values.GetValue("filename", Filename).Trim();
			Password = _values.GetValue("password", Password);
			if (Password == string.Empty)
			{
				Password = null;
			}
			InitialSize = _values.GetFileSize("initial size", InitialSize);
			ReadOnly = _values.GetValue("readonly", ReadOnly);
			Collation = (_values.ContainsKey("collation") ? new Collation(_values.GetValue<string>("collation")) : Collation);
			Upgrade = _values.GetValue("upgrade", Upgrade);
			AutoRebuild = _values.GetValue("auto-rebuild", AutoRebuild);
		}

		internal ILiteEngine CreateEngine(Action<EngineSettings> engineSettingsAction = null)
		{
			EngineSettings engineSettings = new EngineSettings
			{
				Filename = Filename,
				Password = Password,
				InitialSize = InitialSize,
				ReadOnly = ReadOnly,
				Collation = Collation,
				Upgrade = Upgrade,
				AutoRebuild = AutoRebuild
			};
			engineSettingsAction?.Invoke(engineSettings);
			if (Connection == ConnectionType.Direct)
			{
				return new LiteEngine(engineSettings);
			}
			if (Connection == ConnectionType.Shared)
			{
				return new SharedEngine(engineSettings);
			}
			throw new NotImplementedException();
		}
	}
	internal enum ConnectionType
	{
		Direct,
		Shared
	}
	internal class Query
	{
		public const int Ascending = 1;

		public const int Descending = -1;

		public BsonExpression Select { get; set; } = BsonExpression.Root;


		public List<BsonExpression> Includes { get; } = new List<BsonExpression>();


		public List<BsonExpression> Where { get; } = new List<BsonExpression>();


		public List<QueryOrder> OrderBy { get; } = new List<QueryOrder>();


		public BsonExpression GroupBy { get; set; }

		public BsonExpression Having { get; set; }

		public int Offset { get; set; }

		public int Limit { get; set; } = int.MaxValue;


		public bool ForUpdate { get; set; }

		public string VectorField { get; set; }

		public float[] VectorTarget { get; set; }

		public double VectorMaxDistance { get; set; } = double.MaxValue;


		public bool HasVectorFilter
		{
			get
			{
				if (VectorField != null)
				{
					return VectorTarget != null;
				}
				return false;
			}
		}

		public string Into { get; set; }

		public BsonAutoId IntoAutoId { get; set; } = BsonAutoId.ObjectId;


		public bool ExplainPlan { get; set; }

		public static Query All()
		{
			return new Query();
		}

		public static Query All(int order = 1)
		{
			return new Query
			{
				OrderBy = 
				{
					new QueryOrder(BsonExpression.Create("_id"), order)
				}
			};
		}

		public static Query All(string field, int order = 1)
		{
			return new Query
			{
				OrderBy = 
				{
					new QueryOrder(BsonExpression.Create(field), order)
				}
			};
		}

		public static BsonExpression EQ(string field, BsonValue value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} = {value ?? BsonValue.Null}");
		}

		public static BsonExpression LT(string field, BsonValue value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} < {value ?? BsonValue.Null}");
		}

		public static BsonExpression LTE(string field, BsonValue value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} <= {value ?? BsonValue.Null}");
		}

		public static BsonExpression GT(string field, BsonValue value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} > {value ?? BsonValue.Null}");
		}

		public static BsonExpression GTE(string field, BsonValue value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} >= {value ?? BsonValue.Null}");
		}

		public static BsonExpression Between(string field, BsonValue start, BsonValue end)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} BETWEEN {start ?? BsonValue.Null} AND {end ?? BsonValue.Null}");
		}

		public static BsonExpression StartsWith(string field, string value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			if (value.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create(string.Format("{0} LIKE {1}", field, new BsonValue(value + "%")));
		}

		public static BsonExpression EndsWith(string field, string value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			if (value.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create(string.Format("{0} LIKE {1}", field, new BsonValue("%" + value)));
		}

		public static BsonExpression Contains(string field, string value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			if (value.IsNullOrEmpty())
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create(string.Format("{0} LIKE {1}", field, new BsonValue("%" + value + "%")));
		}

		public static BsonExpression Not(string field, BsonValue value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			return BsonExpression.Create($"{field} != {value ?? BsonValue.Null}");
		}

		public static BsonExpression In(string field, BsonArray value)
		{
			if (field.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("field");
			}
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create($"{field} IN {value}");
		}

		public static BsonExpression In(string field, params BsonValue[] values)
		{
			return In(field, new BsonArray(values));
		}

		public static BsonExpression In(string field, IEnumerable<BsonValue> values)
		{
			return In(field, new BsonArray(values));
		}

		public static QueryAny Any()
		{
			return new QueryAny();
		}

		public static BsonExpression And(BsonExpression left, BsonExpression right)
		{
			if (left == null)
			{
				throw new ArgumentNullException("left");
			}
			if (right == null)
			{
				throw new ArgumentNullException("right");
			}
			return "(" + left.Source + " AND " + right.Source + ")";
		}

		public static BsonExpression And(params BsonExpression[] queries)
		{
			if (queries == null || queries.Length < 2)
			{
				throw new ArgumentException("At least two Query should be passed");
			}
			BsonExpression bsonExpression = queries[0];
			for (int i = 1; i < queries.Length; i++)
			{
				bsonExpression = And(bsonExpression, queries[i]);
			}
			return bsonExpression;
		}

		public static BsonExpression Or(BsonExpression left, BsonExpression right)
		{
			if (left == null)
			{
				throw new ArgumentNullException("left");
			}
			if (right == null)
			{
				throw new ArgumentNullException("right");
			}
			return "(" + left.Source + " OR " + right.Source + ")";
		}

		public static BsonExpression Or(params BsonExpression[] queries)
		{
			if (queries == null || queries.Length < 2)
			{
				throw new ArgumentException("At least two Query should be passed");
			}
			BsonExpression bsonExpression = queries[0];
			for (int i = 1; i < queries.Length; i++)
			{
				bsonExpression = Or(bsonExpression, queries[i]);
			}
			return bsonExpression;
		}

		public string ToSQL(string collection)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (ExplainPlan)
			{
				stringBuilder.AppendLine("EXPLAIN");
			}
			stringBuilder.AppendLine("SELECT " + Select.Source);
			if (Into != null)
			{
				stringBuilder.AppendLine("INTO " + Into + ":" + IntoAutoId.ToString().ToLower());
			}
			stringBuilder.AppendLine("FROM " + collection);
			if (Includes.Count > 0)
			{
				stringBuilder.AppendLine("INCLUDE " + string.Join(", ", Includes.Select((BsonExpression x) => x.Source)));
			}
			if (GroupBy != null)
			{
				stringBuilder.AppendLine("GROUP BY " + GroupBy.Source);
			}
			if (Having != null)
			{
				stringBuilder.AppendLine("HAVING " + Having.Source);
			}
			if (OrderBy.Count > 0)
			{
				IEnumerable<string> values = OrderBy.Select((QueryOrder x) => x.Expression.Source + " " + ((x.Order == 1) ? "ASC" : "DESC"));
				stringBuilder.AppendLine("ORDER BY " + string.Join(", ", values));
			}
			if (Limit != int.MaxValue)
			{
				stringBuilder.AppendLine($"LIMIT {Limit}");
			}
			if (Offset != 0)
			{
				stringBuilder.AppendLine($"OFFSET {Offset}");
			}
			if (ForUpdate)
			{
				stringBuilder.AppendLine("FOR UPDATE");
			}
			if (HasVectorFilter)
			{
				string text = VectorField;
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Trim();
					if (!text.StartsWith("$", StringComparison.Ordinal))
					{
						text = (text.StartsWith(".", StringComparison.Ordinal) ? ("$" + text) : ("$." + text));
					}
				}
				string text2 = "VECTOR_SIM(" + text + ", [" + string.Join(",", VectorTarget) + "])";
				if (Where.Count > 0)
				{
					stringBuilder.AppendLine(string.Format("WHERE ({0}) AND {1} <= {2}", string.Join(" AND ", Where.Select((BsonExpression x) => x.Source)), text2, VectorMaxDistance));
				}
				else
				{
					stringBuilder.AppendLine($"WHERE {text2} <= {VectorMaxDistance}");
				}
			}
			else if (Where.Count > 0)
			{
				stringBuilder.AppendLine("WHERE " + string.Join(" AND ", Where.Select((BsonExpression x) => x.Source)));
			}
			return stringBuilder.ToString().Trim();
		}
	}
	internal class QueryAny
	{
		public BsonExpression EQ(string arrayField, BsonValue value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY = {value ?? BsonValue.Null}");
		}

		public BsonExpression LT(string arrayField, BsonValue value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY < {value ?? BsonValue.Null}");
		}

		public BsonExpression LTE(string arrayField, BsonValue value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY <= {value ?? BsonValue.Null}");
		}

		public BsonExpression GT(string arrayField, BsonValue value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY > {value ?? BsonValue.Null}");
		}

		public BsonExpression GTE(string arrayField, BsonValue value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY >= {value ?? BsonValue.Null}");
		}

		public BsonExpression Between(string arrayField, BsonValue start, BsonValue end)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY BETWEEN {start ?? BsonValue.Null} AND {end ?? BsonValue.Null}");
		}

		public BsonExpression StartsWith(string arrayField, string value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			if (value.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create(string.Format("{0} ANY LIKE {1}", arrayField, new BsonValue(value + "%")));
		}

		public BsonExpression EndsWith(string arrayField, string value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			if (value.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create(string.Format("{0} ANY LIKE {1}", arrayField, new BsonValue("%" + value)));
		}

		public BsonExpression Contains(string arrayField, string value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			if (value.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("value");
			}
			return BsonExpression.Create(string.Format("{0} ANY LIKE {1}", arrayField, new BsonValue("%" + value + "%")));
		}

		public BsonExpression Not(string arrayField, BsonValue value)
		{
			if (arrayField.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("arrayField");
			}
			return BsonExpression.Create($"{arrayField} ANY != {value ?? BsonValue.Null}");
		}
	}
	internal class BsonSerializer
	{
		public static byte[] Serialize(BsonDocument doc)
		{
			if (doc == null)
			{
				throw new ArgumentNullException("doc");
			}
			byte[] array = new byte[doc.GetBytesCount(recalc: true)];
			using BufferWriter bufferWriter = new BufferWriter(array);
			bufferWriter.WriteDocument(doc, recalc: false);
			return array;
		}

		public static BsonDocument Deserialize(byte[] buffer, bool utcDate = false, HashSet<string> fields = null)
		{
			if (buffer == null || buffer.Length == 0)
			{
				throw new ArgumentNullException("buffer");
			}
			using BufferReader bufferReader = new BufferReader(buffer, utcDate);
			return bufferReader.ReadDocument(fields).GetValue();
		}
	}
	internal class BsonArray : BsonValue, IList<BsonValue>, ICollection<BsonValue>, IEnumerable<BsonValue>, IEnumerable
	{
		[CompilerGenerated]
		private sealed class <System-Collections-IEnumerable-GetEnumerator>d__25 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public BsonArray <>4__this;

			private IEnumerator<BsonValue> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <System-Collections-IEnumerable-GetEnumerator>d__25(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BsonArray bsonArray = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = bsonArray.RawValue.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						BsonValue current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

		private int _length;

		public new IList<BsonValue> RawValue => (IList<BsonValue>)base.RawValue;

		public override BsonValue this[int index]
		{
			get
			{
				return RawValue[index];
			}
			set
			{
				RawValue[index] = value ?? BsonValue.Null;
			}
		}

		public int Count => RawValue.Count;

		public bool IsReadOnly => false;

		public BsonArray()
			: base(BsonType.Array, new List<BsonValue>())
		{
		}

		public BsonArray(List<BsonValue> array)
			: this()
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			AddRange(array);
		}

		public BsonArray(params BsonValue[] array)
			: this()
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			AddRange(array);
		}

		public BsonArray(IEnumerable<BsonValue> items)
			: this()
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			AddRange(items);
		}

		public BsonArray(BsonArray items)
			: this()
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			AddRange(items);
		}

		public void Add(BsonValue item)
		{
			RawValue.Add(item ?? BsonValue.Null);
		}

		public void AddRange<TCollection>(TCollection collection) where TCollection : ICollection<BsonValue>
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			List<BsonValue> list = (List<BsonValue>)base.RawValue;
			if (list.Capacity - list.Count < collection.Count)
			{
				list.Capacity += collection.Count;
			}
			foreach (BsonValue item in collection)
			{
				list.Add(item ?? BsonValue.Null);
			}
		}

		public void AddRange(IEnumerable<BsonValue> items)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			foreach (BsonValue item in items)
			{
				Add(item ?? BsonValue.Null);
			}
		}

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

		public bool Contains(BsonValue item)
		{
			return RawValue.Contains(item ?? BsonValue.Null);
		}

		public void CopyTo(BsonValue[] array, int arrayIndex)
		{
			RawValue.CopyTo(array, arrayIndex);
		}

		public IEnumerator<BsonValue> GetEnumerator()
		{
			return RawValue.GetEnumerator();
		}

		public int IndexOf(BsonValue item)
		{
			return RawValue.IndexOf(item ?? BsonValue.Null);
		}

		public void Insert(int index, BsonValue item)
		{
			RawValue.Insert(index, item ?? BsonValue.Null);
		}

		public bool Remove(BsonValue item)
		{
			return RawValue.Remove(item);
		}

		public void RemoveAt(int index)
		{
			RawValue.RemoveAt(index);
		}

		[IteratorStateMachine(typeof(<System-Collections-IEnumerable-GetEnumerator>d__25))]
		IEnumerator IEnumerable.GetEnumerator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <System-Collections-IEnumerable-GetEnumerator>d__25(0)
			{
				<>4__this = this
			};
		}

		public override int CompareTo(BsonValue other)
		{
			if (other.Type != BsonType.Array)
			{
				return base.Type.CompareTo(other.Type);
			}
			BsonArray asArray = other.AsArray;
			int num = 0;
			int num2 = 0;
			int num3 = Math.Min(Count, asArray.Count);
			while (num == 0 && num2 < num3)
			{
				num = this[num2].CompareTo(asArray[num2]);
				num2++;
			}
			if (num != 0)
			{
				return num;
			}
			if (num2 == Count)
			{
				if (num2 != asArray.Count)
				{
					return -1;
				}
				return 0;
			}
			return 1;
		}

		internal override int GetBytesCount(bool recalc)
		{
			if (!recalc && _length > 0)
			{
				return _length;
			}
			int num = 5;
			IList<BsonValue> rawValue = RawValue;
			for (int i = 0; i < rawValue.Count; i++)
			{
				num += GetBytesCountElement(i.ToString(), rawValue[i]);
			}
			return _length = num;
		}
	}
	internal enum BsonAutoId
	{
		Int32 = 2,
		Int64 = 3,
		ObjectId = 10,
		Guid = 11
	}
	internal class BsonDocument : BsonValue, IDictionary<string, BsonValue>, ICollection<KeyValuePair<string, BsonValue>>, IEnumerable<KeyValuePair<string, BsonValue>>, IEnumerable
	{
		[CompilerGenerated]
		private sealed class <GetElements>d__22 : IEnumerable<KeyValuePair<string, BsonValue>>, IEnumerable, IEnumerator<KeyValuePair<string, BsonValue>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<string, BsonValue> <>2__current;

			private int <>l__initialThreadId;

			public BsonDocument <>4__this;

			private IEnumerator<KeyValuePair<string, BsonValue>> <>7__wrap1;

			KeyValuePair<string, BsonValue> IEnumerator<KeyValuePair<string, BsonValue>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BsonDocument bsonDocument = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if (bsonDocument.RawValue.TryGetValue("_id", out var value))
						{
							<>2__current = new KeyValuePair<string, BsonValue>("_id", value);
							<>1__state = 1;
							return true;
						}
						goto IL_0068;
					}
					case 1:
						<>1__state = -1;
						goto IL_0068;
					case 2:
						{
							<>1__state = -3;
							break;
						}
						IL_0068:
						<>7__wrap1 = bsonDocument.RawValue.Where((KeyValuePair<string, BsonValue> x) => x.Key != "_id").GetEnumerator();
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						KeyValuePair<string, BsonValue> current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<KeyValuePair<string, BsonValue>> IEnumerable<KeyValuePair<string, BsonValue>>.GetEnumerator()
			{
				<GetElements>d__22 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetElements>d__22(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<string, BsonValue>>)this).GetEnumerator();
			}
		}

		private int _length;

		public new IDictionary<string, BsonValue> RawValue => base.RawValue as IDictionary<string, BsonValue>;

		internal PageAddress RawId { get; set; } = PageAddress.Empty;


		public override BsonValue this[string key]
		{
			get
			{
				return RawValue.GetOrDefault(key, BsonValue.Null);
			}
			set
			{
				RawValue[key] = value ?? BsonValue.Null;
			}
		}

		public ICollection<string> Keys => RawValue.Keys;

		public ICollection<BsonValue> Values => RawValue.Values;

		public int Count => RawValue.Count;

		public bool IsReadOnly => false;

		public BsonDocument()
			: base(BsonType.Document, new Dictionary<string, BsonValue>(StringComparer.OrdinalIgnoreCase))
		{
		}

		public BsonDocument(ConcurrentDictionary<string, BsonValue> dict)
			: this()
		{
			if (dict == null)
			{
				throw new ArgumentNullException("dict");
			}
			foreach (KeyValuePair<string, BsonValue> item in dict)
			{
				Add(item);
			}
		}

		public BsonDocument(IDictionary<string, BsonValue> dict)
			: this()
		{
			if (dict == null)
			{
				throw new ArgumentNullException("dict");
			}
			foreach (KeyValuePair<string, BsonValue> item in dict)
			{
				Add(item);
			}
		}

		public override int CompareTo(BsonValue other)
		{
			if (other.Type != BsonType.Document)
			{
				return base.Type.CompareTo(other.Type);
			}
			string[] array = Keys.ToArray();
			int num = array.Length;
			BsonDocument asDocument = other.AsDocument;
			int num2 = asDocument.Keys.ToArray().Length;
			int num3 = 0;
			int num4 = 0;
			int num5 = Math.Min(num, num2);
			while (num3 == 0 && num4 < num5)
			{
				num3 = this[array[num4]].CompareTo(asDocument[array[num4]]);
				num4++;
			}
			if (num3 != 0)
			{
				return num3;
			}
			if (num4 == num)
			{
				if (num4 != num2)
				{
					return -1;
				}
				return 0;
			}
			return 1;
		}

		public bool ContainsKey(string key)
		{
			return RawValue.ContainsKey(key);
		}

		[IteratorStateMachine(typeof(<GetElements>d__22))]
		public IEnumerable<KeyValuePair<string, BsonValue>> GetElements()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetElements>d__22(-2)
			{
				<>4__this = this
			};
		}

		public void Add(string key, BsonValue value)
		{
			RawValue.Add(key, value ?? BsonValue.Null);
		}

		public bool Remove(string key)
		{
			return RawValue.Remove(key);
		}

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

		public bool TryGetValue(string key, out BsonValue value)
		{
			return RawValue.TryGetValue(key, out value);
		}

		public void Add(KeyValuePair<string, BsonValue> item)
		{
			Add(item.Key, item.Value);
		}

		public bool Contains(KeyValuePair<string, BsonValue> item)
		{
			return RawValue.Contains(item);
		}

		public bool Remove(KeyValuePair<string, BsonValue> item)
		{
			return Remove(item.Key);
		}

		public IEnumerator<KeyValuePair<string, BsonValue>> GetEnumerator()
		{
			return RawValue.GetEnumerator();
		}

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

		public void CopyTo(KeyValuePair<string, BsonValue>[] array, int arrayIndex)
		{
			RawValue.CopyTo(array, arrayIndex);
		}

		public void CopyTo(BsonDocument other)
		{
			using IEnumerator<KeyValuePair<string, BsonValue>> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<string, BsonValue> current = enumerator.Current;
				other[current.Key] = current.Value;
			}
		}

		internal override int GetBytesCount(bool recalc)
		{
			if (!recalc && _length > 0)
			{
				return _length;
			}
			int num = 5;
			foreach (KeyValuePair<string, BsonValue> item in RawValue)
			{
				num += GetBytesCountElement(item.Key, item.Value);
			}
			return _length = num;
		}
	}
	internal enum BsonType : byte
	{
		MinValue = 0,
		Null = 1,
		Int32 = 2,
		Int64 = 3,
		Double = 4,
		Decimal = 5,
		String = 6,
		Document = 7,
		Array = 8,
		Binary = 9,
		ObjectId = 10,
		Guid = 11,
		Boolean = 12,
		DateTime = 13,
		MaxValue = 14,
		Vector = 100
	}
	internal class BsonValue : IComparable<BsonValue>, IEquatable<BsonValue>
	{
		public static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		public static BsonValue Null = new BsonValue(BsonType.Null, null);

		public static BsonValue MinValue = new BsonValue(BsonType.MinValue, "-oo");

		public static BsonValue MaxValue = new BsonValue(BsonType.MaxValue, "+oo");

		public BsonType Type { get; }

		public virtual object RawValue { get; }

		public virtual BsonValue this[string name]
		{
			get
			{
				throw new InvalidOperationException("Cannot access non-document type value on " + RawValue);
			}
			set
			{
				throw new InvalidOperationException("Cannot access non-document type value on " + RawValue);
			}
		}

		public virtual BsonValue this[int index]
		{
			get
			{
				throw new InvalidOperationException("Cannot access non-array type value on " + RawValue);
			}
			set
			{
				throw new InvalidOperationException("Cannot access non-array type value on " + RawValue);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public BsonArray AsArray => this as BsonArray;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public BsonDocument AsDocument => this as BsonDocument;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public byte[] AsBinary => RawValue as byte[];

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool AsBoolean => (bool)RawValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public string AsString => (string)RawValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public int AsInt32 => Convert.ToInt32(RawValue);

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public long AsInt64 => Convert.ToInt64(RawValue);

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public double AsDouble => Convert.ToDouble(RawValue);

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public decimal AsDecimal => Convert.ToDecimal(RawValue);

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public DateTime AsDateTime => (DateTime)RawValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public ObjectId AsObjectId => (ObjectId)RawValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Guid AsGuid => (Guid)RawValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public float[] AsVector => (float[])RawValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsNull => Type == BsonType.Null;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsArray => Type == BsonType.Array;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDocument => Type == BsonType.Document;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsInt32 => Type == BsonType.Int32;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsInt64 => Type == BsonType.Int64;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDouble => Type == BsonType.Double;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDecimal => Type == BsonType.Decimal;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsNumber
		{
			get
			{
				if (!IsInt32 && !IsInt64 && !IsDouble)
				{
					return IsDecimal;
				}
				return true;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsBinary => Type == BsonType.Binary;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsBoolean => Type == BsonType.Boolean;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsString => Type == BsonType.String;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsObjectId => Type == BsonType.ObjectId;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsGuid => Type == BsonType.Guid;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsVector => Type == BsonType.Vector;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDateTime => Type == BsonType.DateTime;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsMinValue => Type == BsonType.MinValue;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsMaxValue => Type == BsonType.MaxValue;

		public static BsonDocument DbRef(BsonValue id, string collection)
		{
			return new BsonDocument
			{
				["$id"] = id,
				["$ref"] = collection
			};
		}

		public BsonValue()
		{
			Type = BsonType.Null;
			RawValue = null;
		}

		public BsonValue(int value)
		{
			Type = BsonType.Int32;
			RawValue = value;
		}

		public BsonValue(long value)
		{
			Type = BsonType.Int64;
			RawValue = value;
		}

		public BsonValue(double value)
		{
			Type = BsonType.Double;
			RawValue = value;
		}

		public BsonValue(decimal value)
		{
			Type = BsonType.Decimal;
			RawValue = value;
		}

		public BsonValue(string value)
		{
			Type = ((value == null) ? BsonType.Null : BsonType.String);
			RawValue = value;
		}

		public BsonValue(byte[] value)
		{
			Type = ((value == null) ? BsonType.Null : BsonType.Binary);
			RawValue = value;
		}

		public BsonValue(ObjectId value)
		{
			Type = ((value == null) ? BsonType.Null : BsonType.ObjectId);
			RawValue = value;
		}

		public BsonValue(Guid value)
		{
			Type = BsonType.Guid;
			RawValue = value;
		}

		public BsonValue(bool value)
		{
			Type = BsonType.Boolean;
			RawValue = value;
		}

		public BsonValue(DateTime value)
		{
			Type = BsonType.DateTime;
			RawValue = value.Truncate();
		}

		protected BsonValue(BsonType type, object rawValue)
		{
			Type = type;
			RawValue = rawValue;
		}

		protected BsonValue(float[] value)
		{
			Type = BsonType.Vector;
			RawValue = value;
		}

		public BsonValue(object value)
		{
			RawValue = value;
			if (value == null)
			{
				Type = BsonType.Null;
				return;
			}
			if (value is int)
			{
				Type = BsonType.Int32;
				return;
			}
			if (value is long)
			{
				Type = BsonType.Int64;
				return;
			}
			if (value is double)
			{
				Type = BsonType.Double;
				return;
			}
			if (value is decimal)
			{
				Type = BsonType.Decimal;
				return;
			}
			if (value is string)
			{
				Type = BsonType.String;
				return;
			}
			if (value is IDictionary<string, BsonValue>)
			{
				Type = BsonType.Document;
				return;
			}
			if (value is IList<BsonValue>)
			{
				Type = BsonType.Array;
				return;
			}
			if (value is byte[])
			{
				Type = BsonType.Binary;
				return;
			}
			if (value is ObjectId)
			{
				Type = BsonType.ObjectId;
				return;
			}
			if (value is Guid)
			{
				Type = BsonType.Guid;
				return;
			}
			if (value is bool)
			{
				Type = BsonType.Boolean;
				return;
			}
			if (value is float[])
			{
				Type = BsonType.Vector;
				return;
			}
			if (value is DateTime)
			{
				Type = BsonType.DateTime;
				RawValue = ((DateTime)value).Truncate();
				return;
			}
			if (value is BsonValue)
			{
				BsonValue bsonValue = (BsonValue)value;
				Type = bsonValue.Type;
				RawValue = bsonValue.RawValue;
				return;
			}
			IEnumerable enumerable = value as IEnumerable;
			if (value is IDictionary dictionary)
			{
				Dictionary<string, BsonValue> dictionary2 = new Dictionary<string, BsonValue>();
				foreach (object key in dictionary.Keys)
				{
					dictionary2.Add(key.ToString(), new BsonValue(dictionary[key]));
				}
				Type = BsonType.Document;
				RawValue = dictionary2;
				return;
			}
			if (enumerable != null)
			{
				List<BsonValue> list = new List<BsonValue>();
				foreach (object item in enumerable)
				{
					list.Add(new BsonValue(item));
				}
				Type = BsonType.Array;
				RawValue = list;
				return;
			}
			throw new InvalidCastException("Value is not a valid BSON data type - Use Mapper.ToDocument for more complex types converts");
		}

		public static implicit operator int(BsonValue value)
		{
			return (int)value.RawValue;
		}

		public static implicit operator BsonValue(int value)
		{
			return new BsonValue(value);
		}

		public static implicit operator long(BsonValue value)
		{
			return (long)value.RawValue;
		}

		public static implicit operator BsonValue(long value)
		{
			return new BsonValue(value);
		}

		public static implicit operator double(BsonValue value)
		{
			return (double)value.RawValue;
		}

		public static implicit operator BsonValue(double value)
		{
			return new BsonValue(value);
		}

		public static implicit operator decimal(BsonValue value)
		{
			return (decimal)value.RawValue;
		}

		public static implicit operator BsonValue(decimal value)
		{
			return new BsonValue(value);
		}

		public static implicit operator ulong(BsonValue value)
		{
			return (ulong)value.RawValue;
		}

		public static implicit operator BsonValue(ulong value)
		{
			return new BsonValue((double)value);
		}

		public static implicit operator string(BsonValue value)
		{
			return (string)value.RawValue;
		}

		public static implicit operator BsonValue(string value)
		{
			return new BsonValue(value);
		}

		public static implicit operator byte[](BsonValue value)
		{
			return (byte[])value.RawValue;
		}

		public static implicit operator BsonValue(byte[] value)
		{
			return new BsonValue(value);
		}

		public static implicit operator ObjectId(BsonValue value)
		{
			return (ObjectId)value.RawValue;
		}

		public static implicit operator BsonValue(ObjectId value)
		{
			return new BsonValue(value);
		}

		public static implicit operator Guid(BsonValue value)
		{
			return (Guid)value.RawValue;
		}

		public static implicit operator BsonValue(Guid value)
		{
			return new BsonValue(value);
		}

		public static implicit operator float[](BsonValue value)
		{
			return value.AsVector;
		}

		public static implicit operator BsonValue(float[] value)
		{
			return new BsonVector(value);
		}

		public static implicit operator bool(BsonValue value)
		{
			return (bool)value.RawValue;
		}

		public static implicit operator BsonValue(bool value)
		{
			return new BsonValue(value);
		}

		public static implicit operator DateTime(BsonValue value)
		{
			return (DateTime)value.RawValue;
		}

		public static implicit operator BsonValue(DateTime value)
		{
			return new BsonValue(value);
		}

		public static BsonValue operator +(BsonValue left, BsonValue right)
		{
			if (!left.IsNumber || !right.IsNumber)
			{
				return Null;
			}
			if (left.IsInt32 && right.IsInt32)
			{
				return left.AsInt32 + right.AsInt32;
			}
			if (left.IsInt64 && right.IsInt64)
			{
				return left.AsInt64 + right.AsInt64;
			}
			if (left.IsDouble && right.IsDouble)
			{
				return left.AsDouble + right.AsDouble;
			}
			if (left.IsDecimal && right.IsDecimal)
			{
				return left.AsDecimal + right.AsDecimal;
			}
			decimal num = left.AsDecimal + right.AsDecimal;
			return (BsonType)(byte)Math.Max((int)left.Type, (int)right.Type) switch
			{
				BsonType.Double => new BsonValue((double)num), 
				BsonType.Int64 => new BsonValue((long)num), 
				_ => new BsonValue(num), 
			};
		}

		public static BsonValue operator -(BsonValue left, BsonValue right)
		{
			if (!left.IsNumber || !right.IsNumber)
			{
				return Null;
			}
			if (left.IsInt32 && right.IsInt32)
			{
				return left.AsInt32 - right.AsInt32;
			}
			if (left.IsInt64 && right.IsInt64)
			{
				return left.AsInt64 - right.AsInt64;
			}
			if (left.IsDouble && right.IsDouble)
			{
				return left.AsDouble - right.AsDouble;
			}
			if (left.IsDecimal && right.IsDecimal)
			{
				return left.AsDecimal - right.AsDecimal;
			}
			decimal num = left.AsDecimal - right.AsDecimal;
			return (BsonType)(byte)Math.Max((int)left.Type, (int)right.Type) switch
			{
				BsonType.Double => new BsonValue((double)num), 
				BsonType.Int64 => new BsonValue((long)num), 
				_ => new BsonValue(num), 
			};
		}

		public static BsonValue operator *(BsonValue left, BsonValue right)
		{
			if (!left.IsNumber || !right.IsNumber)
			{
				return Null;
			}
			if (left.IsInt32 && right.IsInt32)
			{
				return left.AsInt32 * right.AsInt32;
			}
			if (left.IsInt64 && right.IsInt64)
			{
				return left.AsInt64 * right.AsInt64;
			}
			if (left.IsDouble && right.IsDouble)
			{
				return left.AsDouble * right.AsDouble;
			}
			if (left.IsDecimal && right.IsDecimal)
			{
				return left.AsDecimal * right.AsDecimal;
			}
			decimal num = left.AsDecimal * right.AsDecimal;
			return (BsonType)(byte)Math.Max((int)left.Type, (int)right.Type) switch
			{
				BsonType.Double => new BsonValue((double)num), 
				BsonType.Int64 => new BsonValue((long)num), 
				_ => new BsonValue(num), 
			};
		}

		public static BsonValue operator /(BsonValue left, BsonValue right)
		{
			if (!left.IsNumber || !right.IsNumber)
			{
				return Null;
			}
			if (left.IsDecimal || right.IsDecimal)
			{
				return left.AsDecimal / right.AsDecimal;
			}
			return left.AsDouble / right.AsDouble;
		}

		public static BsonValue operator %(BsonValue left, BsonValue right)
		{
			if (!left.IsNumber || !right.IsNumber)
			{
				return Null;
			}
			if (left.IsInt32 && right.IsInt32)
			{
				return left.AsInt32 % right.AsInt32;
			}
			if (left.IsInt64 && right.IsInt64)
			{
				return left.AsInt64 % right.AsInt64;
			}
			if (left.IsDecimal && right.IsDecimal)
			{
				return left.AsDecimal % right.AsDecimal;
			}
			return left.AsDouble % right.AsDouble;
		}

		public override string ToString()
		{
			return JsonSerializer.Serialize(this);
		}

		public virtual int CompareTo(BsonValue other)
		{
			return CompareTo(other, Collation.Binary);
		}

		public virtual int CompareTo(BsonValue other, Collation collation)
		{
			if (Type != other.Type)
			{
				if (IsNumber && other.IsNumber)
				{
					return Convert.ToDecimal(RawValue).CompareTo(Convert.ToDecimal(other.RawValue));
				}
				int num = Type.CompareTo(other.Type);
				if (num >= 0)
				{
					return (num > 0) ? 1 : 0;
				}
				return -1;
			}
			switch (Type)
			{
			case BsonType.MinValue:
			case BsonType.Null:
			case BsonType.MaxValue:
				return 0;
			case BsonType.Int32:
				return AsInt32.CompareTo(other.AsInt32);
			case BsonType.Int64:
				return AsInt64.CompareTo(other.AsInt64);
			case BsonType.Double:
				return AsDouble.CompareTo(other.AsDouble);
			case BsonType.Decimal:
				return AsDecimal.CompareTo(other.AsDecimal);
			case BsonType.String:
				return collation.Compare(AsString, other.AsString);
			case BsonType.Document:
				return AsDocument.CompareTo(other);
			case BsonType.Array:
				return AsArray.CompareTo(other);
			case BsonType.Binary:
				return AsBinary.BinaryCompareTo(other.AsBinary);
			case BsonType.ObjectId:
				return AsObjectId.CompareTo(other.AsObjectId);
			case BsonType.Guid:
				return AsGuid.CompareTo(other.AsGuid);
			case BsonType.Boolean:
				return AsBoolean.CompareTo(other.AsBoolean);
			case BsonType.Vector:
			{
				float[] asVector = AsVector;
				float[] asVector2 = other.AsVector;
				int num2 = Math.Min(asVector.Length, asVector2.Length);
				for (int i = 0; i < num2; i++)
				{
					int num3 = asVector[i].CompareTo(asVector2[i]);
					if (num3 != 0)
					{
						return num3;
					}
				}
				if (asVector.Length == asVector2.Length)
				{
					return 0;
				}
				if (asVector.Length >= asVector2.Length)
				{
					return 1;
				}
				return -1;
			}
			case BsonType.DateTime:
			{
				DateTime dateTime = AsDateTime;
				DateTime value = other.AsDateTime;
				if (dateTime.Kind != DateTimeKind.Utc)
				{
					dateTime = dateTime.ToUniversalTime();
				}
				if (value.Kind != DateTimeKind.Utc)
				{
					value = value.ToUniversalTime();
				}
				return dateTime.CompareTo(value);
			}
			default:
				throw new NotImplementedException();
			}
		}

		public bool Equals(BsonValue other)
		{
			return CompareTo(other) == 0;
		}

		public static bool operator ==(BsonValue lhs, BsonValue rhs)
		{
			if ((object)lhs == null)
			{
				return (object)rhs == null;
			}
			if ((object)rhs == null)
			{
				return false;
			}
			return lhs.Equals(rhs);
		}

		public static bool operator !=(BsonValue lhs, BsonValue rhs)
		{
			return !(lhs == rhs);
		}

		public static bool operator >=(BsonValue lhs, BsonValue rhs)
		{
			return lhs.CompareTo(rhs) >= 0;
		}

		public static bool operator >(BsonValue lhs, BsonValue rhs)
		{
			return lhs.CompareTo(rhs) > 0;
		}

		public static bool operator <(BsonValue lhs, BsonValue rhs)
		{
			return lhs.CompareTo(rhs) < 0;
		}

		public static bool operator <=(BsonValue lhs, BsonValue rhs)
		{
			return lhs.CompareTo(rhs) <= 0;
		}

		public override bool Equals(object obj)
		{
			if (obj is BsonValue other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			int num = 17;
			num = 37 * num + Type.GetHashCode();
			return 37 * num + (RawValue?.GetHashCode() ?? 0);
		}

		internal virtual int GetBytesCount(bool recalc)
		{
			switch (Type)
			{
			case BsonType.MinValue:
			case BsonType.Null:
			case BsonType.MaxValue:
				return 0;
			case BsonType.Int32:
				return 4;
			case BsonType.Int64:
				return 8;
			case BsonType.Double:
				return 8;
			case BsonType.Decimal:
				return 16;
			case BsonType.String:
				return StringEncoding.UTF8.GetByteCount(AsString);
			case BsonType.Binary:
				return AsBinary.Length;
			case BsonType.ObjectId:
				return 12;
			case BsonType.Guid:
				return 16;
			case BsonType.Boolean:
				return 1;
			case BsonType.DateTime:
				return 8;
			case BsonType.Vector:
				return 2 + 4 * AsVector.Length;
			case BsonType.Document:
				return AsDocument.GetBytesCount(recalc);
			case BsonType.Array:
				return AsArray.GetBytesCount(recalc);
			default:
				throw new ArgumentException();
			}
		}

		protected int GetBytesCountElement(string key, BsonValue value)
		{
			bool flag = value.Type == BsonType.String || value.Type == BsonType.Binary || value.Type == BsonType.Guid;
			return 1 + StringEncoding.UTF8.GetByteCount(key) + 1 + value.GetBytesCount(recalc: true) + (flag ? 5 : 0);
		}
	}
	internal class BsonVector : BsonValue
	{
		public float[] Values => base.AsVector;

		public BsonVector(float[] values)
			: base(values)
		{
		}

		public BsonValue Clone()
		{
			return new BsonVector((float[])Values.Clone());
		}

		public override bool Equals(object? obj)
		{
			if (obj is BsonVector bsonVector)
			{
				return Values.SequenceEqual(bsonVector.Values);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Values.Aggregate(17, (int acc, float f) => acc * 31 + f.GetHashCode());
		}

		public override string ToString()
		{
			return "[" + string.Join(", ", Values.Select((float v) => v.ToString("0.###"))) + "]";
		}
	}
	internal class BsonDataReader : IBsonDataReader, IDisposable
	{
		private readonly IEnumerator<BsonValue> _source;

		private readonly EngineState _state;

		private readonly string _collection;

		private readonly bool _hasValues;

		private BsonValue _current;

		private bool _isFirst;

		private bool _disposed;

		public bool HasValues => _hasValues;

		public BsonValue Current => _current;

		public string Collection => _collection;

		public BsonValue this[string field] => _current.AsDocument[field] ?? BsonValue.Null;

		internal BsonDataReader()
		{
			_hasValues = false;
		}

		internal BsonDataReader(BsonValue value, string collection = null)
		{
			_current = value;
			_isFirst = (_hasValues = true);
			_collection = collection;
		}

		internal BsonDataReader(IEnumerable<BsonValue> values, string collection, EngineState state)
		{
			_collection = collection;
			_source = values.GetEnumerator();
			_state = state;
			try
			{
				_state.Validate();
				if (_source.MoveNext())
				{
					_hasValues = (_isFirst = true);
					_current = _state.ReadTransform(_collection, _source.Current);
				}
			}
			catch (Exception ex)
			{
				_state.Handle(ex);
				throw;
			}
		}

		public bool Read()
		{
			if (!_hasValues)
			{
				return false;
			}
			if (_isFirst)
			{
				_isFirst = false;
				return true;
			}
			if (_source != null)
			{
				_state.Validate();
				try
				{
					bool result = _source.MoveNext();
					_current = _state.ReadTransform(_collection, _source.Current);
					return result;
				}
				catch (Exception ex)
				{
					_state.Handle(ex);
					throw ex;
				}
			}
			return false;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		~BsonDataReader()
		{
			Dispose(disposing: false);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				_disposed = true;
				if (disposing)
				{
					_source?.Dispose();
				}
			}
		}
	}
	internal static class BsonDataReaderExtensions
	{
		[CompilerGenerated]
		private sealed class <ToEnumerable>d__0 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private IBsonDataReader reader;

			public IBsonDataReader <>3__reader;

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

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

			[DebuggerHidden]
			public <ToEnumerable>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 == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (reader.Read())
					{
						<>2__current = reader.Current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					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;
				reader.Dispose();
			}

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

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

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

		[IteratorStateMachine(typeof(<ToEnumerable>d__0))]
		public static IEnumerable<BsonValue> ToEnumerable(this IBsonDataReader reader)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ToEnumerable>d__0(-2)
			{
				<>3__reader = reader
			};
		}

		public static BsonValue[] ToArray(this IBsonDataReader reader)
		{
			return reader.ToEnumerable().ToArray();
		}

		public static IList<BsonValue> ToList(this IBsonDataReader reader)
		{
			return reader.ToEnumerable().ToList();
		}

		public static BsonValue First(this IBsonDataReader reader)
		{
			return reader.ToEnumerable().First();
		}

		public static BsonValue FirstOrDefault(this IBsonDataReader reader)
		{
			return reader.ToEnumerable().FirstOrDefault();
		}

		public static BsonValue Single(this IBsonDataReader reader)
		{
			return reader.ToEnumerable().Single();
		}

		public static BsonValue SingleOrDefault(this IBsonDataReader reader)
		{
			return reader.ToEnumerable().SingleOrDefault();
		}
	}
	internal interface IBsonDataReader : IDisposable
	{
		BsonValue this[string field] { get; }

		string Collection { get; }

		BsonValue Current { get; }

		bool HasValues { get; }

		bool Read();
	}
	internal delegate IEnumerable<BsonValue> BsonExpressionEnumerableDelegate(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation, BsonDocument parameters);
	internal delegate BsonValue BsonExpressionScalarDelegate(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation, BsonDocument parameters);
	internal sealed class BsonExpression
	{
		[CompilerGenerated]
		private sealed class <Execute>d__57 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			public BsonExpression <>4__this;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			private BsonDocument root;

			public BsonDocument <>3__root;

			private BsonValue current;

			public BsonValue <>3__current;

			private Collation collation;

			public Collation <>3__collation;

			private IEnumerator<BsonValue> <>7__wrap1;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BsonExpression bsonExpression = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if (bsonExpression.IsScalar)
						{
							BsonValue bsonValue = bsonExpression._funcScalar(source, root, current, collation ?? Collation.Binary, bsonExpression.Parameters);
							<>2__current = bsonValue;
							<>1__state = 1;
							return true;
						}
						IEnumerable<BsonValue> enumerable = bsonExpression._funcEnumerable(source, root, current, collation ?? Collation.Binary, bsonExpression.Parameters);
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						goto IL_00fd;
					}
					case 1:
						<>1__state = -1;
						break;
					case 2:
						{
							<>1__state = -3;
							goto IL_00fd;
						}
						IL_00fd:
						if (<>7__wrap1.MoveNext())
						{
							BsonValue bsonValue2 = <>7__wrap1.Current;
							<>2__current = bsonValue2;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						break;
					}
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<Execute>d__57 <Execute>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Execute>d__ = this;
				}
				else
				{
					<Execute>d__ = new <Execute>d__57(0)
					{
						<>4__this = <>4__this
					};
				}
				<Execute>d__.source = <>3__source;
				<Execute>d__.root = <>3__root;
				<Execute>d__.current = <>3__current;
				<Execute>d__.collation = <>3__collation;
				return <Execute>d__;
			}

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

		private BsonExpressionEnumerableDelegate _funcEnumerable;

		private BsonExpressionScalarDelegate _funcScalar;

		private static readonly ConcurrentDictionary<string, BsonExpressionEnumerableDelegate> _cacheEnumerable = new ConcurrentDictionary<string, BsonExpressionEnumerableDelegate>();

		private static readonly ConcurrentDictionary<string, BsonExpressionScalarDelegate> _cacheScalar = new ConcurrentDictionary<string, BsonExpressionScalarDelegate>();

		public static BsonExpression Root = Create("$");

		private static readonly Dictionary<string, MethodInfo> _methods = typeof(BsonExpressionMethods).GetMethods(BindingFlags.Static | BindingFlags.Public).ToDictionary((MethodInfo m) => m.Name.ToUpperInvariant() + "~" + (from p in m.GetParameters()
			where p.ParameterType != typeof(Collation)
			select p).Count());

		private static readonly Dictionary<string, MethodInfo> _functions = typeof(BsonExpressionFunctions).GetMethods(BindingFlags.Static | BindingFlags.Public).ToDictionary((MethodInfo m) => m.Name.ToUpperInvariant() + "~" + m.GetParameters().Skip(5).Count());

		public string Source { get; internal set; }

		public BsonExpressionType Type { get; internal set; }

		public bool IsImmutable { get; internal set; }

		public BsonDocument Parameters { get; internal set; }

		internal BsonExpression Left { get; set; }

		internal BsonExpression Right { get; set; }

		internal bool UseSource { get; set; }

		internal Expression Expression { get; set; }

		public HashSet<string> Fields { get; internal set; }

		public bool IsScalar { get; internal set; }

		internal bool IsPredicate
		{
			get
			{
				if (Type != BsonExpressionType.Equal && Type != BsonExpressionType.Like && Type != BsonExpressionType.Between && Type != BsonExpressionType.GreaterThan && Type != BsonExpressionType.GreaterThanOrEqual && Type != BsonExpressionType.LessThan && Type != BsonExpressionType.LessThanOrEqual && Type != BsonExpressionType.NotEqual)
				{
					return Type == BsonExpressionType.In;
				}
				return true;
			}
		}

		internal bool IsIndexable
		{
			get
			{
				if (Fields.Count > 0 && IsImmutable)
				{
					return Parameters.Count == 0;
				}
				return false;
			}
		}

		internal bool IsValue => Fields.Count == 0;

		internal bool IsANY
		{
			get
			{
				if (IsPredicate)
				{
					return Expression.ToString().Contains("_ANY");
				}
				return false;
			}
		}

		public static IEnumerable<MethodInfo> Methods => _methods.Values;

		public static IEnumerable<MethodInfo> Functions => _functions.Values;

		internal string DefaultFieldName()
		{
			string text = string.Join("_", Fields.Where((string x) => x != "$"));
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "expr";
		}

		internal BsonExpression()
		{
		}

		public static implicit operator string(BsonExpression expr)
		{
			return expr.Source;
		}

		public static implicit operator BsonExpression(string expr)
		{
			return Create(expr);
		}

		public IEnumerable<BsonValue> Execute(Collation collation = null)
		{
			BsonDocument bsonDocument = new BsonDocument();
			BsonDocument[] source = new BsonDocument[1] { bsonDocument };
			return Execute(source, bsonDocument, bsonDocument, collation);
		}

		public IEnumerable<BsonValue> Execute(BsonDocument root, Collation collation = null)
		{
			if (root == null)
			{
				throw new ArgumentNullException("root");
			}
			BsonDocument[] source = new BsonDocument[1] { root };
			return Execute(source, root, root, collation);
		}

		public IEnumerable<BsonValue> Execute(IEnumerable<BsonDocument> source, Collation collation = null)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return Execute(source, null, null, collation);
		}

		[IteratorStateMachine(typeof(<Execute>d__57))]
		internal IEnumerable<BsonValue> Execute(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Execute>d__57(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__root = root,
				<>3__current = current,
				<>3__collation = collation
			};
		}

		internal IEnumerable<BsonValue> GetIndexKeys(BsonDocument doc, Collation collation)
		{
			return Execute(doc, collation).Distinct();
		}

		public BsonValue ExecuteScalar(Collation collation = null)
		{
			BsonDocument bsonDocument = new BsonDocument();
			BsonDocument[] source = new BsonDocument[0];
			return ExecuteScalar(source, bsonDocument, bsonDocument, collation);
		}

		public BsonValue ExecuteScalar(BsonDocument root, Collation collation = null)
		{
			if (root == null)
			{
				throw new ArgumentNullException("root");
			}
			BsonDocument[] source = new BsonDocument[1] { root };
			return ExecuteScalar(source, root, root, collation);
		}

		public BsonValue ExecuteScalar(IEnumerable<BsonDocument> source, Collation collation = null)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return ExecuteScalar(source, null, null, collation);
		}

		internal BsonValue ExecuteScalar(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation)
		{
			if (IsScalar)
			{
				return _funcScalar(source, root, current, collation ?? Collation.Binary, Parameters);
			}
			throw new LiteException(0, "Expression `" + Source + "` is not a scalar expression and can return more than one result");
		}

		public static BsonExpression Create(string expression)
		{
			return Create(expression, new BsonDocument());
		}

		public static BsonExpression Create(string expression, params BsonValue[] args)
		{
			BsonDocument bsonDocument = new BsonDocument();
			for (int i = 0; i < args.Length; i++)
			{
				bsonDocument[i.ToString()] = args[i];
			}
			return Create(expression, bsonDocument);
		}

		public static BsonExpression Create(string expression, BsonDocument parameters)
		{
			if (string.IsNullOrWhiteSpace(expression))
			{
				throw new ArgumentNullException("expression");
			}
			Tokenizer tokenizer = new Tokenizer(expression);
			BsonExpression result = Create(tokenizer, BsonExpressionParserMode.Full, parameters);
			tokenizer.LookAhead().Expect(TokenType.EOF);
			return result;
		}

		internal static BsonExpression Create(Tokenizer tokenizer, BsonExpressionParserMode mode, BsonDocument parameters)
		{
			if (tokenizer == null)
			{
				throw new ArgumentNullException("tokenizer");
			}
			return ParseAndCompile(tokenizer, mode, parameters, DocumentScope.Root);
		}

		internal static BsonExpression ParseAndCompile(Tokenizer tokenizer, BsonExpressionParserMode mode, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer == null)
			{
				throw new ArgumentNullException("tokenizer");
			}
			ExpressionContext context = new ExpressionContext();
			object obj = mode switch
			{
				BsonExpressionParserMode.SelectDocument => BsonExpressionParser.ParseSelectDocumentBuilder(tokenizer, context, parameters), 
				BsonExpressionParserMode.Single => BsonExpressionParser.ParseSingleExpression(tokenizer, context, parameters, scope), 
				BsonExpressionParserMode.Full => BsonExpressionParser.ParseFullExpression(tokenizer, context, parameters, scope), 
				_ => BsonExpressionParser.ParseUpdateDocumentBuilder(tokenizer, context, parameters), 
			};
			Compile((BsonExpression)obj, context);
			return (BsonExpression)obj;
		}

		internal static void Compile(BsonExpression expr, ExpressionContext context)
		{
			if (expr.IsScalar)
			{
				BsonExpressionScalarDelegate orAdd = _cacheScalar.GetOrAdd(expr.Source, (string s) => Expression.Lambda<BsonExpressionScalarDelegate>(expr.Expression, new ParameterExpression[5] { context.Source, context.Root, context.Current, context.Collation, context.Parameters }).Compile());
				expr._funcScalar = orAdd;
			}
			else
			{
				BsonExpressionEnumerableDelegate orAdd2 = _cacheEnumerable.GetOrAdd(expr.Source, (string s) => Expression.Lambda<BsonExpressionEnumerableDelegate>(expr.Expression, new ParameterExpression[5] { context.Source, context.Root, context.Current, context.Collation, context.Parameters }).Compile());
				expr._funcEnumerable = orAdd2;
			}
			if (expr.Left != null)
			{
				Compile(expr.Left, context);
			}
			if (expr.Right != null)
			{
				Compile(expr.Right, context);
			}
		}

		internal static void SetParameters(BsonExpression expr, BsonDocument parameters)
		{
			expr.Parameters = parameters;
			if (expr.Left != null)
			{
				SetParameters(expr.Left, parameters);
			}
			if (expr.Right != null)
			{
				SetParameters(expr.Right, parameters);
			}
		}

		internal static MethodInfo GetMethod(string name, int parameterCount)
		{
			string key = name.ToUpperInvariant() + "~" + parameterCount;
			return _methods.GetOrDefault(key);
		}

		internal static MethodInfo GetFunction(string name, int parameterCount = 0)
		{
			string key = name.ToUpperInvariant() + "~" + parameterCount;
			return _functions.GetOrDefault(key);
		}

		public override string ToString()
		{
			return $"`{Source}` [{Type}]";
		}
	}
	internal class BsonExpressionMethods
	{
		[CompilerGenerated]
		private sealed class <ITEMS>d__77 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private BsonValue array;

			public BsonValue <>3__array;

			private IEnumerator<BsonValue> <>7__wrap1;

			private byte[] <>7__wrap2;

			private int <>7__wrap3;

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

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

			[DebuggerHidden]
			public <ITEMS>d__77(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();
					}
				}
				<>7__wrap1 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (array.IsArray)
						{
							<>7__wrap1 = array.AsArray.GetEnumerator();
							<>1__state = -3;
							goto IL_0081;
						}
						if (array.IsBinary)
						{
							<>7__wrap2 = array.AsBinary;
							<>7__wrap3 = 0;
							goto IL_0101;
						}
						<>2__current = array;
						<>1__state = 3;
						return true;
					case 1:
						<>1__state = -3;
						goto IL_0081;
					case 2:
						<>1__state = -1;
						<>7__wrap3++;
						goto IL_0101;
					case 3:
						{
							<>1__state = -1;
							break;
						}
						IL_0081:
						if (<>7__wrap1.MoveNext())
						{
							BsonValue current = <>7__wrap1.Current;
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						break;
						IL_0101:
						if (<>7__wrap3 < <>7__wrap2.Length)
						{
							byte b = <>7__wrap2[<>7__wrap3];
							<>2__current = (int)b;
							<>1__state = 2;
							return true;
						}
						<>7__wrap2 = null;
						break;
					}
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<ITEMS>d__77 <ITEMS>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ITEMS>d__ = this;
				}
				else
				{
					<ITEMS>d__ = new <ITEMS>d__77(0);
				}
				<ITEMS>d__.array = <>3__array;
				return <ITEMS>d__;
			}

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

		[CompilerGenerated]
		private sealed class <KEYS>d__79 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private BsonValue document;

			public BsonValue <>3__document;

			private IEnumerator<string> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <KEYS>d__79(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
					}
					else
					{
						<>1__state = -1;
						if (!document.IsDocument)
						{
							goto IL_0093;
						}
						<>7__wrap1 = document.AsDocument.Keys.GetEnumerator();
						<>1__state = -3;
					}
					if (<>7__wrap1.MoveNext())
					{
						string current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					goto IL_0093;
					IL_0093:
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<KEYS>d__79 <KEYS>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<KEYS>d__ = this;
				}
				else
				{
					<KEYS>d__ = new <KEYS>d__79(0);
				}
				<KEYS>d__.document = <>3__document;
				return <KEYS>d__;
			}

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

		[CompilerGenerated]
		private sealed class <SPLIT>d__104 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private BsonValue value;

			public BsonValue <>3__value;

			private BsonValue separator;

			public BsonValue <>3__separator;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<>7__wrap2++;
				}
				else
				{
					<>1__state = -1;
					if (!value.IsString || !separator.IsString)
					{
						goto IL_00bf;
					}
					string[] array = value.AsString.Split(new string[1] { separator.AsString }, StringSplitOptions.RemoveEmptyEntries);
					<>7__wrap1 = array;
					<>7__wrap2 = 0;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					string text = <>7__wrap1[<>7__wrap2];
					<>2__current = text;
					<>1__state = 1;
					return true;
				}
				<>7__wrap1 = null;
				goto IL_00bf;
				IL_00bf:
				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]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<SPLIT>d__104 <SPLIT>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SPLIT>d__ = this;
				}
				else
				{
					<SPLIT>d__ = new <SPLIT>d__104(0);
				}
				<SPLIT>d__.value = <>3__value;
				<SPLIT>d__.separator = <>3__separator;
				return <SPLIT>d__;
			}

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

		[CompilerGenerated]
		private sealed class <SPLIT>d__105 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private BsonValue useRegex;

			public BsonValue <>3__useRegex;

			private BsonValue value;

			public BsonValue <>3__value;

			private BsonValue pattern;

			public BsonValue <>3__pattern;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

			private IEnumerator<BsonValue> <>7__wrap3;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (useRegex.IsBoolean && useRegex.AsBoolean)
						{
							if (!value.IsString || !pattern.IsString)
							{
								break;
							}
							string[] array = Regex.Split(value.AsString, pattern.AsString, RegexOptions.Compiled);
							<>7__wrap1 = array;
							<>7__wrap2 = 0;
							goto IL_00d1;
						}
						<>7__wrap3 = SPLIT(value, pattern).GetEnumerator();
						<>1__state = -3;
						goto IL_0138;
					case 1:
						<>1__state = -1;
						<>7__wrap2++;
						goto IL_00d1;
					case 2:
						{
							<>1__state = -3;
							goto IL_0138;
						}
						IL_00d1:
						if (<>7__wrap2 < <>7__wrap1.Length)
						{
							string text = <>7__wrap1[<>7__wrap2];
							<>2__current = text;
							<>1__state = 1;
							return true;
						}
						<>7__wrap1 = null;
						break;
						IL_0138:
						if (<>7__wrap3.MoveNext())
						{
							BsonValue current = <>7__wrap3.Current;
							<>2__current = current;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap3 = null;
						break;
					}
					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__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<SPLIT>d__105 <SPLIT>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SPLIT>d__ = this;
				}
				else
				{
					<SPLIT>d__ = new <SPLIT>d__105(0);
				}
				<SPLIT>d__.value = <>3__value;
				<SPLIT>d__.pattern = <>3__pattern;
				<SPLIT>d__.useRegex = <>3__useRegex;
				return <SPLIT>d__;
			}

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

		[CompilerGenerated]
		private sealed class <VALUES>d__80 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private BsonValue document;

			public BsonValue <>3__document;

			private IEnumerator<BsonValue> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <VALUES>d__80(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
					}
					else
					{
						<>1__state = -1;
						if (!document.IsDocument)
						{
							goto IL_008e;
						}
						<>7__wrap1 = document.AsDocument.Values.GetEnumerator();
						<>1__state = -3;
					}
					if (<>7__wrap1.MoveNext())
					{
						BsonValue current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					goto IL_008e;
					IL_008e:
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<VALUES>d__80 <VALUES>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<VALUES>d__ = this;
				}
				else
				{
					<VALUES>d__ = new <VALUES>d__80(0);
				}
				<VALUES>d__.document = <>3__document;
				return <VALUES>d__;
			}

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

		private static readonly Random _random = new Random();

		public static BsonValue COUNT(IEnumerable<BsonValue> values)
		{
			return values.Count();
		}

		public static BsonValue MIN(IEnumerable<BsonValue> values)
		{
			BsonValue bsonValue = BsonValue.MaxValue;
			foreach (BsonValue value in values)
			{
				if (value.CompareTo(bsonValue) <= 0)
				{
					bsonValue = value;
				}
			}
			if (!(bsonValue == BsonValue.MaxValue))
			{
				return bsonValue;
			}
			return BsonValue.MinValue;
		}

		public static BsonValue MAX(IEnumerable<BsonValue> values)
		{
			BsonValue bsonValue = BsonValue.MinValue;
			foreach (BsonValue value in values)
			{
				if (value.CompareTo(bsonValue) >= 0)
				{
					bsonValue = value;
				}
			}
			if (!(bsonValue == BsonValue.MinValue))
			{
				return bsonValue;
			}
			return BsonValue.MaxValue;
		}

		public static BsonValue FIRST(IEnumerable<BsonValue> values)
		{
			return values.FirstOrDefault();
		}

		public static BsonValue LAST(IEnumerable<BsonValue> values)
		{
			return values.LastOrDefault();
		}

		public static BsonValue AVG(IEnumerable<BsonValue> values)
		{
			BsonValue bsonValue = new BsonValue(0);
			int num = 0;
			foreach (BsonValue item in values.Where((BsonValue x) => x.IsNumber))
			{
				bsonValue += item;
				num++;
			}
			if (num > 0)
			{
				return bsonValue / num;
			}
			return 0;
		}

		public static BsonValue SUM(IEnumerable<BsonValue> values)
		{
			BsonValue result = new BsonValue(0);
			foreach (BsonValue item in values.Where((BsonValue x) => x.IsNumber))
			{
				result += item;
			}
			return result;
		}

		public static BsonValue ANY(IEnumerable<BsonValue> values)
		{
			return values.Any();
		}

		public static BsonValue MINVALUE()
		{
			return BsonValue.MinValue;
		}

		[Volatile]
		public static BsonValue OBJECTID()
		{
			return ObjectId.NewObjectId();
		}

		[Volatile]
		public static BsonValue GUID()
		{
			return Guid.NewGuid();
		}

		[Volatile]
		public static BsonValue NOW()
		{
			return DateTime.Now;
		}

		[Volatile]
		public static BsonValue NOW_UTC()
		{
			return DateTime.UtcNow;
		}

		[Volatile]
		public static BsonValue TODAY()
		{
			return DateTime.Today;
		}

		public static BsonValue MAXVALUE()
		{
			return BsonValue.MaxValue;
		}

		public static BsonValue INT32(BsonValue value)
		{
			if (value.IsNumber)
			{
				return value.AsInt32;
			}
			if (value.IsString && int.TryParse(value.AsString, out var result))
			{
				return result;
			}
			return BsonValue.Null;
		}

		public static BsonValue INT64(BsonValue value)
		{
			if (value.IsNumber)
			{
				return value.AsInt64;
			}
			if (value.IsString && long.TryParse(value.AsString, out var result))
			{
				return result;
			}
			return BsonValue.Null;
		}

		public static BsonValue DOUBLE(Collation collation, BsonValue value)
		{
			if (value.IsNumber)
			{
				return value.AsDouble;
			}
			if (value.IsString && double.TryParse(value.AsString, NumberStyles.Any, collation.Culture.NumberFormat, out var result))
			{
				return result;
			}
			return BsonValue.Null;
		}

		public static BsonValue DOUBLE(BsonValue value, BsonValue culture)
		{
			if (value.IsNumber)
			{
				return value.AsDouble;
			}
			if (value.IsString && culture.IsString)
			{
				CultureInfo cultureInfo = new CultureInfo(culture.AsString);
				if (double.TryParse(value.AsString, NumberStyles.Any, cultureInfo.NumberFormat, out var result))
				{
					return result;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue DECIMAL(Collation collation, BsonValue value)
		{
			if (value.IsNumber)
			{
				return value.AsDecimal;
			}
			if (value.IsString && decimal.TryParse(value.AsString, NumberStyles.Any, collation.Culture.NumberFormat, out var result))
			{
				return result;
			}
			return BsonValue.Null;
		}

		public static BsonValue DECIMAL(BsonValue value, BsonValue culture)
		{
			if (value.IsNumber)
			{
				return value.AsDecimal;
			}
			if (value.IsString && culture.IsString)
			{
				CultureInfo cultureInfo = new CultureInfo(culture.AsString);
				if (decimal.TryParse(value.AsString, NumberStyles.Any, cultureInfo.NumberFormat, out var result))
				{
					return result;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue STRING(BsonValue value)
		{
			return value.IsNull ? "" : (value.IsString ? value.AsString : value.ToString());
		}

		public static BsonValue ARRAY(IEnumerable<BsonValue> values)
		{
			return new BsonArray(values);
		}

		public static BsonValue BINARY(BsonValue value)
		{
			if (value.IsBinary)
			{
				return value;
			}
			if (value.IsString)
			{
				byte[] array = null;
				bool flag = false;
				try
				{
					array = Convert.FromBase64String(value.AsString);
					flag = true;
				}
				catch (FormatException)
				{
				}
				if (flag)
				{
					return array;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue OBJECTID(BsonValue value)
		{
			if (value.IsObjectId)
			{
				return value.AsObjectId;
			}
			if (value.IsString)
			{
				ObjectId objectId = null;
				bool flag = false;
				try
				{
					objectId = new ObjectId(value.AsString);
					flag = true;
				}
				catch
				{
				}
				if (flag)
				{
					return objectId;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue GUID(BsonValue value)
		{
			if (value.IsGuid)
			{
				return value.AsGuid;
			}
			if (value.IsString)
			{
				Guid guid = Guid.Empty;
				bool flag = false;
				try
				{
					guid = new Guid(value.AsString);
					flag = true;
				}
				catch
				{
				}
				if (flag)
				{
					return guid;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue BOOLEAN(BsonValue value)
		{
			if (value.IsBoolean)
			{
				return value.AsBoolean;
			}
			bool flag = false;
			bool flag2 = false;
			try
			{
				flag = Convert.ToBoolean(value.AsString);
				flag2 = true;
			}
			catch
			{
			}
			if (flag2)
			{
				return flag;
			}
			return BsonValue.Null;
		}

		public static BsonValue DATETIME(Collation collation, BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime;
			}
			if (value.IsString && DateTime.TryParse(value.AsString, collation.Culture.DateTimeFormat, DateTimeStyles.None, out var result))
			{
				return result;
			}
			return BsonValue.Null;
		}

		public static BsonValue DATETIME(BsonValue value, BsonValue culture)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime;
			}
			if (value.IsString && culture.IsString)
			{
				CultureInfo cultureInfo = new CultureInfo(culture.AsString);
				if (DateTime.TryParse(value.AsString, cultureInfo.DateTimeFormat, DateTimeStyles.None, out var result))
				{
					return result;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue DATETIME_UTC(Collation collation, BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime;
			}
			if (value.IsString && DateTime.TryParse(value.AsString, collation.Culture.DateTimeFormat, DateTimeStyles.AssumeUniversal, out var result))
			{
				return result;
			}
			return BsonValue.Null;
		}

		public static BsonValue DATETIME_UTC(BsonValue value, BsonValue culture)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime;
			}
			if (value.IsString && culture.IsString)
			{
				CultureInfo cultureInfo = new CultureInfo(culture.AsString);
				if (DateTime.TryParse(value.AsString, cultureInfo.DateTimeFormat, DateTimeStyles.AssumeUniversal, out var result))
				{
					return result;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue DATETIME(BsonValue year, BsonValue month, BsonValue day)
		{
			if (year.IsNumber && month.IsNumber && day.IsNumber)
			{
				return new DateTime(year.AsInt32, month.AsInt32, day.AsInt32);
			}
			return BsonValue.Null;
		}

		public static BsonValue DATETIME_UTC(BsonValue year, BsonValue month, BsonValue day)
		{
			if (year.IsNumber && month.IsNumber && day.IsNumber)
			{
				return new DateTime(year.AsInt32, month.AsInt32, day.AsInt32, 0, 0, 0, DateTimeKind.Utc);
			}
			return BsonValue.Null;
		}

		public static BsonValue IS_MINVALUE(BsonValue value)
		{
			return value.IsMinValue;
		}

		public static BsonValue IS_NULL(BsonValue value)
		{
			return value.IsNull;
		}

		public static BsonValue IS_INT32(BsonValue value)
		{
			return value.IsInt32;
		}

		public static BsonValue IS_INT64(BsonValue value)
		{
			return value.IsInt64;
		}

		public static BsonValue IS_DOUBLE(BsonValue value)
		{
			return value.IsDouble;
		}

		public static BsonValue IS_DECIMAL(BsonValue value)
		{
			return value.IsDecimal;
		}

		public static BsonValue IS_NUMBER(BsonValue value)
		{
			return value.IsNumber;
		}

		public static BsonValue IS_STRING(BsonValue value)
		{
			return value.IsString;
		}

		public static BsonValue IS_DOCUMENT(BsonValue value)
		{
			return value.IsDocument;
		}

		public static BsonValue IS_ARRAY(BsonValue value)
		{
			return value.IsArray;
		}

		public static BsonValue IS_BINARY(BsonValue value)
		{
			return value.IsBinary;
		}

		public static BsonValue IS_OBJECTID(BsonValue value)
		{
			return value.IsObjectId;
		}

		public static BsonValue IS_GUID(BsonValue value)
		{
			return value.IsGuid;
		}

		public static BsonValue IS_BOOLEAN(BsonValue value)
		{
			return value.IsBoolean;
		}

		public static BsonValue IS_DATETIME(BsonValue value)
		{
			return value.IsDateTime;
		}

		public static BsonValue IS_MAXVALUE(BsonValue value)
		{
			return value.IsMaxValue;
		}

		public static BsonValue INT(BsonValue value)
		{
			return INT32(value);
		}

		public static BsonValue LONG(BsonValue value)
		{
			return INT64(value);
		}

		public static BsonValue BOOL(BsonValue value)
		{
			return BOOLEAN(value);
		}

		public static BsonValue DATE(Collation collation, BsonValue value)
		{
			return DATETIME(collation, value);
		}

		public static BsonValue DATE(BsonValue values, BsonValue culture)
		{
			return DATETIME(values, culture);
		}

		public static BsonValue DATE_UTC(Collation collation, BsonValue value)
		{
			return DATETIME_UTC(collation, value);
		}

		public static BsonValue DATE_UTC(BsonValue values, BsonValue culture)
		{
			return DATETIME_UTC(values, culture);
		}

		public static BsonValue DATE(BsonValue year, BsonValue month, BsonValue day)
		{
			return DATETIME(year, month, day);
		}

		public static BsonValue DATE_UTC(BsonValue year, BsonValue month, BsonValue day)
		{
			return DATETIME_UTC(year, month, day);
		}

		public static BsonValue IS_INT(BsonValue value)
		{
			return IS_INT32(value);
		}

		public static BsonValue IS_LONG(BsonValue value)
		{
			return IS_INT64(value);
		}

		public static BsonValue IS_BOOL(BsonValue value)
		{
			return IS_BOOLEAN(value);
		}

		public static BsonValue IS_DATE(BsonValue value)
		{
			return IS_DATETIME(value);
		}

		public static BsonValue YEAR(BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime.Year;
			}
			return BsonValue.Null;
		}

		public static BsonValue MONTH(BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime.Month;
			}
			return BsonValue.Null;
		}

		public static BsonValue DAY(BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime.Day;
			}
			return BsonValue.Null;
		}

		public static BsonValue HOUR(BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime.Hour;
			}
			return BsonValue.Null;
		}

		public static BsonValue MINUTE(BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime.Minute;
			}
			return BsonValue.Null;
		}

		public static BsonValue SECOND(BsonValue value)
		{
			if (value.IsDateTime)
			{
				return value.AsDateTime.Second;
			}
			return BsonValue.Null;
		}

		public static BsonValue DATEADD(BsonValue dateInterval, BsonValue number, BsonValue value)
		{
			if (dateInterval.IsString && number.IsNumber && value.IsDateTime)
			{
				string asString = dateInterval.AsString;
				int asInt = number.AsInt32;
				DateTime asDateTime = value.AsDateTime;
				switch ((asString == "M") ? "month" : asString.ToLower())
				{
				case "y":
				case "year":
					return asDateTime.AddYears(asInt);
				case "month":
					return asDateTime.AddMonths(asInt);
				case "d":
				case "day":
					return asDateTime.AddDays(asInt);
				case "h":
				case "hour":
					return asDateTime.AddHours(asInt);
				case "m":
				case "minute":
					return asDateTime.AddMinutes(asInt);
				case "s":
				case "second":
					return asDateTime.AddSeconds(asInt);
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue DATEDIFF(BsonValue dateInterval, BsonValue starts, BsonValue ends)
		{
			if (dateInterval.IsString && starts.IsDateTime && ends.IsDateTime)
			{
				string asString = dateInterval.AsString;
				DateTime asDateTime = starts.AsDateTime;
				DateTime asDateTime2 = ends.AsDateTime;
				switch ((asString == "M") ? "month" : asString.ToLower())
				{
				case "y":
				case "year":
					return asDateTime.YearDifference(asDateTime2);
				case "month":
					return asDateTime.MonthDifference(asDateTime2);
				case "d":
				case "day":
					return Convert.ToInt32(Math.Truncate(asDateTime2.Subtract(asDateTime).TotalDays));
				case "h":
				case "hour":
					return Convert.ToInt32(Math.Truncate(asDateTime2.Subtract(asDateTime).TotalHours));
				case "m":
				case "minute":
					return Convert.ToInt32(Math.Truncate(asDateTime2.Subtract(asDateTime).TotalMinutes));
				case "s":
				case "second":
					return Convert.ToInt32(Math.Truncate(asDateTime2.Subtract(asDateTime).TotalSeconds));
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue TO_LOCAL(BsonValue date)
		{
			if (date.IsDateTime)
			{
				return date.AsDateTime.ToLocalTime();
			}
			return BsonValue.Null;
		}

		public static BsonValue TO_UTC(BsonValue date)
		{
			if (date.IsDateTime)
			{
				return date.AsDateTime.ToUniversalTime();
			}
			return BsonValue.Null;
		}

		public static BsonValue ABS(BsonValue value)
		{
			return value.Type switch
			{
				BsonType.Int32 => Math.Abs(value.AsInt32), 
				BsonType.Int64 => Math.Abs(value.AsInt64), 
				BsonType.Double => Math.Abs(value.AsDouble), 
				BsonType.Decimal => Math.Abs(value.AsDecimal), 
				_ => BsonValue.Null, 
			};
		}

		public static BsonValue ROUND(BsonValue value, BsonValue digits)
		{
			if (digits.IsNumber)
			{
				switch (value.Type)
				{
				case BsonType.Int32:
					return value.AsInt32;
				case BsonType.Int64:
					return value.AsInt64;
				case BsonType.Double:
					return Math.Round(value.AsDouble, digits.AsInt32);
				case BsonType.Decimal:
					return Math.Round(value.AsDecimal, digits.AsInt32);
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue POW(BsonValue x, BsonValue y)
		{
			if (x.IsNumber && y.IsNumber)
			{
				return Math.Pow(x.AsDouble, y.AsDouble);
			}
			return BsonValue.Null;
		}

		public static BsonValue JSON(BsonValue json)
		{
			if (json.IsString)
			{
				BsonValue result = null;
				bool flag = false;
				try
				{
					result = JsonSerializer.Deserialize(json.AsString);
					flag = true;
				}
				catch (LiteException ex) when (ex.ErrorCode == 203)
				{
				}
				if (flag)
				{
					return result;
				}
			}
			return BsonValue.Null;
		}

		public static BsonValue EXTEND(BsonValue source, BsonValue extend)
		{
			if (source.IsDocument && extend.IsDocument)
			{
				BsonDocument bsonDocument = new BsonDocument();
				source.AsDocument.CopyTo(bsonDocument);
				extend.AsDocument.CopyTo(bsonDocument);
				bsonDocument.RawId = source.AsDocument.RawId;
				return bsonDocument;
			}
			if (source.IsDocument)
			{
				return source;
			}
			if (extend.IsDocument)
			{
				return extend;
			}
			return new BsonDocument();
		}

		[IteratorStateMachine(typeof(<ITEMS>d__77))]
		public static IEnumerable<BsonValue> ITEMS(BsonValue array)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ITEMS>d__77(-2)
			{
				<>3__array = array
			};
		}

		public static IEnumerable<BsonValue> CONCAT(IEnumerable<BsonValue> first, IEnumerable<BsonValue> second)
		{
			return first.Concat(second);
		}

		[IteratorStateMachine(typeof(<KEYS>d__79))]
		public static IEnumerable<BsonValue> KEYS(BsonValue document)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <KEYS>d__79(-2)
			{
				<>3__document = document
			};
		}

		[IteratorStateMachine(typeof(<VALUES>d__80))]
		public static IEnumerable<BsonValue> VALUES(BsonValue document)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <VALUES>d__80(-2)
			{
				<>3__document = document
			};
		}

		public static BsonValue OID_CREATIONTIME(BsonValue objectId)
		{
			if (objectId.IsObjectId)
			{
				return objectId.AsObjectId.CreationTime;
			}
			return BsonValue.Null;
		}

		public static BsonValue IIF(BsonValue test, BsonValue ifTrue, BsonValue ifFalse)
		{
			throw new NotImplementedException();
		}

		public static BsonValue COALESCE(BsonValue left, BsonValue right)
		{
			if (!left.IsNull)
			{
				return left;
			}
			return right;
		}

		public static BsonValue LENGTH(BsonValue value)
		{
			if (value.IsString)
			{
				return value.AsString.Length;
			}
			if (value.IsBinary)
			{
				return value.AsBinary.Length;
			}
			if (value.IsArray)
			{
				return value.AsArray.Count;
			}
			if (value.IsDocument)
			{
				return value.AsDocument.Keys.Count;
			}
			if (value.IsNull)
			{
				return 0;
			}
			return BsonValue.Null;
		}

		public static IEnumerable<BsonValue> TOP(IEnumerable<BsonValue> values, BsonValue num)
		{
			if (num.IsInt32 || num.IsInt64)
			{
				int asInt = num.AsInt32;
				if (asInt > 0)
				{
					return values.Take(asInt);
				}
			}
			return Enumerable.Empty<BsonValue>();
		}

		public static IEnumerable<BsonValue> UNION(IEnumerable<BsonValue> left, IEnumerable<BsonValue> right)
		{
			return left.Union(right);
		}

		public static IEnumerable<BsonValue> EXCEPT(IEnumerable<BsonValue> left, IEnumerable<BsonValue> right)
		{
			return left.Except(right);
		}

		public static IEnumerable<BsonValue> DISTINCT(IEnumerable<BsonValue> items)
		{
			return items.Distinct();
		}

		[Volatile]
		public static BsonValue RANDOM()
		{
			return _random.Next();
		}

		[Volatile]
		public static BsonValue RANDOM(BsonValue min, BsonValue max)
		{
			if (min.IsNumber && max.IsNumber)
			{
				return _random.Next(min.AsInt32, max.AsInt32);
			}
			return BsonValue.Null;
		}

		public static BsonValue LOWER(BsonValue value)
		{
			if (value.IsString)
			{
				return value.AsString.ToLowerInvariant();
			}
			return BsonValue.Null;
		}

		public static BsonValue UPPER(BsonValue value)
		{
			if (value.IsString)
			{
				return value.AsString.ToUpperInvariant();
			}
			return BsonValue.Null;
		}

		public static BsonValue LTRIM(BsonValue value)
		{
			if (value.IsString)
			{
				return value.AsString.TrimStart(Array.Empty<char>());
			}
			return BsonValue.Null;
		}

		public static BsonValue RTRIM(BsonValue value)
		{
			if (value.IsString)
			{
				return value.AsString.TrimEnd(Array.Empty<char>());
			}
			return BsonValue.Null;
		}

		public static BsonValue TRIM(BsonValue value)
		{
			if (value.IsString)
			{
				return value.AsString.Trim();
			}
			return BsonValue.Null;
		}

		public static BsonValue INDEXOF(BsonValue value, BsonValue search)
		{
			if (value.IsString && search.IsString)
			{
				return value.AsString.IndexOf(search.AsString);
			}
			return BsonValue.Null;
		}

		public static BsonValue INDEXOF(BsonValue value, BsonValue search, BsonValue startIndex)
		{
			if (value.IsString && search.IsString && startIndex.IsNumber)
			{
				return value.AsString.IndexOf(search.AsString, startIndex.AsInt32);
			}
			return BsonValue.Null;
		}

		public static BsonValue SUBSTRING(BsonValue value, BsonValue startIndex)
		{
			if (value.IsString && startIndex.IsNumber)
			{
				return value.AsString.Substring(startIndex.AsInt32);
			}
			return BsonValue.Null;
		}

		public static BsonValue SUBSTRING(BsonValue value, BsonValue startIndex, BsonValue length)
		{
			if (value.IsString && startIndex.IsNumber && length.IsNumber)
			{
				return value.AsString.Substring(startIndex.AsInt32, length.AsInt32);
			}
			return BsonValue.Null;
		}

		public static BsonValue REPLACE(BsonValue value, BsonValue oldValue, BsonValue newValue)
		{
			if (value.IsString && oldValue.IsString && newValue.IsString)
			{
				return value.AsString.Replace(oldValue.AsString, newValue.AsString);
			}
			return BsonValue.Null;
		}

		public static BsonValue LPAD(BsonValue value, BsonValue totalWidth, BsonValue paddingChar)
		{
			if (value.IsString && totalWidth.IsNumber && paddingChar.IsString)
			{
				string asString = paddingChar.AsString;
				if (string.IsNullOrEmpty(asString))
				{
					throw new ArgumentOutOfRangeException("paddingChar");
				}
				return value.AsString.PadLeft(totalWidth.AsInt32, asString[0]);
			}
			return BsonValue.Null;
		}

		public static BsonValue RPAD(BsonValue value, BsonValue totalWidth, BsonValue paddingChar)
		{
			if (value.IsString && totalWidth.IsNumber && paddingChar.IsString)
			{
				string asString = paddingChar.AsString;
				if (string.IsNullOrEmpty(asString))
				{
					throw new ArgumentOutOfRangeException("paddingChar");
				}
				return value.AsString.PadRight(totalWidth.AsInt32, asString[0]);
			}
			return BsonValue.Null;
		}

		[IteratorStateMachine(typeof(<SPLIT>d__104))]
		public static IEnumerable<BsonValue> SPLIT(BsonValue value, BsonValue separator)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SPLIT>d__104(-2)
			{
				<>3__value = value,
				<>3__separator = separator
			};
		}

		[IteratorStateMachine(typeof(<SPLIT>d__105))]
		public static IEnumerable<BsonValue> SPLIT(BsonValue value, BsonValue pattern, BsonValue useRegex)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SPLIT>d__105(-2)
			{
				<>3__value = value,
				<>3__pattern = pattern,
				<>3__useRegex = useRegex
			};
		}

		public static BsonValue FORMAT(BsonValue value, BsonValue format)
		{
			if (format.IsString)
			{
				return string.Format("{0:" + format.AsString + "}", value.RawValue);
			}
			return BsonValue.Null;
		}

		public static BsonValue JOIN(IEnumerable<BsonValue> values)
		{
			return JOIN(values, "");
		}

		public static BsonValue JOIN(IEnumerable<BsonValue> values, BsonValue separator)
		{
			if (separator.IsString)
			{
				return string.Join(separator.AsString, values.Select((BsonValue x) => STRING(x).AsString).ToArray());
			}
			return BsonValue.Null;
		}

		public static BsonValue IS_MATCH(BsonValue value, BsonValue pattern)
		{
			if (!value.IsString || !pattern.IsString)
			{
				return false;
			}
			return Regex.IsMatch(value.AsString, pattern.AsString);
		}

		public static BsonValue MATCH(BsonValue value, BsonValue pattern, BsonValue group)
		{
			if (!value.IsString || !pattern.IsString)
			{
				return null;
			}
			Match match = Regex.Match(value.AsString, pattern.AsString);
			if (!match.Success)
			{
				return BsonValue.Null;
			}
			if (group.IsNumber)
			{
				return match.Groups[group.AsInt32].Value;
			}
			if (group.IsString)
			{
				return match.Groups[group.AsString].Value;
			}
			return BsonValue.Null;
		}

		public static BsonValue VECTOR_SIM(BsonValue left, BsonValue right)
		{
			if ((!left.IsArray && left.Type != BsonType.Vector) || (!right.IsArray && right.Type != BsonType.Vector))
			{
				return BsonValue.Null;
			}
			BsonArray bsonArray = (left.IsArray ? left.AsArray : new BsonArray(((IEnumerable<float>)left.AsVector).Select((Func<float, BsonValue>)((float x) => x))));
			float[] array = (right.IsVector ? right.AsVector : right.AsArray.Select(delegate(BsonValue x)
			{
				try
				{
					return (float)x.AsDouble;
				}
				catch
				{
					return float.NaN;
				}
			}).ToArray());
			if (bsonArray.Count != array.Length)
			{
				return BsonValue.Null;
			}
			double num = 0.0;
			double num2 = 0.0;
			double num3 = 0.0;
			for (int i = 0; i < array.Length; i++)
			{
				double asDouble;
				try
				{
					asDouble = bsonArray[i].AsDouble;
				}
				catch
				{
					return BsonValue.Null;
				}
				double num4 = array[i];
				if (double.IsNaN(num4))
				{
					return BsonValue.Null;
				}
				num += asDouble * num4;
				num2 += asDouble * asDouble;
				num3 += num4 * num4;
			}
			if (num2 == 0.0 || num3 == 0.0)
			{
				return BsonValue.Null;
			}
			double num5 = 1.0 - num / (Math.Sqrt(num2) * Math.Sqrt(num3));
			if (!double.IsNaN(num5))
			{
				return num5;
			}
			return BsonValue.Null;
		}
	}
	internal class VolatileAttribute : Attribute
	{
	}
	internal class BsonExpressionFunctions
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass2_0
		{
			public IEnumerable<BsonValue> input;

			public BsonExpression sortExpr;

			public BsonDocument root;

			public Collation collation;
		}

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

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<BsonValue> input;

			public IEnumerable<BsonValue> <>3__input;

			private BsonExpression filterExpr;

			public BsonExpression <>3__filterExpr;

			private BsonDocument root;

			public BsonDocument <>3__root;

			private Collation collation;

			public Collation <>3__collation;

			private IEnumerator<BsonValue> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <FILTER>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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = input.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						BsonValue current = <>7__wrap1.Current;
						BsonValue bsonValue = filterExpr.ExecuteScalar(new BsonDocument[1] { root }, root, current, collation);
						if (bsonValue.IsBoolean && bsonValue.AsBoolean)
						{
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<FILTER>d__1 <FILTER>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FILTER>d__ = this;
				}
				else
				{
					<FILTER>d__ = new <FILTER>d__1(0);
				}
				<FILTER>d__.root = <>3__root;
				<FILTER>d__.collation = <>3__collation;
				<FILTER>d__.input = <>3__input;
				<FILTER>d__.filterExpr = <>3__filterExpr;
				return <FILTER>d__;
			}

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

		[CompilerGenerated]
		private sealed class <MAP>d__0 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<BsonValue> input;

			public IEnumerable<BsonValue> <>3__input;

			private BsonExpression mapExpr;

			public BsonExpression <>3__mapExpr;

			private BsonDocument root;

			public BsonDocument <>3__root;

			private Collation collation;

			public Collation <>3__collation;

			private IEnumerator<BsonValue> <>7__wrap1;

			private IEnumerator<BsonValue> <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_00af;
					}
					<>1__state = -1;
					<>7__wrap1 = input.GetEnumerator();
					<>1__state = -3;
					goto IL_00c9;
					IL_00af:
					if (<>7__wrap2.MoveNext())
					{
						BsonValue current = <>7__wrap2.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>7__wrap2 = null;
					goto IL_00c9;
					IL_00c9:
					if (<>7__wrap1.MoveNext())
					{
						BsonValue current2 = <>7__wrap1.Current;
						IEnumerable<BsonValue> enumerable = mapExpr.Execute(new BsonDocument[1] { root }, root, current2, collation);
						<>7__wrap2 = enumerable.GetEnumerator();
						<>1__state = -4;
						goto IL_00af;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<MAP>d__0 <MAP>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<MAP>d__ = this;
				}
				else
				{
					<MAP>d__ = new <MAP>d__0(0);
				}
				<MAP>d__.root = <>3__root;
				<MAP>d__.collation = <>3__collation;
				<MAP>d__.input = <>3__input;
				<MAP>d__.mapExpr = <>3__mapExpr;
				return <MAP>d__;
			}

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

		[IteratorStateMachine(typeof(<MAP>d__0))]
		public static IEnumerable<BsonValue> MAP(BsonDocument root, Collation collation, BsonDocument parameters, IEnumerable<BsonValue> input, BsonExpression mapExpr)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MAP>d__0(-2)
			{
				<>3__root = root,
				<>3__collation = collation,
				<>3__input = input,
				<>3__mapExpr = mapExpr
			};
		}

		[IteratorStateMachine(typeof(<FILTER>d__1))]
		public static IEnumerable<BsonValue> FILTER(BsonDocument root, Collation collation, BsonDocument parameters, IEnumerable<BsonValue> input, BsonExpression filterExpr)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FILTER>d__1(-2)
			{
				<>3__root = root,
				<>3__collation = collation,
				<>3__input = input,
				<>3__filterExpr = filterExpr
			};
		}

		public static IEnumerable<BsonValue> SORT(BsonDocument root, Collation collation, BsonDocument parameters, IEnumerable<BsonValue> input, BsonExpression sortExpr, BsonValue order)
		{
			<>c__DisplayClass2_0 CS$<>8__locals0 = new <>c__DisplayClass2_0();
			CS$<>8__locals0.input = input;
			CS$<>8__locals0.sortExpr = sortExpr;
			CS$<>8__locals0.root = root;
			CS$<>8__locals0.collation = collation;
			if ((!order.IsInt32 || order.AsInt32 <= 0) && (!order.IsString || !order.AsString.Equals("asc", StringComparison.OrdinalIgnoreCase)))
			{
				return from x in source().OrderByDescending((Tuple<BsonValue, BsonValue> x) => x.Item2, CS$<>8__locals0.collation)
					select x.Item1;
			}
			return from x in source().OrderBy((Tuple<BsonValue, BsonValue> x) => x.Item2, CS$<>8__locals0.collation)
				select x.Item1;
			[IteratorStateMachine(typeof(<>c__DisplayClass2_0.<<SORT>g__source|0>d))]
			IEnumerable<Tuple<BsonValue, BsonValue>> source()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass2_0.<<SORT>g__source|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		public static IEnumerable<BsonValue> SORT(BsonDocument root, Collation collation, BsonDocument parameters, IEnumerable<BsonValue> input, BsonExpression sortExpr)
		{
			return SORT(root, collation, parameters, input, sortExpr, 1);
		}

		public static BsonValue VECTOR_SIM(BsonDocument root, Collation collation, BsonDocument parameters, BsonValue left, BsonValue right)
		{
			return BsonExpressionMethods.VECTOR_SIM(left, right);
		}
	}
	internal class BsonExpressionOperators
	{
		[CompilerGenerated]
		private sealed class <ARRAY_FILTER>d__36 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			private BsonValue value;

			public BsonValue <>3__value;

			private int index;

			public int <>3__index;

			private BsonExpression filterExpr;

			public BsonExpression <>3__filterExpr;

			private BsonDocument root;

			public BsonDocument <>3__root;

			private Collation collation;

			public Collation <>3__collation;

			private IEnumerator<BsonValue> <>7__wrap1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if (!value.IsArray)
						{
							return false;
						}
						BsonArray asArray = value.AsArray;
						if (index == int.MaxValue)
						{
							<>7__wrap1 = asArray.GetEnumerator();
							<>1__state = -3;
							goto IL_0093;
						}
						<>7__wrap1 = asArray.GetEnumerator();
						<>1__state = -4;
						goto IL_012c;
					}
					case 1:
						<>1__state = -3;
						goto IL_0093;
					case 2:
						{
							<>1__state = -4;
							goto IL_012c;
						}
						IL_0093:
						if (<>7__wrap1.MoveNext())
						{
							BsonValue current = <>7__wrap1.Current;
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						break;
						IL_012c:
						while (<>7__wrap1.MoveNext())
						{
							BsonValue current2 = <>7__wrap1.Current;
							BsonValue bsonValue = filterExpr.ExecuteScalar(new BsonDocument[1] { root }, root, current2, collation);
							if (bsonValue.IsBoolean && bsonValue.AsBoolean)
							{
								<>2__current = current2;
								<>1__state = 2;
								return true;
							}
						}
						<>m__Finally2();
						<>7__wrap1 = null;
						break;
					}
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<ARRAY_FILTER>d__36 <ARRAY_FILTER>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ARRAY_FILTER>d__ = this;
				}
				else
				{
					<ARRAY_FILTER>d__ = new <ARRAY_FILTER>d__36(0);
				}
				<ARRAY_FILTER>d__.value = <>3__value;
				<ARRAY_FILTER>d__.index = <>3__index;
				<ARRAY_FILTER>d__.filterExpr = <>3__filterExpr;
				<ARRAY_FILTER>d__.root = <>3__root;
				<ARRAY_FILTER>d__.collation = <>3__collation;
				return <ARRAY_FILTER>d__;
			}

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

		public static BsonValue ADD(BsonValue left, BsonValue right)
		{
			if (left.IsString && right.IsString)
			{
				return left.AsString + right.AsString;
			}
			if (left.IsString || right.IsString)
			{
				return BsonExpressionMethods.STRING(left).AsString + BsonExpressionMethods.STRING(right).AsString;
			}
			if (left.IsDateTime && right.IsNumber)
			{
				return left.AsDateTime.AddTicks(right.AsInt64);
			}
			if (left.IsNumber && right.IsDateTime)
			{
				return right.AsDateTime.AddTicks(left.AsInt64);
			}
			if (left.IsNumber && right.IsNumber)
			{
				return left + right;
			}
			return BsonValue.Null;
		}

		public static BsonValue MINUS(BsonValue left, BsonValue right)
		{
			if (left.IsDateTime && right.IsNumber)
			{
				return left.AsDateTime.AddTicks(-right.AsInt64);
			}
			if (left.IsNumber && right.IsDateTime)
			{
				return right.AsDateTime.AddTicks(-left.AsInt64);
			}
			if (left.IsNumber && right.IsNumber)
			{
				return left - right;
			}
			return BsonValue.Null;
		}

		public static BsonValue MULTIPLY(BsonValue left, BsonValue right)
		{
			if (left.IsNumber && right.IsNumber)
			{
				return left * right;
			}
			return BsonValue.Null;
		}

		public static BsonValue DIVIDE(BsonValue left, BsonValue right)
		{
			if (left.IsNumber && right.IsNumber)
			{
				return left / right;
			}
			return BsonValue.Null;
		}

		public static BsonValue MOD(BsonValue left, BsonValue right)
		{
			if (left.IsNumber && right.IsNumber)
			{
				return left % right;
			}
			return BsonValue.Null;
		}

		public static BsonValue EQ(Collation collation, BsonValue left, BsonValue right)
		{
			return collation.Equals(left, right);
		}

		public static BsonValue EQ_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => collation.Equals(x, right));
		}

		public static BsonValue EQ_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => collation.Equals(x, right));
		}

		public static BsonValue GT(BsonValue left, BsonValue right)
		{
			return left > right;
		}

		public static BsonValue GT_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => collation.Compare(x, right) > 0);
		}

		public static BsonValue GT_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => collation.Compare(x, right) > 0);
		}

		public static BsonValue GTE(BsonValue left, BsonValue right)
		{
			return left >= right;
		}

		public static BsonValue GTE_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => collation.Compare(x, right) >= 0);
		}

		public static BsonValue GTE_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => collation.Compare(x, right) >= 0);
		}

		public static BsonValue LT(BsonValue left, BsonValue right)
		{
			return left < right;
		}

		public static BsonValue LT_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => collation.Compare(x, right) < 0);
		}

		public static BsonValue LT_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => collation.Compare(x, right) < 0);
		}

		public static BsonValue LTE(Collation collation, BsonValue left, BsonValue right)
		{
			return left <= right;
		}

		public static BsonValue LTE_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => collation.Compare(x, right) <= 0);
		}

		public static BsonValue LTE_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => collation.Compare(x, right) <= 0);
		}

		public static BsonValue NEQ(Collation collation, BsonValue left, BsonValue right)
		{
			return !collation.Equals(left, right);
		}

		public static BsonValue NEQ_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => !collation.Equals(x, right));
		}

		public static BsonValue NEQ_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => !collation.Equals(x, right));
		}

		public static BsonValue LIKE(Collation collation, BsonValue left, BsonValue right)
		{
			if (left.IsString && right.IsString)
			{
				return left.AsString.SqlLike(right.AsString, collation);
			}
			return false;
		}

		public static BsonValue LIKE_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => LIKE(collation, x, right));
		}

		public static BsonValue LIKE_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => LIKE(collation, x, right));
		}

		public static BsonValue BETWEEN(Collation collation, BsonValue left, BsonValue right)
		{
			if (!right.IsArray)
			{
				throw new InvalidOperationException("BETWEEN expression need an array with 2 values");
			}
			BsonArray asArray = right.AsArray;
			if (asArray.Count != 2)
			{
				throw new InvalidOperationException("BETWEEN expression need an array with 2 values");
			}
			BsonValue rigth = asArray[0];
			BsonValue rigth2 = asArray[1];
			return collation.Compare(left, rigth) >= 0 && collation.Compare(left, rigth2) <= 0;
		}

		public static BsonValue BETWEEN_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => BETWEEN(collation, x, right));
		}

		public static BsonValue BETWEEN_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => BETWEEN(collation, x, right));
		}

		public static BsonValue IN(Collation collation, BsonValue left, BsonValue right)
		{
			if (right.IsArray)
			{
				return right.AsArray.Contains(left, collation);
			}
			return collation.Equals(left, right);
		}

		public static BsonValue VECTOR_SIM(BsonValue left, BsonValue right)
		{
			return BsonExpressionMethods.VECTOR_SIM(left, right);
		}

		public static BsonValue IN_ANY(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.Any((BsonValue x) => IN(collation, x, right));
		}

		public static BsonValue IN_ALL(Collation collation, IEnumerable<BsonValue> left, BsonValue right)
		{
			return left.All((BsonValue x) => IN(collation, x, right));
		}

		public static BsonValue PARAMETER_PATH(BsonDocument doc, string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return doc;
			}
			if (doc.TryGetValue(name, out var value))
			{
				return value;
			}
			return BsonValue.Null;
		}

		public static BsonValue MEMBER_PATH(BsonValue value, string name)
		{
			if (value == null)
			{
				throw new LiteException(0, "Field '" + name + "' is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.");
			}
			if (string.IsNullOrEmpty(name))
			{
				return value;
			}
			if (value.IsDocument && value.AsDocument.TryGetValue(name, out var value2))
			{
				return value2;
			}
			return BsonValue.Null;
		}

		public static BsonValue ARRAY_INDEX(BsonValue value, int index, BsonExpression expr, BsonDocument root, Collation collation, BsonDocument parameters)
		{
			if (!value.IsArray)
			{
				return BsonValue.Null;
			}
			BsonArray asArray = value.AsArray;
			if (expr.Type == BsonExpressionType.Parameter)
			{
				BsonValue bsonValue = expr.ExecuteScalar(root, collation);
				if (!bsonValue.IsNumber)
				{
					throw new LiteException(0, "Parameter expression must return number when called inside an array");
				}
				index = bsonValue.AsInt32;
			}
			int num = ((index < 0) ? (asArray.Count + index) : index);
			if (asArray.Count > num)
			{
				return asArray[num];
			}
			return BsonValue.Null;
		}

		[IteratorStateMachine(typeof(<ARRAY_FILTER>d__36))]
		public static IEnumerable<BsonValue> ARRAY_FILTER(BsonValue value, int index, BsonExpression filterExpr, BsonDocument root, Collation collation, BsonDocument parameters)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ARRAY_FILTER>d__36(-2)
			{
				<>3__value = value,
				<>3__index = index,
				<>3__filterExpr = filterExpr,
				<>3__root = root,
				<>3__collation = collation
			};
		}

		public static BsonValue DOCUMENT_INIT(string[] keys, BsonValue[] values)
		{
			Constants.ENSURE(keys.Length == values.Length, "both keys/value must contains same length");
			if (keys.Length == 1 && keys[0][0] == '$' && values[0].IsString)
			{
				switch (keys[0])
				{
				case "$binary":
					return BsonExpressionMethods.BINARY(values[0]);
				case "$oid":
					return BsonExpressionMethods.OBJECTID(values[0]);
				case "$guid":
					return BsonExpressionMethods.GUID(values[0]);
				case "$date":
					return BsonExpressionMethods.DATE(Collation.Binary, values[0]);
				case "$numberLong":
					return BsonExpressionMethods.LONG(values[0]);
				case "$numberDecimal":
					return BsonExpressionMethods.DECIMAL(Collation.Binary, values[0]);
				case "$minValue":
					return BsonExpressionMethods.MINVALUE();
				case "$maxValue":
					return BsonExpressionMethods.MAXVALUE();
				}
			}
			BsonDocument bsonDocument = new BsonDocument();
			for (int i = 0; i < keys.Length; i++)
			{
				bsonDocument[keys[i]] = values[i];
			}
			return bsonDocument;
		}

		public static BsonValue ARRAY_INIT(BsonValue[] values)
		{
			return new BsonArray(values);
		}
	}
	internal enum BsonExpressionParserMode
	{
		Full,
		Single,
		SelectDocument,
		UpdateDocument
	}
	internal class BsonExpressionParser
	{
		private static readonly Dictionary<string, Tuple<string, MethodInfo, BsonExpressionType>> _operators = new Dictionary<string, Tuple<string, MethodInfo, BsonExpressionType>>
		{
			["%"] = Tuple.Create("%", M("MOD"), BsonExpressionType.Modulo),
			["/"] = Tuple.Create("/", M("DIVIDE"), BsonExpressionType.Divide),
			["*"] = Tuple.Create("*", M("MULTIPLY"), BsonExpressionType.Multiply),
			["+"] = Tuple.Create("+", M("ADD"), BsonExpressionType.Add),
			["-"] = Tuple.Create("-", M("MINUS"), BsonExpressionType.Subtract),
			["VECTOR_SIM"] = Tuple.Create(" VECTOR_SIM ", M("VECTOR_SIM"), BsonExpressionType.VectorSim),
			["LIKE"] = Tuple.Create(" LIKE ", M("LIKE"), BsonExpressionType.Like),
			["BETWEEN"] = Tuple.Create(" BETWEEN ", M("BETWEEN"), BsonExpressionType.Between),
			["IN"] = Tuple.Create(" IN ", M("IN"), BsonExpressionType.In),
			[">"] = Tuple.Create(">", M("GT"), BsonExpressionType.GreaterThan),
			[">="] = Tuple.Create(">=", M("GTE"), BsonExpressionType.GreaterThanOrEqual),
			["<"] = Tuple.Create("<", M("LT"), BsonExpressionType.LessThan),
			["<="] = Tuple.Create("<=", M("LTE"), BsonExpressionType.LessThanOrEqual),
			["!="] = Tuple.Create("!=", M("NEQ"), BsonExpressionType.NotEqual),
			["="] = Tuple.Create("=", M("EQ"), BsonExpressionType.Equal),
			["ANY LIKE"] = Tuple.Create(" ANY LIKE ", M("LIKE_ANY"), BsonExpressionType.Like),
			["ANY BETWEEN"] = Tuple.Create(" ANY BETWEEN ", M("BETWEEN_ANY"), BsonExpressionType.Between),
			["ANY IN"] = Tuple.Create(" ANY IN ", M("IN_ANY"), BsonExpressionType.In),
			["ANY >"] = Tuple.Create(" ANY>", M("GT_ANY"), BsonExpressionType.GreaterThan),
			["ANY >="] = Tuple.Create(" ANY>=", M("GTE_ANY"), BsonExpressionType.GreaterThanOrEqual),
			["ANY <"] = Tuple.Create(" ANY<", M("LT_ANY"), BsonExpressionType.LessThan),
			["ANY <="] = Tuple.Create(" ANY<=", M("LTE_ANY"), BsonExpressionType.LessThanOrEqual),
			["ANY !="] = Tuple.Create(" ANY!=", M("NEQ_ANY"), BsonExpressionType.NotEqual),
			["ANY ="] = Tuple.Create(" ANY=", M("EQ_ANY"), BsonExpressionType.Equal),
			["ALL LIKE"] = Tuple.Create(" ALL LIKE ", M("LIKE_ALL"), BsonExpressionType.Like),
			["ALL BETWEEN"] = Tuple.Create(" ALL BETWEEN ", M("BETWEEN_ALL"), BsonExpressionType.Between),
			["ALL IN"] = Tuple.Create(" ALL IN ", M("IN_ALL"), BsonExpressionType.In),
			["ALL >"] = Tuple.Create(" ALL>", M("GT_ALL"), BsonExpressionType.GreaterThan),
			["ALL >="] = Tuple.Create(" ALL>=", M("GTE_ALL"), BsonExpressionType.GreaterThanOrEqual),
			["ALL <"] = Tuple.Create(" ALL<", M("LT_ALL"), BsonExpressionType.LessThan),
			["ALL <="] = Tuple.Create(" ALL<=", M("LTE_ALL"), BsonExpressionType.LessThanOrEqual),
			["ALL !="] = Tuple.Create(" ALL!=", M("NEQ_ALL"), BsonExpressionType.NotEqual),
			["ALL ="] = Tuple.Create(" ALL=", M("EQ_ALL"), BsonExpressionType.Equal),
			["AND"] = Tuple.Create<string, MethodInfo, BsonExpressionType>(" AND ", null, BsonExpressionType.And),
			["OR"] = Tuple.Create<string, MethodInfo, BsonExpressionType>(" OR ", null, BsonExpressionType.Or)
		};

		private static readonly MethodInfo _parameterPathMethod = M("PARAMETER_PATH");

		private static readonly MethodInfo _memberPathMethod = M("MEMBER_PATH");

		private static readonly MethodInfo _arrayIndexMethod = M("ARRAY_INDEX");

		private static readonly MethodInfo _arrayFilterMethod = M("ARRAY_FILTER");

		private static readonly MethodInfo _documentInitMethod = M("DOCUMENT_INIT");

		private static readonly MethodInfo _arrayInitMethod = M("ARRAY_INIT");

		private static readonly MethodInfo _itemsMethod = typeof(BsonExpressionMethods).GetMethod("ITEMS");

		private static readonly MethodInfo _arrayMethod = typeof(BsonExpressionMethods).GetMethod("ARRAY");

		private static MethodInfo M(string s)
		{
			return typeof(BsonExpressionOperators).GetMethod(s);
		}

		public static BsonExpression ParseFullExpression(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			BsonExpression item = ParseSingleExpression(tokenizer, context, parameters, scope);
			List<BsonExpression> list = new List<BsonExpression> { item };
			List<string> list2 = new List<string>();
			while (!tokenizer.EOF)
			{
				string text = ReadOperant(tokenizer);
				if (text == null)
				{
					break;
				}
				BsonExpression bsonExpression = ParseSingleExpression(tokenizer, context, parameters, scope);
				if (text.EndsWith("BETWEEN", StringComparison.OrdinalIgnoreCase))
				{
					tokenizer.ReadToken().Expect("AND");
					BsonExpression item2 = ParseSingleExpression(tokenizer, context, parameters, scope);
					bsonExpression = NewArray(bsonExpression, item2);
				}
				list.Add(bsonExpression);
				list2.Add(text.ToUpperInvariant());
			}
			int num = 0;
			while (list.Count >= 2)
			{
				KeyValuePair<string, Tuple<string, MethodInfo, BsonExpressionType>> keyValuePair = _operators.ElementAt(num);
				int num2 = list2.IndexOf(keyValuePair.Key);
				if (num2 == -1)
				{
					num++;
					continue;
				}
				BsonExpression bsonExpression2 = list.ElementAt(num2);
				BsonExpression bsonExpression3 = list.ElementAt(num2 + 1);
				string item3 = keyValuePair.Value.Item1;
				MethodInfo item4 = keyValuePair.Value.Item2;
				BsonExpressionType item5 = keyValuePair.Value.Item3;
				int num3;
				if (!keyValuePair.Key.StartsWith("ALL"))
				{
					num3 = (keyValuePair.Key.StartsWith("ANY") ? 1 : 0);
					if (num3 == 0)
					{
						goto IL_0138;
					}
				}
				else
				{
					num3 = 1;
				}
				if (bsonExpression2.IsScalar)
				{
					bsonExpression2 = ConvertToEnumerable(bsonExpression2);
				}
				goto IL_0138;
				IL_0138:
				if (num3 == 0 && !bsonExpression2.IsScalar)
				{
					throw new LiteException(0, "Left expression `" + bsonExpression2.Source + "` returns more than one result. Try use ANY or ALL before operant.");
				}
				if (num3 == 0 && !bsonExpression3.IsScalar)
				{
					throw new LiteException(0, "Left expression `" + bsonExpression3.Source + "` must return a single value");
				}
				if (!bsonExpression3.IsScalar)
				{
					throw new LiteException(0, "Right expression `" + bsonExpression3.Source + "` must return a single value");
				}
				BsonExpression item6;
				if (item5 == BsonExpressionType.And || item5 == BsonExpressionType.Or)
				{
					item6 = CreateLogicExpression(item5, bsonExpression2, bsonExpression3);
				}
				else
				{
					List<Expression> list3 = new List<Expression>();
					if (item4?.GetParameters().FirstOrDefault()?.ParameterType == typeof(Collation))
					{
						list3.Add(context.Collation);
					}
					list3.Add(bsonExpression2.Expression);
					list3.Add(bsonExpression3.Expression);
					item6 = new BsonExpression
					{
						Type = item5,
						Parameters = parameters,
						IsImmutable = (bsonExpression2.IsImmutable && bsonExpression3.IsImmutable),
						UseSource = (bsonExpression2.UseSource || bsonExpression3.UseSource),
						IsScalar = true,
						Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(bsonExpression2.Fields).AddRange(bsonExpression3.Fields),
						Expression = Expression.Call(item4, list3.ToArray()),
						Left = bsonExpression2,
						Right = bsonExpression3,
						Source = bsonExpression2.Source + item3 + bsonExpression3.Source
					};
				}
				list.Insert(num2, item6);
				list.RemoveRange(num2 + 1, 2);
				list2.RemoveAt(num2);
			}
			return list.Single();
		}

		public static BsonExpression ParseSingleExpression(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			Token token = tokenizer.ReadToken();
			return TryParseDouble(tokenizer, parameters) ?? TryParseInt(tokenizer, parameters) ?? TryParseBool(tokenizer, parameters) ?? TryParseNull(tokenizer, parameters) ?? TryParseString(tokenizer, parameters) ?? TryParseSource(tokenizer, context, parameters, scope) ?? TryParseDocument(tokenizer, context, parameters, scope) ?? TryParseArray(tokenizer, context, parameters, scope) ?? TryParseParameter(tokenizer, context, parameters, scope) ?? TryParseInnerExpression(tokenizer, context, parameters, scope) ?? TryParseFunction(tokenizer, context, parameters, scope) ?? TryParseMethodCall(tokenizer, context, parameters, scope) ?? TryParsePath(tokenizer, context, parameters, scope) ?? throw LiteException.UnexpectedToken(token);
		}

		public static BsonExpression ParseSelectDocumentBuilder(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters)
		{
			List<KeyValuePair<string, BsonExpression>> fields = new List<KeyValuePair<string, BsonExpression>>();
			HashSet<string> names = new HashSet<string>();
			int counter = 1;
			while (true)
			{
				BsonExpression bsonExpression = ParseFullExpression(tokenizer, context, parameters, DocumentScope.Root);
				Token token = tokenizer.LookAhead();
				if (stop(token))
				{
					Add(bsonExpression.DefaultFieldName(), bsonExpression);
					break;
				}
				if (token.Type == TokenType.Comma)
				{
					tokenizer.ReadToken();
					Add(bsonExpression.DefaultFieldName(), bsonExpression);
					continue;
				}
				if (token.Is("AS"))
				{
					tokenizer.ReadToken();
				}
				Add(tokenizer.ReadToken().Expect(TokenType.Word).Value, bsonExpression);
				token = tokenizer.LookAhead();
				if (stop(token))
				{
					break;
				}
				tokenizer.ReadToken().Expect(TokenType.Comma);
			}
			BsonExpression value = fields[0].Value;
			if (fields.Count == 1)
			{
				if (value.Type == BsonExpressionType.Path && value.Source == "$")
				{
					return BsonExpression.Root;
				}
				if (fields.Count == 1 && value.Type == BsonExpressionType.Document)
				{
					return value;
				}
				if (fields.Count == 1 && value.Type == BsonExpressionType.Call && value.Source.StartsWith("EXTEND"))
				{
					return value;
				}
			}
			Type typeFromHandle = typeof(string);
			Expression[] initializers = fields.Select((KeyValuePair<string, BsonExpression> x) => Expression.Constant(x.Key)).ToArray();
			NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeFromHandle, initializers);
			NewArrayExpression newArrayExpression2 = Expression.NewArrayInit(typeof(BsonValue), fields.Select((KeyValuePair<string, BsonExpression> x) => x.Value.Expression).ToArray());
			BsonExpression bsonExpression2 = new BsonExpression();
			bsonExpression2.Type = BsonExpressionType.Document;
			bsonExpression2.Parameters = parameters;
			bsonExpression2.IsImmutable = fields.All((KeyValuePair<string, BsonExpression> x) => x.Value.IsImmutable);
			bsonExpression2.UseSource = fields.Any((KeyValuePair<string, BsonExpression> x) => x.Value.UseSource);
			bsonExpression2.IsScalar = true;
			bsonExpression2.Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(fields.SelectMany((KeyValuePair<string, BsonExpression> x) => x.Value.Fields));
			bsonExpression2.Expression = Expression.Call(_documentInitMethod, new Expression[2] { newArrayExpression, newArrayExpression2 });
			bsonExpression2.Source = "{" + string.Join(",", fields.Select((KeyValuePair<string, BsonExpression> x) => x.Key + ":" + x.Value.Source)) + "}";
			return bsonExpression2;
			void Add(string alias, BsonExpression expr)
			{
				if (names.Contains(alias))
				{
					alias += counter++;
				}
				names.Add(alias);
				if (!expr.IsScalar)
				{
					expr = ConvertToArray(expr);
				}
				fields.Add(new KeyValuePair<string, BsonExpression>(alias, expr));
			}
			static bool stop(Token t)
			{
				if (!t.Is("FROM") && !t.Is("INTO") && t.Type != TokenType.EOF)
				{
					return t.Type == TokenType.SemiColon;
				}
				return true;
			}
		}

		public static BsonExpression ParseUpdateDocumentBuilder(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters)
		{
			if (tokenizer.LookAhead().Type == TokenType.OpenBrace)
			{
				tokenizer.ReadToken();
				return TryParseDocument(tokenizer, context, parameters, DocumentScope.Root);
			}
			List<Expression> list = new List<Expression>();
			List<Expression> list2 = new List<Expression>();
			StringBuilder stringBuilder = new StringBuilder();
			bool isImmutable = true;
			bool useSource = false;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			stringBuilder.Append("{");
			while (!tokenizer.CheckEOF())
			{
				string value = ReadKey(tokenizer, stringBuilder);
				tokenizer.ReadToken().Expect(TokenType.Equals);
				stringBuilder.Append(":");
				BsonExpression bsonExpression = ParseFullExpression(tokenizer, context, parameters, DocumentScope.Root);
				if (!bsonExpression.IsScalar)
				{
					bsonExpression = ConvertToArray(bsonExpression);
				}
				if (!bsonExpression.IsImmutable)
				{
					isImmutable = false;
				}
				if (bsonExpression.UseSource)
				{
					useSource = true;
				}
				hashSet.AddRange(bsonExpression.Fields);
				list.Add(Expression.Constant(value));
				list2.Add(bsonExpression.Expression);
				stringBuilder.Append(bsonExpression.Source);
				if (tokenizer.LookAhead().Type != TokenType.Comma)
				{
					break;
				}
				stringBuilder.Append(tokenizer.ReadToken().Value);
			}
			stringBuilder.Append("}");
			NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(string), list.ToArray());
			NewArrayExpression newArrayExpression2 = Expression.NewArrayInit(typeof(BsonValue), list2.ToArray());
			MethodCallExpression expression = Expression.Call(_documentInitMethod, new Expression[2] { newArrayExpression, newArrayExpression2 });
			return new BsonExpression
			{
				Type = BsonExpressionType.Document,
				Parameters = parameters,
				IsImmutable = isImmutable,
				UseSource = useSource,
				IsScalar = true,
				Fields = hashSet,
				Expression = expression,
				Source = stringBuilder.ToString()
			};
		}

		private static BsonExpression TryParseDouble(Tokenizer tokenizer, BsonDocument parameters)
		{
			string text = null;
			if (tokenizer.Current.Type == TokenType.Double)
			{
				text = tokenizer.Current.Value;
			}
			else if (tokenizer.Current.Type == TokenType.Minus && tokenizer.LookAhead(eatWhitespace: false).Type == TokenType.Double)
			{
				text = "-" + tokenizer.ReadToken().Value;
			}
			if (text != null)
			{
				double value = Convert.ToDouble(text, CultureInfo.InvariantCulture.NumberFormat);
				ConstantExpression expression = Expression.Constant(new BsonValue(value));
				return new BsonExpression
				{
					Type = BsonExpressionType.Double,
					Parameters = parameters,
					IsImmutable = true,
					UseSource = false,
					IsScalar = true,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
					Expression = expression,
					Source = value.ToString("0.0########", CultureInfo.InvariantCulture.NumberFormat)
				};
			}
			return null;
		}

		private static BsonExpression TryParseInt(Tokenizer tokenizer, BsonDocument parameters)
		{
			string text = null;
			if (tokenizer.Current.Type == TokenType.Int)
			{
				text = tokenizer.Current.Value;
			}
			else if (tokenizer.Current.Type == TokenType.Minus && tokenizer.LookAhead(eatWhitespace: false).Type == TokenType.Int)
			{
				text = "-" + tokenizer.ReadToken().Value;
			}
			if (text != null)
			{
				if (int.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out var result))
				{
					ConstantExpression expression = Expression.Constant(new BsonValue(result));
					return new BsonExpression
					{
						Type = BsonExpressionType.Int,
						Parameters = parameters,
						IsImmutable = true,
						UseSource = false,
						IsScalar = true,
						Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
						Expression = expression,
						Source = result.ToString(CultureInfo.InvariantCulture.NumberFormat)
					};
				}
				long value = long.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat);
				ConstantExpression expression2 = Expression.Constant(new BsonValue(value));
				return new BsonExpression
				{
					Type = BsonExpressionType.Int,
					Parameters = parameters,
					IsImmutable = true,
					UseSource = false,
					IsScalar = true,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
					Expression = expression2,
					Source = value.ToString(CultureInfo.InvariantCulture.NumberFormat)
				};
			}
			return null;
		}

		private static BsonExpression TryParseBool(Tokenizer tokenizer, BsonDocument parameters)
		{
			if (tokenizer.Current.Type == TokenType.Word && (tokenizer.Current.Is("true") || tokenizer.Current.Is("false")))
			{
				bool value = Convert.ToBoolean(tokenizer.Current.Value);
				ConstantExpression expression = Expression.Constant(new BsonValue(value));
				return new BsonExpression
				{
					Type = BsonExpressionType.Boolean,
					Parameters = parameters,
					IsImmutable = true,
					UseSource = false,
					IsScalar = true,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
					Expression = expression,
					Source = value.ToString().ToLower()
				};
			}
			return null;
		}

		private static BsonExpression TryParseNull(Tokenizer tokenizer, BsonDocument parameters)
		{
			if (tokenizer.Current.Type == TokenType.Word && tokenizer.Current.Is("null"))
			{
				ConstantExpression expression = Expression.Constant(BsonValue.Null);
				return new BsonExpression
				{
					Type = BsonExpressionType.Null,
					Parameters = parameters,
					IsImmutable = true,
					UseSource = false,
					IsScalar = true,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
					Expression = expression,
					Source = "null"
				};
			}
			return null;
		}

		private static BsonExpression TryParseString(Tokenizer tokenizer, BsonDocument parameters)
		{
			if (tokenizer.Current.Type == TokenType.String)
			{
				BsonValue value = new BsonValue(tokenizer.Current.Value);
				ConstantExpression expression = Expression.Constant(value);
				return new BsonExpression
				{
					Type = BsonExpressionType.String,
					Parameters = parameters,
					IsImmutable = true,
					UseSource = false,
					IsScalar = true,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
					Expression = expression,
					Source = JsonSerializer.Serialize(value)
				};
			}
			return null;
		}

		private static BsonExpression TryParseDocument(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != 0)
			{
				return null;
			}
			List<Expression> list = new List<Expression>();
			List<Expression> list2 = new List<Expression>();
			StringBuilder stringBuilder = new StringBuilder();
			bool isImmutable = true;
			bool useSource = false;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			stringBuilder.Append("{");
			BsonExpression bsonExpression2;
			if (tokenizer.LookAhead().Type == TokenType.CloseBrace)
			{
				stringBuilder.Append(tokenizer.ReadToken().Value);
			}
			else
			{
				while (!tokenizer.CheckEOF())
				{
					StringBuilder stringBuilder2 = new StringBuilder();
					string text = ReadKey(tokenizer, stringBuilder2);
					stringBuilder.Append((object?)stringBuilder2);
					tokenizer.ReadToken();
					stringBuilder.Append(":");
					BsonExpression bsonExpression;
					if (tokenizer.Current.Type == TokenType.Colon)
					{
						bsonExpression = ParseFullExpression(tokenizer, context, parameters, scope);
						tokenizer.ReadToken();
					}
					else
					{
						string text2 = stringBuilder2.ToString();
						bsonExpression2 = new BsonExpression();
						bsonExpression2.Type = BsonExpressionType.Path;
						bsonExpression2.Parameters = parameters;
						bsonExpression2.IsImmutable = isImmutable;
						bsonExpression2.UseSource = useSource;
						bsonExpression2.IsScalar = true;
						bsonExpression2.Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(new string[1] { text });
						bsonExpression2.Expression = Expression.Call(_memberPathMethod, context.Root, Expression.Constant(text));
						bsonExpression2.Source = "$." + (text2.IsWord() ? text2 : ("[" + text2 + "]"));
						bsonExpression = bsonExpression2;
					}
					if (!bsonExpression.IsScalar)
					{
						bsonExpression = ConvertToArray(bsonExpression);
					}
					if (!bsonExpression.IsImmutable)
					{
						isImmutable = false;
					}
					if (bsonExpression.UseSource)
					{
						useSource = true;
					}
					hashSet.AddRange(bsonExpression.Fields);
					list.Add(Expression.Constant(text));
					list2.Add(bsonExpression.Expression);
					stringBuilder.Append(bsonExpression.Source);
					tokenizer.Current.Expect(TokenType.Comma, TokenType.CloseBrace);
					stringBuilder.Append(tokenizer.Current.Value);
					if (tokenizer.Current.Type != TokenType.Comma)
					{
						break;
					}
				}
			}
			NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(string), list.ToArray());
			NewArrayExpression newArrayExpression2 = Expression.NewArrayInit(typeof(BsonValue), list2.ToArray());
			bsonExpression2 = new BsonExpression();
			bsonExpression2.Type = BsonExpressionType.Document;
			bsonExpression2.Parameters = parameters;
			bsonExpression2.IsImmutable = isImmutable;
			bsonExpression2.UseSource = useSource;
			bsonExpression2.IsScalar = true;
			bsonExpression2.Fields = hashSet;
			bsonExpression2.Expression = Expression.Call(_documentInitMethod, new Expression[2] { newArrayExpression, newArrayExpression2 });
			bsonExpression2.Source = stringBuilder.ToString();
			return bsonExpression2;
		}

		private static BsonExpression TryParseSource(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != TokenType.Asterisk)
			{
				return null;
			}
			BsonExpression bsonExpression = new BsonExpression
			{
				Type = BsonExpressionType.Source,
				Parameters = parameters,
				IsImmutable = true,
				UseSource = true,
				IsScalar = false,
				Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "$" },
				Expression = context.Source,
				Source = "*"
			};
			if (tokenizer.LookAhead(eatWhitespace: false).Type == TokenType.Period)
			{
				tokenizer.ReadToken();
				BsonExpression bsonExpression2 = BsonExpression.ParseAndCompile(tokenizer, BsonExpressionParserMode.Single, parameters, DocumentScope.Source);
				if (bsonExpression2 == null)
				{
					throw LiteException.UnexpectedToken(tokenizer.Current);
				}
				return new BsonExpression
				{
					Type = BsonExpressionType.Map,
					Parameters = parameters,
					IsImmutable = bsonExpression2.IsImmutable,
					UseSource = true,
					IsScalar = false,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(bsonExpression2.Fields),
					Expression = Expression.Call(BsonExpression.GetFunction("MAP"), context.Root, context.Collation, context.Parameters, bsonExpression.Expression, Expression.Constant(bsonExpression2)),
					Source = "MAP(*=>" + bsonExpression2.Source + ")"
				};
			}
			return bsonExpression;
		}

		private static BsonExpression TryParseArray(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != TokenType.OpenBracket)
			{
				return null;
			}
			List<Expression> list = new List<Expression>();
			StringBuilder stringBuilder = new StringBuilder();
			bool isImmutable = true;
			bool useSource = false;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			stringBuilder.Append("[");
			if (tokenizer.LookAhead().Type == TokenType.CloseBracket)
			{
				stringBuilder.Append(tokenizer.ReadToken().Value);
			}
			else
			{
				while (!tokenizer.CheckEOF())
				{
					BsonExpression bsonExpression = ParseFullExpression(tokenizer, context, parameters, scope);
					if (!bsonExpression.IsScalar)
					{
						bsonExpression = ConvertToArray(bsonExpression);
					}
					stringBuilder.Append(bsonExpression.Source);
					if (!bsonExpression.IsImmutable)
					{
						isImmutable = false;
					}
					if (bsonExpression.UseSource)
					{
						useSource = true;
					}
					hashSet.AddRange(bsonExpression.Fields);
					list.Add(bsonExpression.Expression);
					Token token = tokenizer.ReadToken().Expect(TokenType.Comma, TokenType.CloseBracket);
					stringBuilder.Append(token.Value);
					if (token.Type != TokenType.Comma)
					{
						break;
					}
				}
			}
			NewArrayExpression arg = Expression.NewArrayInit(typeof(BsonValue), list.ToArray());
			return new BsonExpression
			{
				Type = BsonExpressionType.Array,
				Parameters = parameters,
				IsImmutable = isImmutable,
				UseSource = useSource,
				IsScalar = true,
				Fields = hashSet,
				Expression = Expression.Call(_arrayInitMethod, arg),
				Source = stringBuilder.ToString()
			};
		}

		private static BsonExpression TryParseParameter(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != TokenType.At)
			{
				return null;
			}
			Token token = tokenizer.LookAhead(eatWhitespace: false);
			if (token.Type == TokenType.Word || token.Type == TokenType.Int)
			{
				string value = tokenizer.ReadToken(eatWhitespace: false).Value;
				ConstantExpression arg = Expression.Constant(value);
				return new BsonExpression
				{
					Type = BsonExpressionType.Parameter,
					Parameters = parameters,
					IsImmutable = false,
					UseSource = false,
					IsScalar = true,
					Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase),
					Expression = Expression.Call(_parameterPathMethod, context.Parameters, arg),
					Source = "@" + value
				};
			}
			return null;
		}

		private static BsonExpression TryParseInnerExpression(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != TokenType.OpenParenthesis)
			{
				return null;
			}
			BsonExpression bsonExpression = ParseFullExpression(tokenizer, context, parameters, scope);
			tokenizer.ReadToken().Expect(TokenType.CloseParenthesis);
			return new BsonExpression
			{
				Type = bsonExpression.Type,
				Parameters = bsonExpression.Parameters,
				IsImmutable = bsonExpression.IsImmutable,
				UseSource = bsonExpression.UseSource,
				IsScalar = bsonExpression.IsScalar,
				Fields = bsonExpression.Fields,
				Expression = bsonExpression.Expression,
				Left = bsonExpression.Left,
				Right = bsonExpression.Right,
				Source = "(" + bsonExpression.Source + ")"
			};
		}

		private static BsonExpression TryParseMethodCall(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			Token current = tokenizer.Current;
			if (tokenizer.Current.Type != TokenType.Word)
			{
				return null;
			}
			if (tokenizer.LookAhead().Type != TokenType.OpenParenthesis)
			{
				return null;
			}
			tokenizer.ReadToken();
			List<BsonExpression> list = new List<BsonExpression>();
			StringBuilder stringBuilder = new StringBuilder();
			bool isImmutable = true;
			bool useSource = false;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			stringBuilder.Append(current.Value.ToUpperInvariant() + "(");
			if (tokenizer.LookAhead().Type == TokenType.CloseParenthesis)
			{
				stringBuilder.Append(tokenizer.ReadToken().Value);
			}
			else
			{
				while (!tokenizer.CheckEOF())
				{
					BsonExpression bsonExpression = ParseFullExpression(tokenizer, context, parameters, scope);
					if (!bsonExpression.IsImmutable)
					{
						isImmutable = false;
					}
					if (bsonExpression.UseSource)
					{
						useSource = true;
					}
					hashSet.AddRange(bsonExpression.Fields);
					list.Add(bsonExpression);
					stringBuilder.Append(bsonExpression.Source);
					Token token = tokenizer.ReadToken().Expect(TokenType.Comma, TokenType.CloseParenthesis);
					stringBuilder.Append(token.Value);
					if (token.Type != TokenType.Comma)
					{
						break;
					}
				}
			}
			MethodInfo method = BsonExpression.GetMethod(current.Value, list.Count);
			if (method == null)
			{
				throw LiteException.UnexpectedToken("Method '" + current.Value.ToUpperInvariant() + "' does not exist or contains invalid parameters", current);
			}
			if (method.GetCustomAttribute<VolatileAttribute>() != null)
			{
				isImmutable = false;
			}
			List<Expression> list2 = new List<Expression>();
			if (method.GetParameters().FirstOrDefault()?.ParameterType == typeof(Collation))
			{
				list2.Add(context.Collation);
			}
			foreach (var item in (from x in method.GetParameters()
				where x.ParameterType != typeof(Collation)
				select x).Zip(list, (ParameterInfo parameter, BsonExpression expr) => new { parameter, expr }))
			{
				if (!item.parameter.ParameterType.IsEnumerable() && !item.expr.IsScalar)
				{
					list2.Add(ConvertToArray(item.expr).Expression);
				}
				else if (item.parameter.ParameterType.IsEnumerable() && item.expr.IsScalar)
				{
					list2.Add(ConvertToEnumerable(item.expr).Expression);
				}
				else
				{
					list2.Add(item.expr.Expression);
				}
			}
			if (method.Name == "IIF" && list.Count == 3)
			{
				return CreateConditionalExpression(list[0], list[1], list[2]);
			}
			return new BsonExpression
			{
				Type = BsonExpressionType.Call,
				Parameters = parameters,
				IsImmutable = isImmutable,
				UseSource = useSource,
				IsScalar = !method.ReturnType.IsEnumerable(),
				Fields = hashSet,
				Expression = Expression.Call(method, list2.ToArray()),
				Source = stringBuilder.ToString()
			};
		}

		private static BsonExpression TryParsePath(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != TokenType.At && tokenizer.Current.Type != TokenType.Dollar && tokenizer.Current.Type != TokenType.Word)
			{
				return null;
			}
			TokenType tokenType = ((scope == DocumentScope.Root) ? TokenType.Dollar : TokenType.At);
			if (tokenizer.Current.Type == TokenType.At || tokenizer.Current.Type == TokenType.Dollar)
			{
				tokenType = tokenizer.Current.Type;
				if (tokenizer.LookAhead(eatWhitespace: false).Type == TokenType.Period)
				{
					tokenizer.ReadToken();
					tokenizer.ReadToken();
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			bool isImmutable = true;
			bool useSource = false;
			bool isScalar = true;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			stringBuilder.Append((tokenType == TokenType.Dollar) ? "$" : "@");
			string text = ReadField(tokenizer, stringBuilder);
			ConstantExpression arg = Expression.Constant(text);
			Expression expression = Expression.Call(_memberPathMethod, (tokenType == TokenType.Dollar) ? context.Root : context.Current, arg);
			if (tokenType == TokenType.Dollar || scope == DocumentScope.Source)
			{
				hashSet.Add((text.Length == 0) ? "$" : text);
			}
			while (!tokenizer.EOF)
			{
				Expression expression2 = ParsePath(tokenizer, expression, context, parameters, hashSet, ref isImmutable, ref useSource, ref isScalar, stringBuilder);
				if (!isScalar)
				{
					expression = expression2;
					break;
				}
				if (expression2 == null)
				{
					break;
				}
				expression = expression2;
			}
			BsonExpression bsonExpression = new BsonExpression
			{
				Type = BsonExpressionType.Path,
				Parameters = parameters,
				IsImmutable = isImmutable,
				UseSource = useSource,
				IsScalar = isScalar,
				Fields = hashSet,
				Expression = expression,
				Source = stringBuilder.ToString()
			};
			if (!isScalar && tokenizer.LookAhead(eatWhitespace: false).Type == TokenType.Period)
			{
				tokenizer.ReadToken();
				BsonExpression bsonExpression2 = BsonExpression.ParseAndCompile(tokenizer, BsonExpressionParserMode.Single, parameters, DocumentScope.Current);
				if (bsonExpression2 == null)
				{
					throw LiteException.UnexpectedToken(tokenizer.Current);
				}
				BsonExpression bsonExpression3 = new BsonExpression();
				bsonExpression3.Type = BsonExpressionType.Map;
				bsonExpression3.Parameters = parameters;
				bsonExpression3.IsImmutable = bsonExpression.IsImmutable && bsonExpression2.IsImmutable;
				bsonExpression3.UseSource = bsonExpression.UseSource || bsonExpression2.UseSource;
				bsonExpression3.IsScalar = false;
				bsonExpression3.Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(bsonExpression.Fields).AddRange(bsonExpression2.Fields);
				bsonExpression3.Expression = Expression.Call(BsonExpression.GetFunction("MAP"), context.Root, context.Collation, context.Parameters, bsonExpression.Expression, Expression.Constant(bsonExpression2));
				bsonExpression3.Source = "MAP(" + bsonExpression.Source + "=>" + bsonExpression2.Source + ")";
				return bsonExpression3;
			}
			return bsonExpression;
		}

		private static Expression ParsePath(Tokenizer tokenizer, Expression expr, ExpressionContext context, BsonDocument parameters, HashSet<string> fields, ref bool isImmutable, ref bool useSource, ref bool isScalar, StringBuilder src)
		{
			Token token = tokenizer.LookAhead(eatWhitespace: false);
			if (token.Type == TokenType.Period)
			{
				tokenizer.ReadToken();
				tokenizer.ReadToken(eatWhitespace: false);
				ConstantExpression arg = Expression.Constant(ReadField(tokenizer, src));
				return Expression.Call(_memberPathMethod, expr, arg);
			}
			if (token.Type == TokenType.OpenBracket)
			{
				src.Append("[");
				tokenizer.ReadToken();
				token = tokenizer.LookAhead();
				int num = 0;
				BsonExpression bsonExpression = new BsonExpression();
				MethodInfo method = _arrayIndexMethod;
				if (token.Type == TokenType.Int)
				{
					src.Append(tokenizer.ReadToken().Value);
					num = Convert.ToInt32(tokenizer.Current.Value);
				}
				else if (token.Type == TokenType.Minus)
				{
					src.Append(tokenizer.ReadToken().Value + tokenizer.ReadToken().Expect(TokenType.Int).Value);
					num = -Convert.ToInt32(tokenizer.Current.Value);
				}
				else if (token.Type == TokenType.Asterisk)
				{
					method = _arrayFilterMethod;
					isScalar = false;
					num = int.MaxValue;
					src.Append(tokenizer.ReadToken().Value);
				}
				else
				{
					bsonExpression = BsonExpression.ParseAndCompile(tokenizer, BsonExpressionParserMode.Full, parameters, DocumentScope.Current);
					if (bsonExpression == null)
					{
						throw LiteException.UnexpectedToken(tokenizer.Current);
					}
					if (!bsonExpression.IsImmutable)
					{
						isImmutable = false;
					}
					if (bsonExpression.UseSource)
					{
						useSource = true;
					}
					if (bsonExpression.Type != BsonExpressionType.Parameter)
					{
						method = _arrayFilterMethod;
						isScalar = false;
					}
					fields.AddRange(bsonExpression.Fields);
					src.Append(bsonExpression.Source);
				}
				tokenizer.ReadToken().Expect(TokenType.CloseBracket);
				src.Append("]");
				return Expression.Call(method, expr, Expression.Constant(num), Expression.Constant(bsonExpression), context.Root, context.Collation, context.Parameters);
			}
			return null;
		}

		private static BsonExpression TryParseFunction(Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope)
		{
			if (tokenizer.Current.Type != TokenType.Word)
			{
				return null;
			}
			if (tokenizer.LookAhead().Type != TokenType.OpenParenthesis)
			{
				return null;
			}
			string text = tokenizer.Current.Value.ToUpperInvariant();
			return text switch
			{
				"MAP" => ParseFunction(text, BsonExpressionType.Map, tokenizer, context, parameters, scope), 
				"FILTER" => ParseFunction(text, BsonExpressionType.Filter, tokenizer, context, parameters, scope), 
				"SORT" => ParseFunction(text, BsonExpressionType.Sort, tokenizer, context, parameters, scope), 
				"VECTOR_SIM" => ParseFunction(text, BsonExpressionType.VectorSim, tokenizer, context, parameters, scope, convertScalarLeftToEnumerable: false, isScalarResult: true), 
				_ => null, 
			};
		}

		private static BsonExpression ParseFunction(string functionName, BsonExpressionType type, Tokenizer tokenizer, ExpressionContext context, BsonDocument parameters, DocumentScope scope, bool convertScalarLeftToEnumerable = true, bool isScalarResult = false)
		{
			if (tokenizer.LookAhead().Type != TokenType.OpenParenthesis)
			{
				return null;
			}
			tokenizer.ReadToken().Expect(TokenType.OpenParenthesis);
			BsonExpression bsonExpression = ParseSingleExpression(tokenizer, context, parameters, scope);
			if (convertScalarLeftToEnumerable && bsonExpression.IsScalar)
			{
				bsonExpression = ConvertToEnumerable(bsonExpression);
			}
			List<Expression> list = new List<Expression>();
			list.Add(context.Root);
			list.Add(context.Collation);
			list.Add(context.Parameters);
			StringBuilder stringBuilder = new StringBuilder(functionName + "(" + bsonExpression.Source);
			bool isImmutable = bsonExpression.IsImmutable;
			bool useSource = bsonExpression.UseSource;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			list.Add(bsonExpression.Expression);
			hashSet.AddRange(bsonExpression.Fields);
			if (tokenizer.LookAhead().Type == TokenType.Equals)
			{
				tokenizer.ReadToken().Expect(TokenType.Equals);
				tokenizer.ReadToken().Expect(TokenType.Greater);
				BsonExpression bsonExpression2 = BsonExpression.ParseAndCompile(tokenizer, BsonExpressionParserMode.Full, parameters, (bsonExpression.Type != BsonExpressionType.Source) ? DocumentScope.Current : DocumentScope.Source);
				stringBuilder.Append("=>" + bsonExpression2.Source);
				list.Add(Expression.Constant(bsonExpression2));
				hashSet.AddRange(bsonExpression2.Fields);
			}
			if (tokenizer.LookAhead().Type != TokenType.CloseParenthesis)
			{
				tokenizer.ReadToken().Expect(TokenType.Comma);
				stringBuilder.Append(",");
				while (!tokenizer.CheckEOF())
				{
					BsonExpression bsonExpression3 = ParseFullExpression(tokenizer, context, parameters, scope);
					if (!bsonExpression3.IsImmutable)
					{
						isImmutable = false;
					}
					if (bsonExpression3.UseSource)
					{
						useSource = true;
					}
					list.Add(bsonExpression3.Expression);
					stringBuilder.Append(bsonExpression3.Source);
					hashSet.AddRange(bsonExpression3.Fields);
					if (tokenizer.LookAhead().Type != TokenType.Comma)
					{
						break;
					}
					stringBuilder.Append(tokenizer.ReadToken().Value);
				}
			}
			tokenizer.ReadToken().Expect(TokenType.CloseParenthesis);
			stringBuilder.Append(")");
			MethodInfo function = BsonExpression.GetFunction(functionName, list.Count - 5);
			return new BsonExpression
			{
				Type = type,
				Parameters = parameters,
				IsImmutable = isImmutable,
				UseSource = useSource,
				IsScalar = isScalarResult,
				Fields = hashSet,
				Expression = Expression.Call(function, list.ToArray()),
				Source = stringBuilder.ToString()
			};
		}

		private static BsonExpression NewArray(BsonExpression item0, BsonExpression item1)
		{
			Expression[] source = new Expression[2] { item0.Expression, item1.Expression };
			if (!item0.IsScalar)
			{
				throw new LiteException(0, "Expression `" + item0.Source + "` must be a scalar expression");
			}
			if (!item1.IsScalar)
			{
				throw new LiteException(0, "Expression `" + item0.Source + "` must be a scalar expression");
			}
			NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(BsonValue), source.ToArray());
			BsonExpression bsonExpression = new BsonExpression();
			bsonExpression.Type = BsonExpressionType.Array;
			bsonExpression.Parameters = item0.Parameters;
			bsonExpression.IsImmutable = item0.IsImmutable && item1.IsImmutable;
			bsonExpression.UseSource = item0.UseSource || item1.UseSource;
			bsonExpression.IsScalar = true;
			bsonExpression.Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(item0.Fields).AddRange(item1.Fields);
			bsonExpression.Expression = Expression.Call(_arrayInitMethod, new Expression[1] { newArrayExpression });
			bsonExpression.Source = item0.Source + " AND " + item1.Source;
			return bsonExpression;
		}

		private static string ReadField(Tokenizer tokenizer, StringBuilder source)
		{
			string text = "";
			if (tokenizer.Current.Type == TokenType.OpenBracket)
			{
				text = tokenizer.ReadToken().Expect(TokenType.String).Value;
				tokenizer.ReadToken().Expect(TokenType.CloseBracket);
			}
			else if (tokenizer.Current.Type == TokenType.Word)
			{
				text = tokenizer.Current.Value;
			}
			if (text.Length > 0)
			{
				source.Append(".");
				if (text.IsWord())
				{
					source.Append(text);
				}
				else
				{
					source.Append("[");
					JsonSerializer.Serialize(text, source);
					source.Append("]");
				}
			}
			return text;
		}

		public static string ReadKey(Tokenizer tokenizer, StringBuilder source)
		{
			Token token = tokenizer.ReadToken();
			string text = "";
			text = ((token.Type != TokenType.String) ? token.Expect(TokenType.Word, TokenType.Int).Value : token.Value);
			if (text.IsWord())
			{
				source.Append(text);
			}
			else
			{
				JsonSerializer.Serialize(text, source);
			}
			return text;
		}

		private static string ReadOperant(Tokenizer tokenizer)
		{
			Token token = tokenizer.LookAhead();
			if (token.IsOperand)
			{
				tokenizer.ReadToken();
				return token.Value;
			}
			if (token.Is("ALL") || token.Is("ANY"))
			{
				string text = token.Value.ToUpperInvariant();
				tokenizer.ReadToken();
				token = tokenizer.ReadToken();
				if (!token.IsOperand)
				{
					throw LiteException.UnexpectedToken("Expected valid operand", token);
				}
				return text + " " + token.Value;
			}
			return null;
		}

		private static BsonExpression ConvertToEnumerable(BsonExpression expr)
		{
			string source = ((expr.Type == BsonExpressionType.Path) ? (expr.Source + "[*]") : ("ITEMS(" + expr.Source + ")"));
			BsonExpressionType type = ((expr.Type == BsonExpressionType.Path) ? BsonExpressionType.Path : BsonExpressionType.Call);
			return new BsonExpression
			{
				Type = type,
				Parameters = expr.Parameters,
				IsImmutable = expr.IsImmutable,
				UseSource = expr.UseSource,
				IsScalar = false,
				Fields = expr.Fields,
				Expression = Expression.Call(_itemsMethod, expr.Expression),
				Source = source
			};
		}

		private static BsonExpression ConvertToArray(BsonExpression expr)
		{
			return new BsonExpression
			{
				Type = BsonExpressionType.Call,
				Parameters = expr.Parameters,
				IsImmutable = expr.IsImmutable,
				UseSource = expr.UseSource,
				IsScalar = true,
				Fields = expr.Fields,
				Expression = Expression.Call(_arrayMethod, expr.Expression),
				Source = "ARRAY(" + expr.Source + ")"
			};
		}

		internal static BsonExpression CreateLogicExpression(BsonExpressionType type, BsonExpression left, BsonExpression right)
		{
			MemberExpression left2 = Expression.Property(left.Expression, typeof(BsonValue), "AsBoolean");
			MemberExpression right2 = Expression.Property(right.Expression, typeof(BsonValue), "AsBoolean");
			BinaryExpression binaryExpression = ((type == BsonExpressionType.And) ? Expression.AndAlso(left2, right2) : Expression.OrElse(left2, right2));
			ConstructorInfo constructor = typeof(BsonValue).GetConstructors().First((ConstructorInfo x) => x.GetParameters().FirstOrDefault()?.ParameterType == typeof(bool));
			BsonExpression bsonExpression = new BsonExpression();
			bsonExpression.Type = type;
			bsonExpression.Parameters = left.Parameters;
			bsonExpression.IsImmutable = left.IsImmutable && right.IsImmutable;
			bsonExpression.UseSource = left.UseSource || right.UseSource;
			bsonExpression.IsScalar = left.IsScalar && right.IsScalar;
			bsonExpression.Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(left.Fields).AddRange(right.Fields);
			bsonExpression.Expression = Expression.New(constructor, binaryExpression);
			bsonExpression.Left = left;
			bsonExpression.Right = right;
			bsonExpression.Source = left.Source + " " + type.ToString().ToUpperInvariant() + " " + right.Source;
			return bsonExpression;
		}

		internal static BsonExpression CreateConditionalExpression(BsonExpression test, BsonExpression ifTrue, BsonExpression ifFalse)
		{
			ConditionalExpression expression = Expression.Condition(Expression.Property(test.Expression, typeof(BsonValue), "AsBoolean"), ifTrue.Expression, ifFalse.Expression);
			BsonExpression bsonExpression = new BsonExpression();
			bsonExpression.Type = BsonExpressionType.Call;
			bsonExpression.Parameters = test.Parameters;
			bsonExpression.IsImmutable = (test.IsImmutable && ifTrue.IsImmutable) || ifFalse.IsImmutable;
			bsonExpression.UseSource = test.UseSource || ifTrue.UseSource || ifFalse.UseSource;
			bsonExpression.IsScalar = test.IsScalar && ifTrue.IsScalar && ifFalse.IsScalar;
			bsonExpression.Fields = new HashSet<string>(StringComparer.OrdinalIgnoreCase).AddRange(test.Fields).AddRange(ifTrue.Fields).AddRange(ifFalse.Fields);
			bsonExpression.Expression = expression;
			bsonExpression.Source = "IIF(" + test.Source + "," + ifTrue.Source + "," + ifFalse.Source + ")";
			return bsonExpression;
		}
	}
	internal enum BsonExpressionType : byte
	{
		Double = 1,
		Int = 2,
		String = 3,
		Boolean = 4,
		Null = 5,
		Array = 6,
		Document = 7,
		Parameter = 8,
		Call = 9,
		Path = 10,
		Modulo = 11,
		Add = 12,
		Subtract = 13,
		Multiply = 14,
		Divide = 15,
		Equal = 16,
		Like = 17,
		Between = 18,
		GreaterThan = 19,
		GreaterThanOrEqual = 20,
		LessThan = 21,
		LessThanOrEqual = 22,
		NotEqual = 23,
		In = 24,
		Or = 25,
		And = 26,
		Map = 27,
		Filter = 28,
		Sort = 29,
		Source = 30,
		VectorSim = 50
	}
	internal enum DocumentScope
	{
		Source,
		Root,
		Current
	}
	internal class ExpressionContext
	{
		public ParameterExpression Source { get; }

		public ParameterExpression Root { get; }

		public ParameterExpression Current { get; }

		public ParameterExpression Collation { get; }

		public ParameterExpression Parameters { get; }

		public ExpressionContext()
		{
			Source = Expression.Parameter(typeof(IEnumerable<BsonDocument>), "source");
			Root = Expression.Parameter(typeof(BsonDocument), "root");
			Current = Expression.Parameter(typeof(BsonValue), "current");
			Collation = Expression.Parameter(typeof(Collation), "collation");
			Parameters = Expression.Parameter(typeof(BsonDocument), "parameters");
		}
	}
	internal class JsonReader
	{
		[CompilerGenerated]
		private sealed class <DeserializeArray>d__7 : IEnumerable<BsonValue>, IEnumerable, IEnumerator<BsonValue>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonValue <>2__current;

			private int <>l__initialThreadId;

			public JsonReader <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				JsonReader jsonReader = <>4__this;
				Token token;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					token = jsonReader._tokenizer.ReadToken();
					if (token.Type == TokenType.EOF)
					{
						return false;
					}
					token.Expect(TokenType.OpenBracket);
					token = jsonReader._tokenizer.ReadToken();
					break;
				case 1:
					<>1__state = -1;
					token = jsonReader._tokenizer.ReadToken();
					if (token.Type == TokenType.Comma)
					{
						token = jsonReader._tokenizer.ReadToken();
					}
					break;
				}
				if (token.Type != TokenType.CloseBracket)
				{
					<>2__current = jsonReader.ReadValue(token);
					<>1__state = 1;
					return true;
				}
				token.Expect(TokenType.CloseBracket);
				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]
			IEnumerator<BsonValue> IEnumerable<BsonValue>.GetEnumerator()
			{
				<DeserializeArray>d__7 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <DeserializeArray>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private static readonly IFormatProvider _numberFormat = CultureInfo.InvariantCulture.NumberFormat;

		private readonly Tokenizer _tokenizer;

		public long Position => _tokenizer.Position;

		public JsonReader(TextReader reader)
		{
			if (reader == null)
			{
				throw new ArgumentNullException("reader");
			}
			_tokenizer = new Tokenizer(reader);
		}

		internal JsonReader(Tokenizer tokenizer)
		{
			_tokenizer = tokenizer ?? throw new ArgumentNullException("tokenizer");
		}

		public BsonValue Deserialize()
		{
			Token token = _tokenizer.ReadToken();
			if (token.Type == TokenType.EOF)
			{
				return BsonValue.Null;
			}
			return ReadValue(token);
		}

		[IteratorStateMachine(typeof(<DeserializeArray>d__7))]
		public IEnumerable<BsonValue> DeserializeArray()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeserializeArray>d__7(-2)
			{
				<>4__this = this
			};
		}

		internal BsonValue ReadValue(Token token)
		{
			string text = token.Value;
			switch (token.Type)
			{
			case TokenType.String:
				return text;
			case TokenType.OpenBrace:
				return ReadObject();
			case TokenType.OpenBracket:
				return ReadArray();
			case TokenType.Minus:
			{
				Token token2 = _tokenizer.ReadToken(eatWhitespace: false).Expect(TokenType.Int, TokenType.Double);
				text = "-" + token2.Value;
				if (token2.Type == TokenType.Int)
				{
					goto case TokenType.Int;
				}
				if (token2.Type != TokenType.Double)
				{
					break;
				}
				goto case TokenType.Double;
			}
			case TokenType.Int:
			{
				if (int.TryParse(text, NumberStyles.Any, _numberFormat, out var result))
				{
					return new BsonValue(result);
				}
				return new BsonValue(long.Parse(text, NumberStyles.Any, _numberFormat));
			}
			case TokenType.Double:
				return new BsonValue(Convert.ToDouble(text, _numberFormat));
			case TokenType.Word:
				return text.ToLower() switch
				{
					"null" => BsonValue.Null, 
					"true" => true, 
					"false" => false, 
					_ => throw LiteException.UnexpectedToken(token), 
				};
			}
			throw LiteException.UnexpectedToken(token);
		}

		private BsonValue ReadObject()
		{
			BsonDocument bsonDocument = new BsonDocument();
			Token token = _tokenizer.ReadToken();
			while (token.Type != TokenType.CloseBrace)
			{
				token.Expect(TokenType.String, TokenType.Word);
				string value = token.Value;
				token = _tokenizer.ReadToken();
				token.Expect(TokenType.Colon);
				token = _tokenizer.ReadToken();
				if (value[0] == '$' && bsonDocument.Count == 0)
				{
					BsonValue bsonValue = ReadExtendedDataType(value, token.Value);
					if (!bsonValue.IsNull)
					{
						return bsonValue;
					}
				}
				bsonDocument[value] = ReadValue(token);
				token = _tokenizer.ReadToken();
				if (token.Type == TokenType.Comma)
				{
					token = _tokenizer.ReadToken();
				}
			}
			return bsonDocument;
		}

		private BsonArray ReadArray()
		{
			BsonArray bsonArray = new BsonArray();
			Token token = _tokenizer.ReadToken();
			while (token.Type != TokenType.CloseBracket)
			{
				BsonValue item = ReadValue(token);
				bsonArray.Add(item);
				token = _tokenizer.ReadToken();
				if (token.Type == TokenType.Comma)
				{
					token = _tokenizer.ReadToken();
				}
			}
			return bsonArray;
		}

		private BsonValue ReadExtendedDataType(string key, string value)
		{
			BsonValue result;
			switch (key)
			{
			case "$binary":
				result = new BsonValue(Convert.FromBase64String(value));
				break;
			case "$oid":
				result = new BsonValue(new ObjectId(value));
				break;
			case "$guid":
				result = new BsonValue(new Guid(value));
				break;
			case "$date":
				result = new BsonValue(DateTime.Parse(value).ToLocalTime());
				break;
			case "$numberLong":
				result = new BsonValue(Convert.ToInt64(value, _numberFormat));
				break;
			case "$numberDecimal":
				result = new BsonValue(Convert.ToDecimal(value, _numberFormat));
				break;
			case "$minValue":
				result = BsonValue.MinValue;
				break;
			case "$maxValue":
				result = BsonValue.MaxValue;
				break;
			default:
				return BsonValue.Null;
			}
			_tokenizer.ReadToken().Expect(TokenType.CloseBrace);
			return result;
		}
	}
	internal class JsonSerializer
	{
		public static string Serialize(BsonValue value, bool indent = false)
		{
			StringBuilder stringBuilder = new StringBuilder();
			Serialize(value, stringBuilder, indent);
			return stringBuilder.ToString();
		}

		public static void Serialize(BsonValue value, TextWriter writer, bool indent = false)
		{
			JsonWriter jsonWriter = new JsonWriter(writer);
			jsonWriter.Pretty = indent;
			jsonWriter.Serialize(value ?? BsonValue.Null);
		}

		public static void Serialize(BsonValue value, StringBuilder sb, bool indent = false)
		{
			using StringWriter writer = new StringWriter(sb);
			JsonWriter jsonWriter = new JsonWriter(writer);
			jsonWriter.Pretty = indent;
			jsonWriter.Serialize(value ?? BsonValue.Null);
		}

		public static BsonValue Deserialize(string json)
		{
			if (json == null)
			{
				throw new ArgumentNullException("json");
			}
			using StringReader reader = new StringReader(json);
			return new JsonReader(reader).Deserialize();
		}

		public static BsonValue Deserialize(TextReader reader)
		{
			if (reader == null)
			{
				throw new ArgumentNullException("reader");
			}
			return new JsonReader(reader).Deserialize();
		}

		public static IEnumerable<BsonValue> DeserializeArray(string json)
		{
			if (json == null)
			{
				throw new ArgumentNullException("json");
			}
			return new JsonReader(new StringReader(json)).DeserializeArray();
		}

		public static IEnumerable<BsonValue> DeserializeArray(TextReader reader)
		{
			if (reader == null)
			{
				throw new ArgumentNullException("reader");
			}
			return new JsonReader(reader).DeserializeArray();
		}
	}
	internal class JsonWriter
	{
		private static readonly IFormatProvider _numberFormat = CultureInfo.InvariantCulture.NumberFormat;

		private readonly TextWriter _writer;

		private int _indent;

		private string _spacer = "";

		public int Indent { get; set; } = 4;


		public bool Pretty { get; set; }

		public JsonWriter(TextWriter writer)
		{
			_writer = writer;
		}

		public void Serialize(BsonValue value)
		{
			_indent = 0;
			_spacer = (Pretty ? " " : "");
			WriteValue(value ?? BsonValue.Null);
		}

		private void WriteValue(BsonValue value)
		{
			switch (value.Type)
			{
			case BsonType.Null:
				_writer.Write("null");
				break;
			case BsonType.Array:
				WriteArray(value.AsArray);
				break;
			case BsonType.Document:
				WriteObject(value.AsDocument);
				break;
			case BsonType.Boolean:
				_writer.Write(value.AsBoolean.ToString().ToLower());
				break;
			case BsonType.String:
				WriteString(value.AsString);
				break;
			case BsonType.Int32:
				_writer.Write(value.AsInt32.ToString(_numberFormat));
				break;
			case BsonType.Double:
			{
				double asDouble = value.AsDouble;
				if (double.IsNaN(asDouble) || double.IsNegativeInfinity(asDouble) || double.IsPositiveInfinity(asDouble))
				{
					_writer.Write("null");
				}
				else
				{
					_writer.Write(value.AsDouble.ToString("0.0########", _numberFormat));
				}
				break;
			}
			case BsonType.Binary:
			{
				byte[] asBinary = value.AsBinary;
				WriteExtendDataType("$binary", Convert.ToBase64String(asBinary, 0, asBinary.Length));
				break;
			}
			case BsonType.ObjectId:
				WriteExtendDataType("$oid", value.AsObjectId.ToString());
				break;
			case BsonType.Guid:
				WriteExtendDataType("$guid", value.AsGuid.ToString());
				break;
			case BsonType.DateTime:
				WriteExtendDataType("$date", value.AsDateTime.ToUniversalTime().ToString("o"));
				break;
			case BsonType.Int64:
				WriteExtendDataType("$numberLong", value.AsInt64.ToString(_numberFormat));
				break;
			case BsonType.Decimal:
				WriteExtendDataType("$numberDecimal", value.AsDecimal.ToString(_numberFormat));
				break;
			case BsonType.MinValue:
				WriteExtendDataType("$minValue", "1");
				break;
			case BsonType.MaxValue:
				WriteExtendDataType("$maxValue", "1");
				break;
			case BsonType.Vector:
			{
				BsonArray arr = new BsonArray(((IEnumerable<float>)value.AsVector).Select((Func<float, BsonValue>)((float x) => x)));
				WriteArray(arr);
				break;
			}
			}
		}

		private void WriteObject(BsonDocument obj)
		{
			int num = obj.Keys.Count();
			bool hasData = num > 0;
			WriteStartBlock("{", hasData);
			int num2 = 0;
			foreach (KeyValuePair<string, BsonValue> element in obj.GetElements())
			{
				WriteKeyValue(element.Key, element.Value, num2++ < num - 1);
			}
			WriteEndBlock("}", hasData);
		}

		private void WriteArray(BsonArray arr)
		{
			bool hasData = arr.Count > 0;
			WriteStartBlock("[", hasData);
			for (int i = 0; i < arr.Count; i++)
			{
				BsonValue bsonValue = arr[i];
				if (Pretty && bsonValue != null && (!bsonValue.IsDocument || !bsonValue.AsDocument.Keys.Any()) && (!bsonValue.IsArray || bsonValue.AsArray.Count <= 0))
				{
					WriteIndent();
				}
				WriteValue(bsonValue ?? BsonValue.Null);
				if (i < arr.Count - 1)
				{
					_writer.Write(',');
				}
				WriteNewLine();
			}
			WriteEndBlock("]", hasData);
		}

		private void WriteString(string s)
		{
			_writer.Write('"');
			int length = s.Length;
			for (int i = 0; i < length; i++)
			{
				char c = s[i];
				switch (c)
				{
				case '"':
					_writer.Write("\\\"");
					continue;
				case '\\':
					_writer.Write("\\\\");
					continue;
				case '\b':
					_writer.Write("\\b");
					continue;
				case '\f':
					_writer.Write("\\f");
					continue;
				case '\n':
					_writer.Write("\\n");
					continue;
				case '\r':
					_writer.Write("\\r");
					continue;
				case '\t':
					_writer.Write("\\t");
					continue;
				}
				switch (CharUnicodeInfo.GetUnicodeCategory(c))
				{
				case UnicodeCategory.UppercaseLetter:
				case UnicodeCategory.LowercaseLetter:
				case UnicodeCategory.TitlecaseLetter:
				case UnicodeCategory.OtherLetter:
				case UnicodeCategory.DecimalDigitNumber:
				case UnicodeCategory.LetterNumber:
				case UnicodeCategory.OtherNumber:
				case UnicodeCategory.SpaceSeparator:
				case UnicodeCategory.ConnectorPunctuation:
				case UnicodeCategory.DashPunctuation:
				case UnicodeCategory.OpenPunctuation:
				case UnicodeCategory.ClosePunctuation:
				case UnicodeCategory.InitialQuotePunctuation:
				case UnicodeCategory.FinalQuotePunctuation:
				case UnicodeCategory.OtherPunctuation:
				case UnicodeCategory.MathSymbol:
				case UnicodeCategory.CurrencySymbol:
				case UnicodeCategory.ModifierSymbol:
				case UnicodeCategory.OtherSymbol:
					_writer.Write(c);
					continue;
				}
				_writer.Write("\\u");
				TextWriter writer = _writer;
				int num = c;
				writer.Write(num.ToString("x04"));
			}
			_writer.Write('"');
		}

		private void WriteExtendDataType(string type, string value)
		{
			_writer.Write("{\"");
			_writer.Write(type);
			_writer.Write("\":");
			_writer.Write(_spacer);
			_writer.Write("\"");
			_writer.Write(value);
			_writer.Write("\"}");
		}

		private void WriteKeyValue(string key, BsonValue value, bool comma)
		{
			WriteIndent();
			_writer.Write('"');
			_writer.Write(key);
			_writer.Write("\":");
			if (Pretty)
			{
				_writer.Write(' ');
				if (value != null && ((value.IsDocument && value.AsDocument.Keys.Any()) || (value.IsArray && value.AsArray.Count > 0)))
				{
					WriteNewLine();
				}
			}
			WriteValue(value ?? BsonValue.Null);
			if (comma)
			{
				_writer.Write(',');
			}
			WriteNewLine();
		}

		private void WriteStartBlock(string str, bool hasData)
		{
			if (hasData)
			{
				WriteIndent();
				_writer.Write(str);
				WriteNewLine();
				_indent++;
			}
			else
			{
				_writer.Write(str);
			}
		}

		private void WriteEndBlock(string str, bool hasData)
		{
			if (hasData)
			{
				_indent--;
				WriteIndent();
				_writer.Write(str);
			}
			else
			{
				_writer.Write(str);
			}
		}

		private void WriteNewLine()
		{
			if (Pretty)
			{
				_writer.WriteLine();
			}
		}

		private void WriteIndent()
		{
			if (Pretty)
			{
				_writer.Write("".PadRight(_indent * Indent, ' '));
			}
		}
	}
	internal class ObjectId : IComparable<ObjectId>, IEquatable<ObjectId>
	{
		private static readonly int _machine;

		private static readonly short _pid;

		private static int _increment;

		public static ObjectId Empty => new ObjectId();

		public int Timestamp { get; }

		public int Machine { get; }

		public short Pid { get; }

		public int Increment { get; }

		public DateTime CreationTime
		{
			get
			{
				DateTime unixEpoch = BsonValue.UnixEpoch;
				return unixEpoch.AddSeconds(Timestamp);
			}
		}

		public ObjectId()
		{
			Timestamp = 0;
			Machine = 0;
			Pid = 0;
			Increment = 0;
		}

		public ObjectId(int timestamp, int machine, short pid, int increment)
		{
			Timestamp = timestamp;
			Machine = machine;
			Pid = pid;
			Increment = increment;
		}

		public ObjectId(ObjectId from)
		{
			Timestamp = from.Timestamp;
			Machine = from.Machine;
			Pid = from.Pid;
			Increment = from.Increment;
		}

		public ObjectId(string value)
			: this(FromHex(value))
		{
		}

		public ObjectId(byte[] bytes, int startIndex = 0)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes");
			}
			Timestamp = (bytes[startIndex] << 24) + (bytes[startIndex + 1] << 16) + (bytes[startIndex + 2] << 8) + bytes[startIndex + 3];
			Machine = (bytes[startIndex + 4] << 16) + (bytes[startIndex + 5] << 8) + bytes[startIndex + 6];
			Pid = (short)((bytes[startIndex + 7] << 8) + bytes[startIndex + 8]);
			Increment = (bytes[startIndex + 9] << 16) + (bytes[startIndex + 10] << 8) + bytes[startIndex + 11];
		}

		private static byte[] FromHex(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				throw new ArgumentNullException("value");
			}
			if (value.Length != 24)
			{
				throw new ArgumentException($"ObjectId strings should be 24 hex characters, got {value.Length} : \"{value}\"");
			}
			byte[] array = new byte[12];
			for (int i = 0; i < 24; i += 2)
			{
				array[i / 2] = Convert.ToByte(value.Substring(i, 2), 16);
			}
			return array;
		}

		public bool Equals(ObjectId other)
		{
			if (other != null && Timestamp == other.Timestamp && Machine == other.Machine && Pid == other.Pid)
			{
				return Increment == other.Increment;
			}
			return false;
		}

		public override bool Equals(object other)
		{
			return Equals(other as ObjectId);
		}

		public override int GetHashCode()
		{
			int num = 17;
			num = 37 * num + Timestamp.GetHashCode();
			num = 37 * num + Machine.GetHashCode();
			num = 37 * num + Pid.GetHashCode();
			return 37 * num + Increment.GetHashCode();
		}

		public int CompareTo(ObjectId other)
		{
			int num = Timestamp.CompareTo(other.Timestamp);
			if (num != 0)
			{
				return num;
			}
			num = Machine.CompareTo(other.Machine);
			if (num != 0)
			{
				return num;
			}
			num = Pid.CompareTo(other.Pid);
			if (num != 0)
			{
				if (num >= 0)
				{
					return 1;
				}
				return -1;
			}
			return Increment.CompareTo(other.Increment);
		}

		public void ToByteArray(byte[] bytes, int startIndex)
		{
			bytes[startIndex] = (byte)(Timestamp >> 24);
			bytes[startIndex + 1] = (byte)(Timestamp >> 16);
			bytes[startIndex + 2] = (byte)(Timestamp >> 8);
			bytes[startIndex + 3] = (byte)Timestamp;
			bytes[startIndex + 4] = (byte)(Machine >> 16);
			bytes[startIndex + 5] = (byte)(Machine >> 8);
			bytes[startIndex + 6] = (byte)Machine;
			bytes[startIndex + 7] = (byte)(Pid >> 8);
			bytes[startIndex + 8] = (byte)Pid;
			bytes[startIndex + 9] = (byte)(Increment >> 16);
			bytes[startIndex + 10] = (byte)(Increment >> 8);
			bytes[startIndex + 11] = (byte)Increment;
		}

		public byte[] ToByteArray()
		{
			byte[] array = new byte[12];
			ToByteArray(array, 0);
			return array;
		}

		public override string ToString()
		{
			return BitConverter.ToString(ToByteArray()).Replace("-", "").ToLower();
		}

		public static bool operator ==(ObjectId lhs, ObjectId rhs)
		{
			if ((object)lhs == null)
			{
				return (object)rhs == null;
			}
			if ((object)rhs == null)
			{
				return false;
			}
			return lhs.Equals(rhs);
		}

		public static bool operator !=(ObjectId lhs, ObjectId rhs)
		{
			return !(lhs == rhs);
		}

		public static bool operator >=(ObjectId lhs, ObjectId rhs)
		{
			return lhs.CompareTo(rhs) >= 0;
		}

		public static bool operator >(ObjectId lhs, ObjectId rhs)
		{
			return lhs.CompareTo(rhs) > 0;
		}

		public static bool operator <(ObjectId lhs, ObjectId rhs)
		{
			return lhs.CompareTo(rhs) < 0;
		}

		public static bool operator <=(ObjectId lhs, ObjectId rhs)
		{
			return lhs.CompareTo(rhs) <= 0;
		}

		static ObjectId()
		{
			_machine = (GetMachineHash() + 10000) & 0xFFFFFF;
			_increment = new Random().Next();
			try
			{
				_pid = (short)GetCurrentProcessId();
			}
			catch (SecurityException)
			{
				_pid = 0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static int GetCurrentProcessId()
		{
			return new Random().Next(0, 5000);
		}

		private static int GetMachineHash()
		{
			string text = "SOMENAME";
			return 0xFFFFFF & text.GetHashCode();
		}

		public static ObjectId NewObjectId()
		{
			long num = (long)Math.Floor((DateTime.UtcNow - BsonValue.UnixEpoch).TotalSeconds);
			return new ObjectId(increment: Interlocked.Increment(ref _increment) & 0xFFFFFF, timestamp: (int)num, machine: _machine, pid: _pid);
		}
	}
	internal class AesEncryption : IDisposable
	{
		private Aes _aes;

		public AesEncryption(string password, byte[] salt)
		{
			_aes = Aes.Create();
			_aes.Padding = PaddingMode.Zeros;
			Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, salt);
			using (rfc2898DeriveBytes)
			{
				_aes.Key = rfc2898DeriveBytes.GetBytes(32);
				_aes.IV = rfc2898DeriveBytes.GetBytes(16);
			}
		}

		public byte[] Encrypt(byte[] bytes)
		{
			using ICryptoTransform transform = _aes.CreateEncryptor();
			using MemoryStream memoryStream = new MemoryStream();
			using CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
			cryptoStream.Write(bytes, 0, bytes.Length);
			cryptoStream.FlushFinalBlock();
			memoryStream.Position = 0L;
			byte[] array = new byte[memoryStream.Length];
			memoryStream.Read(array, 0, array.Length);
			return array;
		}

		public byte[] Decrypt(byte[] encryptedValue, int offset = 0, int count = -1)
		{
			using ICryptoTransform transform = _aes.CreateDecryptor();
			using MemoryStream memoryStream = new MemoryStream();
			using CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
			cryptoStream.Write(encryptedValue, offset, (count == -1) ? encryptedValue.Length : count);
			cryptoStream.FlushFinalBlock();
			memoryStream.Position = 0L;
			byte[] array = new byte[memoryStream.Length];
			memoryStream.Read(array, 0, array.Length);
			return array;
		}

		public static byte[] HashSHA1(string password)
		{
			return SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(password));
		}

		public static byte[] Salt(int maxLength = 16)
		{
			byte[] array = new byte[maxLength];
			RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
			using (randomNumberGenerator)
			{
				randomNumberGenerator.GetBytes(array);
				return array;
			}
		}

		public void Dispose()
		{
			if (_aes != null)
			{
				_aes.Dispose();
				_aes = null;
			}
		}
	}
	internal class BsonReader
	{
		private readonly bool _utcDate;

		public BsonReader(bool utcDate)
		{
			_utcDate = utcDate;
		}

		public BsonDocument Deserialize(byte[] bson)
		{
			return ReadDocument(new ByteReader(bson));
		}

		public BsonDocument ReadDocument(ByteReader reader)
		{
			int num = reader.ReadInt32();
			int num2 = reader.Position + num - 5;
			BsonDocument bsonDocument = new BsonDocument();
			while (reader.Position < num2)
			{
				string name;
				BsonValue value = ReadElement(reader, out name);
				bsonDocument.RawValue[name] = value;
			}
			reader.ReadByte();
			return bsonDocument;
		}

		public BsonArray ReadArray(ByteReader reader)
		{
			int num = reader.ReadInt32();
			int num2 = reader.Position + num - 5;
			BsonArray bsonArray = new BsonArray();
			while (reader.Position < num2)
			{
				string name;
				BsonValue item = ReadElement(reader, out name);
				bsonArray.Add(item);
			}
			reader.ReadByte();
			return bsonArray;
		}

		private BsonValue ReadElement(ByteReader reader, out string name)
		{
			byte b = reader.ReadByte();
			name = reader.ReadCString();
			switch (b)
			{
			case 1:
				return reader.ReadDouble();
			case 2:
				return reader.ReadBsonString();
			case 3:
				return ReadDocument(reader);
			case 4:
				return ReadArray(reader);
			case 5:
			{
				int count = reader.ReadInt32();
				byte b2 = reader.ReadByte();
				byte[] array = reader.ReadBytes(count);
				switch (b2)
				{
				case 0:
					return array;
				case 4:
					return new Guid(array);
				}
				break;
			}
			case 7:
				return new ObjectId(reader.ReadBytes(12));
			case 8:
				return reader.ReadBoolean();
			case 9:
			{
				long num = reader.ReadInt64();
				switch (num)
				{
				case 253402300800000L:
					return DateTime.MaxValue;
				case -62135596800000L:
					return DateTime.MinValue;
				default:
				{
					DateTime unixEpoch = BsonValue.UnixEpoch;
					DateTime dateTime = unixEpoch.AddMilliseconds(num);
					return _utcDate ? dateTime : dateTime.ToLocalTime();
				}
				}
			}
			case 10:
				return BsonValue.Null;
			case 16:
				return reader.ReadInt32();
			case 18:
				return reader.ReadInt64();
			case 19:
				return reader.ReadDecimal();
			case byte.MaxValue:
				return BsonValue.MinValue;
			case 127:
				return BsonValue.MaxValue;
			}
			throw new NotSupportedException("BSON type not supported");
		}
	}
	internal class ByteReader
	{
		private readonly byte[] _buffer;

		private readonly int _length;

		private int _pos;

		public int Position
		{
			get
			{
				return _pos;
			}
			set
			{
				_pos = value;
			}
		}

		public ByteReader(byte[] buffer)
		{
			_buffer = buffer;
			_length = buffer.Length;
			_pos = 0;
		}

		public void Skip(int length)
		{
			_pos += length;
		}

		public byte ReadByte()
		{
			byte result = _buffer[_pos];
			_pos++;
			return result;
		}

		public bool ReadBoolean()
		{
			byte num = _buffer[_pos];
			_pos++;
			return num != 0;
		}

		public ushort ReadUInt16()
		{
			_pos += 2;
			return BitConverter.ToUInt16(_buffer, _pos - 2);
		}

		public uint ReadUInt32()
		{
			_pos += 4;
			return BitConverter.ToUInt32(_buffer, _pos - 4);
		}

		public ulong ReadUInt64()
		{
			_pos += 8;
			return BitConverter.ToUInt64(_buffer, _pos - 8);
		}

		public short ReadInt16()
		{
			_pos += 2;
			return BitConverter.ToInt16(_buffer, _pos - 2);
		}

		public int ReadInt32()
		{
			_pos += 4;
			return BitConverter.ToInt32(_buffer, _pos - 4);
		}

		public long ReadInt64()
		{
			_pos += 8;
			return BitConverter.ToInt64(_buffer, _pos - 8);
		}

		public float ReadSingle()
		{
			_pos += 4;
			return BitConverter.ToSingle(_buffer, _pos - 4);
		}

		public double ReadDouble()
		{
			_pos += 8;
			return BitConverter.ToDouble(_buffer, _pos - 8);
		}

		public decimal ReadDecimal()
		{
			_pos += 16;
			int num = BitConverter.ToInt32(_buffer, _pos - 16);
			int num2 = BitConverter.ToInt32(_buffer, _pos - 12);
			int num3 = BitConverter.ToInt32(_buffer, _pos - 8);
			int num4 = BitConverter.ToInt32(_buffer, _pos - 4);
			return new decimal(new int[4] { num, num2, num3, num4 });
		}

		public byte[] ReadBytes(int count)
		{
			byte[] array = new byte[count];
			Buffer.BlockCopy(_buffer, _pos, array, 0, count);
			_pos += count;
			return array;
		}

		public string ReadString()
		{
			int num = ReadInt32();
			string @string = Encoding.UTF8.GetString(_buffer, _pos, num);
			_pos += num;
			return @string;
		}

		public string ReadString(int length)
		{
			string @string = Encoding.UTF8.GetString(_buffer, _pos, length);
			_pos += length;
			return @string;
		}

		public string ReadBsonString()
		{
			int num = ReadInt32();
			string @string = Encoding.UTF8.GetString(_buffer, _pos, num - 1);
			_pos += num;
			return @string;
		}

		public string ReadCString()
		{
			int num = _pos;
			int num2 = 0;
			while (true)
			{
				if (_buffer[num] == 0)
				{
					string @string = Encoding.UTF8.GetString(_buffer, _pos, num2);
					_pos += num2 + 1;
					return @string;
				}
				if (num > _length)
				{
					break;
				}
				num++;
				num2++;
			}
			return "_";
		}

		public DateTime ReadDateTime()
		{
			return new DateTime(ReadInt64(), DateTimeKind.Utc).ToLocalTime();
		}

		public Guid ReadGuid()
		{
			return new Guid(ReadBytes(16));
		}

		public ObjectId ReadObjectId()
		{
			return new ObjectId(ReadBytes(12));
		}

		public BsonValue ReadBsonValue(ushort length)
		{
			return (BsonType)ReadByte() switch
			{
				BsonType.Null => BsonValue.Null, 
				BsonType.Int32 => ReadInt32(), 
				BsonType.Int64 => ReadInt64(), 
				BsonType.Double => ReadDouble(), 
				BsonType.Decimal => ReadDecimal(), 
				BsonType.String => ReadString(length), 
				BsonType.Document => new BsonReader(utcDate: false).ReadDocument(this), 
				BsonType.Array => new BsonReader(utcDate: false).ReadArray(this), 
				BsonType.Binary => ReadBytes(length), 
				BsonType.ObjectId => ReadObjectId(), 
				BsonType.Guid => ReadGuid(), 
				BsonType.Boolean => ReadBoolean(), 
				BsonType.DateTime => ReadDateTime(), 
				BsonType.MinValue => BsonValue.MinValue, 
				BsonType.MaxValue => BsonValue.MaxValue, 
				_ => throw new NotImplementedException(), 
			};
		}
	}
	internal class QueryOrder
	{
		public BsonExpression Expression { get; }

		public int Order { get; }

		public QueryOrder(BsonExpression expression, int order)
		{
			Expression = expression;
			Order = order;
		}
	}
	internal class AsyncManualResetEvent
	{
		private volatile TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();

		public Task WaitAsync()
		{
			return _tcs.Task;
		}

		public void Set()
		{
			_tcs.TrySetResult(result: true);
		}

		public void Reset()
		{
			TaskCompletionSource<bool> tcs;
			do
			{
				tcs = _tcs;
			}
			while (tcs.Task.IsCompleted && Interlocked.CompareExchange(ref _tcs, new TaskCompletionSource<bool>(), tcs) != tcs);
		}
	}
	internal class BufferSlice
	{
		public int Offset { get; }

		public int Count { get; }

		public byte[] Array { get; }

		public byte this[int index]
		{
			get
			{
				return Array[Offset + index];
			}
			set
			{
				Array[Offset + index] = value;
			}
		}

		public BufferSlice(byte[] array, int offset, int count)
		{
			Array = array;
			Offset = offset;
			Count = count;
		}

		public void Clear()
		{
			System.Array.Clear(Array, Offset, Count);
		}

		public void Clear(int offset, int count)
		{
			Constants.ENSURE(offset + count <= Count, "must fit in this page");
			System.Array.Clear(Array, Offset + offset, count);
		}

		public void Fill(byte value)
		{
			for (int i = 0; i < Count; i++)
			{
				Array[Offset + i] = value;
			}
		}

		public bool All(byte value)
		{
			for (int i = 0; i < Count; i++)
			{
				if (Array[Offset + i] != value)
				{
					return false;
				}
			}
			return true;
		}

		public string ToHex()
		{
			StringBuilder stringBuilder = new StringBuilder();
			long num = 0L;
			while (num < Count)
			{
				for (int i = 0; i < 32; i++)
				{
					if (num >= Count)
					{
						break;
					}
					stringBuilder.Append(Array[Offset + num].ToString("X2") + " ");
					num++;
				}
				stringBuilder.AppendLine();
			}
			return stringBuilder.ToString();
		}

		public BufferSlice Slice(int offset, int count)
		{
			return new BufferSlice(Array, Offset + offset, count);
		}

		public byte[] ToArray()
		{
			byte[] array = new byte[Count];
			Buffer.BlockCopy(Array, Offset, array, 0, Count);
			return array;
		}

		public override string ToString()
		{
			return $"Offset: {Offset} - Count: {Count}";
		}
	}
	internal class Collation : IComparer<BsonValue>, IComparer<string>, IEqualityComparer<BsonValue>
	{
		private readonly CompareInfo _compareInfo;

		public static Collation Default = new Collation(LiteDB.LCID.Current, CompareOptions.IgnoreCase);

		public static Collation Binary = new Collation(127, CompareOptions.Ordinal);

		public int LCID { get; }

		public CultureInfo Culture { get; }

		public CompareOptions SortOptions { get; }

		public Collation(string collation)
		{
			string[] array = collation.Split(new char[1] { '/' });
			string text = array[0];
			CompareOptions compareOptions = ((array.Length > 1) ? ((CompareOptions)Enum.Parse(typeof(CompareOptions), array[1])) : CompareOptions.None);
			LCID = LiteDB.LCID.GetLCID(text);
			SortOptions = compareOptions;
			Culture = new CultureInfo(text);
			_compareInfo = Culture.CompareInfo;
		}

		public Collation(int lcid, CompareOptions sortOptions)
		{
			LCID = lcid;
			SortOptions = sortOptions;
			Culture = LiteDB.LCID.GetCulture(lcid);
			_compareInfo = Culture.CompareInfo;
		}

		public int Compare(string left, string right)
		{
			int num = _compareInfo.Compare(left, right, SortOptions);
			if (num >= 0)
			{
				return (num > 0) ? 1 : 0;
			}
			return -1;
		}

		public int Compare(BsonValue left, BsonValue rigth)
		{
			return left.CompareTo(rigth, this);
		}

		public bool Equals(BsonValue x, BsonValue y)
		{
			return Compare(x, y) == 0;
		}

		public int GetHashCode(BsonValue obj)
		{
			return obj.GetHashCode();
		}

		public override string ToString()
		{
			return Culture.Name + "/" + SortOptions;
		}
	}
	internal class Constants
	{
		public const int PAGE_SIZE = 8192;

		public const int PAGE_HEADER_SIZE = 32;

		public const int ENCRYPTION_SALT_SIZE = 16;

		public static int BUFFER_WRITABLE = -1;

		public static int INDEX_NAME_MAX_LENGTH = 32;

		public const int MAX_LEVEL_LENGTH = 32;

		public const int MAX_INDEX_KEY_LENGTH = 1023;

		public const int MAX_INDEX_LENGTH = 1400;

		public const int PAGE_FREE_LIST_SLOTS = 5;

		public const int MAX_DOCUMENT_SIZE = 16683050;

		public const int MAX_OPEN_TRANSACTIONS = 100;

		public const int MAX_TRANSACTION_SIZE = 100000;

		public static int[] MEMORY_SEGMENT_SIZES = new int[5] { 12, 50, 100, 500, 1000 };

		public const int VIRTUAL_INDEX_MAX_CACHE = 2000;

		public const int CONTAINER_SORT_SIZE = 819200;

		public const int RANDOMIZER_SEED = 0;

		[DebuggerHidden]
		[Conditional("DEBUG")]
		public static void LOG(string message, string category)
		{
		}

		[DebuggerHidden]
		[Conditional("DEBUG")]
		public static void LOG(bool conditional, string message, string category)
		{
		}

		[DebuggerHidden]
		public static void ENSURE(bool conditional, string message = null)
		{
			if (!conditional)
			{
				if (Debugger.IsAttached)
				{
					Debugger.Break();
				}
				throw LiteException.InvalidDatafileState(message);
			}
		}

		[DebuggerHidden]
		public static void ENSURE(bool conditional, string format, params object[] args)
		{
			if (!conditional)
			{
				if (Debugger.IsAttached)
				{
					Debugger.Break();
				}
				string.Format(CultureInfo.InvariantCulture, format, args);
				throw LiteException.InvalidDatafileState(format);
			}
		}

		[DebuggerHidden]
		public static void ENSURE(bool ifTest, bool conditional, string message = null)
		{
			if (ifTest && !conditional)
			{
				if (Debugger.IsAttached)
				{
					Debugger.Break();
				}
				throw LiteException.InvalidDatafileState(message);
			}
		}

		[DebuggerHidden]
		[Conditional("DEBUG")]
		public static void DEBUG(bool conditional, string message = null)
		{
			if (!conditional)
			{
				if (Debugger.IsAttached)
				{
					Debugger.Break();
				}
				throw LiteException.InvalidDatafileState(message);
			}
		}
	}
	internal class StringEncoding
	{
		public static Encoding UTF8 = (Encoding)new UTF8Encoding(false, true);
	}
	internal static class ExtendedLengthHelper
	{
		public static void ReadLength(byte typeByte, byte lengthByte, out BsonType type, out ushort length)
		{
			byte b = (byte)(typeByte & 0x3Fu);
			byte b2 = lengthByte;
			byte b3 = (byte)(typeByte & 0xC0u);
			type = (BsonType)b;
			length = (ushort)((b3 << 2) | b2);
		}

		public static void WriteLength(BsonType type, ushort length, out byte typeByte, out byte lengthByte)
		{
			if (length > 1023)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			byte b = (byte)type;
			byte b2 = (byte)length;
			byte b3 = (byte)((length & 0x300) >> 2);
			typeByte = (byte)(b3 | b);
			lengthByte = b2;
		}
	}
	internal static class BufferExtensions
	{
		public static int BinaryCompareTo(this byte[] lh, byte[] rh)
		{
			if (lh == null)
			{
				if (rh != null)
				{
					return -1;
				}
				return 0;
			}
			if (rh == null)
			{
				return 1;
			}
			int num = 0;
			int num2 = 0;
			int num3 = Math.Min(lh.Length, rh.Length);
			while (num == 0 && num2 < num3)
			{
				num = lh[num2].CompareTo(rh[num2]);
				num2++;
			}
			if (num != 0)
			{
				if (num >= 0)
				{
					return 1;
				}
				return -1;
			}
			if (num2 == lh.Length)
			{
				if (num2 != rh.Length)
				{
					return -1;
				}
				return 0;
			}
			return 1;
		}

		public unsafe static bool IsFullZero(this byte[] data)
		{
			fixed (byte* ptr = data)
			{
				int num = data.Length;
				int num2 = num % 128;
				long* ptr2 = (long*)ptr;
				for (long* ptr3 = (long*)(ptr + num - num2); ptr2 < ptr3; ptr2 += 16)
				{
					if ((*ptr2 | ptr2[1] | ptr2[2] | ptr2[3] | ptr2[4] | ptr2[5] | ptr2[6] | ptr2[7] | ptr2[8] | ptr2[9] | ptr2[10] | ptr2[11] | ptr2[12] | ptr2[13] | ptr2[14] | ptr2[15]) != 0L)
					{
						return false;
					}
				}
				for (int i = 0; i < num2; i++)
				{
					if (data[num - 1 - i] != 0)
					{
						return false;
					}
				}
				return true;
			}
		}

		public static byte[] Fill(this byte[] array, byte value, int offset, int count)
		{
			for (int i = 0; i < count; i++)
			{
				array[i + offset] = value;
			}
			return array;
		}

		public static string ReadCString(this byte[] bytes, int startIndex, out int bytesCount)
		{
			int num = Array.IndexOf(bytes, (byte)0, startIndex);
			if (num > 0)
			{
				bytesCount = num - startIndex;
				return Encoding.UTF8.GetString(bytes, startIndex, bytesCount);
			}
			bytesCount = 0;
			return null;
		}

		public unsafe static void ToBytes(this short value, byte[] array, int startIndex)
		{
			fixed (byte* ptr = &array[startIndex])
			{
				*(short*)ptr = value;
			}
		}

		public unsafe static void ToBytes(this int value, byte[] array, int startIndex)
		{
			fixed (byte* ptr = &array[startIndex])
			{
				*(int*)ptr = value;
			}
		}

		public unsafe static void ToBytes(this long value, byte[] array, int startIndex)
		{
			fixed (byte* ptr = &array[startIndex])
			{
				*(long*)ptr = value;
			}
		}

		public unsafe static void ToBytes(this ushort value, byte[] array, int startIndex)
		{
			fixed (byte* ptr = &array[startIndex])
			{
				*(ushort*)ptr = value;
			}
		}

		public unsafe static void ToBytes(this uint value, byte[] array, int startIndex)
		{
			fixed (byte* ptr = &array[startIndex])
			{
				*(uint*)ptr = value;
			}
		}

		public unsafe static void ToBytes(this ulong value, byte[] array, int startIndex)
		{
			fixed (byte* ptr = &array[startIndex])
			{
				*(ulong*)ptr = value;
			}
		}

		public unsafe static void ToBytes(this float value, byte[] array, int startIndex)
		{
			(*(uint*)(&value)).ToBytes(array, startIndex);
		}

		public unsafe static void ToBytes(this double value, byte[] array, int startIndex)
		{
			(*(ulong*)(&value)).ToBytes(array, startIndex);
		}
	}
	internal static class BufferSliceExtensions
	{
		public static bool ReadBool(this BufferSlice buffer, int offset)
		{
			return buffer.Array[buffer.Offset + offset] != 0;
		}

		public static byte ReadByte(this BufferSlice buffer, int offset)
		{
			return buffer.Array[buffer.Offset + offset];
		}

		public static short ReadInt16(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToInt16(buffer.Array, buffer.Offset + offset);
		}

		public static ushort ReadUInt16(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToUInt16(buffer.Array, buffer.Offset + offset);
		}

		public static int ReadInt32(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToInt32(buffer.Array, buffer.Offset + offset);
		}

		public static uint ReadUInt32(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToUInt32(buffer.Array, buffer.Offset + offset);
		}

		public static float ReadSingle(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToSingle(buffer.Array, buffer.Offset + offset);
		}

		public static long ReadInt64(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToInt64(buffer.Array, buffer.Offset + offset);
		}

		public static double ReadDouble(this BufferSlice buffer, int offset)
		{
			return BitConverter.ToDouble(buffer.Array, buffer.Offset + offset);
		}

		public static decimal ReadDecimal(this BufferSlice buffer, int offset)
		{
			int num = buffer.ReadInt32(offset);
			int num2 = buffer.ReadInt32(offset + 4);
			int num3 = buffer.ReadInt32(offset + 8);
			int num4 = buffer.ReadInt32(offset + 12);
			return new decimal(new int[4] { num, num2, num3, num4 });
		}

		public static ObjectId ReadObjectId(this BufferSlice buffer, int offset)
		{
			return new ObjectId(buffer.Array, buffer.Offset + offset);
		}

		public static Guid ReadGuid(this BufferSlice buffer, int offset)
		{
			return new Guid(buffer.ReadBytes(offset, 16));
		}

		public static byte[] ReadBytes(this BufferSlice buffer, int offset, int count)
		{
			byte[] array = new byte[count];
			Buffer.BlockCopy(buffer.Array, buffer.Offset + offset, array, 0, count);
			return array;
		}

		public static DateTime ReadDateTime(this BufferSlice buffer, int offset)
		{
			long num = buffer.ReadInt64(offset);
			return num switch
			{
				0L => DateTime.MinValue, 
				3155378975999999999L => DateTime.MaxValue, 
				_ => new DateTime(num, DateTimeKind.Utc), 
			};
		}

		public static float[] ReadVector(this BufferSlice buffer, int offset)
		{
			ushort num = buffer.ReadUInt16(offset);
			offset += 2;
			float[] array = new float[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = BitConverter.ToSingle(buffer.Array, buffer.Offset + offset + i * 4);
			}
			return array;
		}

		public static PageAddress ReadPageAddress(this BufferSlice buffer, int offset)
		{
			return new PageAddress(buffer.ReadUInt32(offset), buffer[offset + 4]);
		}

		public static string ReadString(this BufferSlice buffer, int offset, int count)
		{
			return Encoding.UTF8.GetString(buffer.Array, buffer.Offset + offset, count);
		}

		public static string ReadCString(this BufferSlice buffer, int offset, out int length)
		{
			length = buffer.Count - buffer.Offset - offset;
			for (int i = offset + buffer.Offset; i < buffer.Count; i++)
			{
				if (buffer[i] == 0)
				{
					length = i - buffer.Offset - offset + 1;
					break;
				}
			}
			return Encoding.UTF8.GetString(buffer.Array, buffer.Offset + offset, length - 1);
		}

		public static BsonValue ReadIndexKey(this BufferSlice buffer, int offset)
		{
			ExtendedLengthHelper.ReadLength(buffer[offset++], buffer[offset], out var type, out var length);
			switch (type)
			{
			case BsonType.Null:
				return BsonValue.Null;
			case BsonType.Int32:
				return buffer.ReadInt32(offset);
			case BsonType.Int64:
				return buffer.ReadInt64(offset);
			case BsonType.Double:
				return buffer.ReadDouble(offset);
			case BsonType.Decimal:
				return buffer.ReadDecimal(offset);
			case BsonType.String:
				offset++;
				return buffer.ReadString(offset, length);
			case BsonType.Document:
			{
				using BufferReader bufferReader2 = new BufferReader(buffer);
				bufferReader2.Skip(offset);
				return bufferReader2.ReadDocument().GetValue();
			}
			case BsonType.Array:
			{
				using BufferReader bufferReader = new BufferReader(buffer);
				bufferReader.Skip(offset);
				return bufferReader.ReadArray().GetValue();
			}
			case BsonType.Binary:
				offset++;
				return buffer.ReadBytes(offset, length);
			case BsonType.ObjectId:
				return buffer.ReadObjectId(offset);
			case BsonType.Guid:
				return buffer.ReadGuid(offset);
			case BsonType.Boolean:
				return buffer[offset] != 0;
			case BsonType.DateTime:
				return buffer.ReadDateTime(offset);
			case BsonType.MinValue:
				return BsonValue.MinValue;
			case BsonType.MaxValue:
				return BsonValue.MaxValue;
			case BsonType.Vector:
				return buffer.ReadVector(offset);
			default:
				throw new NotImplementedException();
			}
		}

		public static void Write(this BufferSlice buffer, bool value, int offset)
		{
			buffer.Array[buffer.Offset + offset] = (value ? ((byte)1) : ((byte)0));
		}

		public static void Write(this BufferSlice buffer, byte value, int offset)
		{
			buffer.Array[buffer.Offset + offset] = value;
		}

		public static void Write(this BufferSlice buffer, short value, int offset)
		{
			value.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, ushort value, int offset)
		{
			value.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, int value, int offset)
		{
			value.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, uint value, int offset)
		{
			value.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, float value, int offset)
		{
			BitConverter.GetBytes(value).CopyTo(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, long value, int offset)
		{
			value.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, double value, int offset)
		{
			value.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, decimal value, int offset)
		{
			int[] bits = decimal.GetBits(value);
			buffer.Write(bits[0], offset);
			buffer.Write(bits[1], offset + 4);
			buffer.Write(bits[2], offset + 8);
			buffer.Write(bits[3], offset + 12);
		}

		public static void Write(this BufferSlice buffer, DateTime value, int offset)
		{
			value.ToUniversalTime().Ticks.ToBytes(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, PageAddress value, int offset)
		{
			value.PageID.ToBytes(buffer.Array, buffer.Offset + offset);
			buffer[offset + 4] = value.Index;
		}

		public static void Write(this BufferSlice buffer, Guid value, int offset)
		{
			buffer.Write(value.ToByteArray(), offset);
		}

		public static void Write(this BufferSlice buffer, float[] value, int offset)
		{
			buffer.Write((ushort)value.Length, offset);
			offset += 2;
			for (int i = 0; i < value.Length; i++)
			{
				BitConverter.GetBytes(value[i]).CopyTo(buffer.Array, buffer.Offset + offset);
				offset += 4;
			}
		}

		public static void Write(this BufferSlice buffer, ObjectId value, int offset)
		{
			value.ToByteArray(buffer.Array, buffer.Offset + offset);
		}

		public static void Write(this BufferSlice buffer, byte[] value, int offset)
		{
			Buffer.BlockCopy(value, 0, buffer.Array, buffer.Offset + offset, value.Length);
		}

		public static void Write(this BufferSlice buffer, string value, int offset)
		{
			Encoding.UTF8.GetBytes(value, 0, value.Length, buffer.Array, buffer.Offset + offset);
		}

		public static void WriteIndexKey(this BufferSlice buffer, BsonValue value, int offset)
		{
			if (value.IsString)
			{
				string asString = value.AsString;
				ushort length = (ushort)Encoding.UTF8.GetByteCount(asString);
				ExtendedLengthHelper.WriteLength(BsonType.String, length, out var typeByte, out var lengthByte);
				buffer[offset++] = typeByte;
				buffer[offset++] = lengthByte;
				buffer.Write(asString, offset);
				return;
			}
			if (value.IsBinary)
			{
				byte[] asBinary = value.AsBinary;
				ExtendedLengthHelper.WriteLength(BsonType.Binary, (ushort)asBinary.Length, out var typeByte2, out var lengthByte2);
				buffer[offset++] = typeByte2;
				buffer[offset++] = lengthByte2;
				buffer.Write(asBinary, offset);
				return;
			}
			buffer[offset++] = (byte)value.Type;
			switch (value.Type)
			{
			case BsonType.Int32:
				buffer.Write(value.AsInt32, offset);
				break;
			case BsonType.Int64:
				buffer.Write(value.AsInt64, offset);
				break;
			case BsonType.Double:
				buffer.Write(value.AsDouble, offset);
				break;
			case BsonType.Decimal:
				buffer.Write(value.AsDecimal, offset);
				break;
			case BsonType.Document:
			{
				using BufferWriter bufferWriter2 = new BufferWriter(buffer);
				bufferWriter2.Skip(offset);
				bufferWriter2.WriteDocument(value.AsDocument, recalc: true);
				break;
			}
			case BsonType.Array:
			{
				using BufferWriter bufferWriter = new BufferWriter(buffer);
				bufferWriter.Skip(offset);
				bufferWriter.WriteArray(value.AsArray, recalc: true);
				break;
			}
			case BsonType.ObjectId:
				buffer.Write(value.AsObjectId, offset);
				break;
			case BsonType.Guid:
				buffer.Write(value.AsGuid, offset);
				break;
			case BsonType.Boolean:
				buffer[offset] = (value.AsBoolean ? ((byte)1) : ((byte)0));
				break;
			case BsonType.DateTime:
				buffer.Write(value.AsDateTime, offset);
				break;
			case BsonType.Vector:
				buffer.Write(value.AsVector, offset);
				break;
			default:
				throw new NotImplementedException();
			case BsonType.MinValue:
			case BsonType.Null:
			case BsonType.MaxValue:
				break;
			}
		}
	}
	internal static class DateExtensions
	{
		public static DateTime Truncate(this DateTime dt)
		{
			if (dt == DateTime.MaxValue || dt == DateTime.MinValue)
			{
				return dt;
			}
			return new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Millisecond, dt.Kind);
		}

		public static int MonthDifference(this DateTime startDate, DateTime endDate)
		{
			int num = endDate.Month + endDate.Year * 12 - (startDate.Month + startDate.Year * 12);
			double num2 = (endDate - endDate.AddMonths(1)).Days;
			return Convert.ToInt32(Math.Truncate((double)num + (double)(startDate.Day - endDate.Day) / num2));
		}

		public static int YearDifference(this DateTime startDate, DateTime endDate)
		{
			int num = endDate.Year - startDate.Year;
			if (startDate.Month == endDate.Month && endDate.Day < startDate.Day)
			{
				num--;
			}
			else if (endDate.Month < startDate.Month)
			{
				num--;
			}
			return num;
		}
	}
	internal static class DictionaryExtensions
	{
		public static T GetOrDefault<K, T>(this IDictionary<K, T> dict, K key, T defaultValue = default(T))
		{
			if (dict.TryGetValue(key, out var value))
			{
				return value;
			}
			return defaultValue;
		}

		public static T GetOrAdd<K, T>(this IDictionary<K, T> dict, K key, Func<K, T> valueFactoy)
		{
			if (!dict.TryGetValue(key, out var value))
			{
				value = valueFactoy(key);
				dict.Add(key, value);
			}
			return value;
		}

		public static void ParseKeyValue(this IDictionary<string, string> dict, string connectionString)
		{
			int position = 0;
			while (position < connectionString.Length)
			{
				EatWhitespace();
				string key = ReadKey();
				EatWhitespace();
				string value = ReadValue();
				dict[key] = value;
			}
			void EatWhitespace()
			{
				for (; position < connectionString.Length && (connectionString[position] == ' ' || connectionString[position] == '\t' || connectionString[position] == '\f'); position++)
				{
				}
			}
			string ReadKey()
			{
				StringBuilder stringBuilder2 = new StringBuilder();
				for (; position < connectionString.Length; position++)
				{
					char c3 = connectionString[position];
					if (c3 == '=')
					{
						position++;
						return stringBuilder2.ToString().Trim();
					}
					stringBuilder2.Append(c3);
				}
				return stringBuilder2.ToString().Trim();
			}
			string ReadValue()
			{
				StringBuilder stringBuilder = new StringBuilder();
				char c = ((connectionString[position] == '"') ? '"' : ((connectionString[position] == '\'') ? '\'' : ' '));
				if (c != ' ')
				{
					position++;
				}
				for (; position < connectionString.Length; position++)
				{
					char c2 = connectionString[position];
					if (c == ' ')
					{
						if (c2 == ';')
						{
							position++;
							return stringBuilder.ToString().Trim();
						}
					}
					else if (c != ' ' && c2 == c)
					{
						if (connectionString[position - 1] != '\\')
						{
							position++;
							EatWhitespace();
							if (position < connectionString.Length && connectionString[position] == ';')
							{
								position++;
							}
							return stringBuilder.ToString();
						}
						stringBuilder.Length--;
					}
					stringBuilder.Append(c2);
				}
				return stringBuilder.ToString().Trim();
			}
		}

		public static T GetValue<T>(this Dictionary<string, string> dict, string key, T defaultValue = default(T))
		{
			try
			{
				if (!dict.TryGetValue(key, out var value))
				{
					return defaultValue;
				}
				if (typeof(T) == typeof(TimeSpan))
				{
					if (Regex.IsMatch(value, "^\\d+$", RegexOptions.Compiled))
					{
						return (T)(object)TimeSpan.FromSeconds(Convert.ToInt32(value));
					}
					return (T)(object)TimeSpan.Parse(value);
				}
				if (typeof(T).GetTypeInfo().IsEnum)
				{
					return (T)Enum.Parse(typeof(T), value, ignoreCase: true);
				}
				return (T)Convert.ChangeType(value, typeof(T));
			}
			catch (Exception)
			{
				throw new LiteException(0, "Invalid connection string value type for `" + key + "`");
			}
		}

		public static long GetFileSize(this Dictionary<string, string> dict, string key, long defaultValue)
		{
			string value = dict.GetValue<string>(key);
			if (value == null)
			{
				return defaultValue;
			}
			Match match = Regex.Match(value, "^(\\d+)\\s*([tgmk])?(b|byte|bytes)?$", RegexOptions.IgnoreCase);
			if (!match.Success)
			{
				return 0L;
			}
			long num = Convert.ToInt64(match.Groups[1].Value);
			string text = match.Groups[2].Value.ToLower();
			switch (text)
			{
			default:
				if (text.Length != 0)
				{
					break;
				}
				return num;
			case "t":
				return num * 1024 * 1024 * 1024 * 1024;
			case "g":
				return num * 1024 * 1024 * 1024;
			case "m":
				return num * 1024 * 1024;
			case "k":
				return num * 1024;
			case null:
				break;
			}
			return 0L;
		}
	}
	internal static class ExpressionExtensions
	{
		private static readonly Regex _removeSelect = new Regex("\\.Select\\s*\\(\\s*\\w+\\s*=>\\s*\\w+\\.", RegexOptions.Compiled);

		private static readonly Regex _removeList = new Regex("\\.get_Item\\(\\d+\\)", RegexOptions.Compiled);

		private static readonly Regex _removeArray = new Regex("\\[\\d+\\]", RegexOptions.Compiled);

		public static string GetPath(this Expression expr)
		{
			while (expr.NodeType == ExpressionType.Convert || expr.NodeType == ExpressionType.ConvertChecked)
			{
				expr = ((UnaryExpression)expr).Operand;
			}
			while (expr.NodeType == ExpressionType.Lambda && ((LambdaExpression)expr).Body is UnaryExpression unaryExpression)
			{
				expr = unaryExpression.Operand;
			}
			string text = expr.ToString();
			int num = text.IndexOf('.');
			string input = ((num < 0) ? text : text.Substring(num + 1).TrimEnd(new char[1] { ')' }));
			input = _removeList.Replace(input, "");
			input = _removeArray.Replace(input, "");
			return _removeSelect.Replace(input, ".").Replace(")", "");
		}
	}
	internal static class HashSetExtensions
	{
		public static HashSet<T> AddRange<T>(this HashSet<T> hash, IEnumerable<T> items)
		{
			if (items == null)
			{
				return hash;
			}
			foreach (T item in items)
			{
				hash.Add(item);
			}
			return hash;
		}
	}
	internal static class IOExceptionExtensions
	{
		private const int ERROR_SHARING_VIOLATION = 32;

		private const int ERROR_LOCK_VIOLATION = 33;

		public static bool IsLocked(this IOException ex)
		{
			int num = Marshal.GetHRForException(ex) & 0xFFFF;
			if (num != 32)
			{
				return num == 33;
			}
			return true;
		}

		public static void WaitIfLocked(this IOException ex, int timerInMilliseconds)
		{
			if (ex.IsLocked())
			{
				if (timerInMilliseconds > 0)
				{
					Task.Delay(timerInMilliseconds).Wait();
				}
				return;
			}
			throw ex;
		}
	}
	internal static class LinqExtensions
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass2_0<TSource, TKey>
		{
			public IEqualityComparer<TKey> comparer;

			public IEnumerable<TSource> source;

			public Func<TSource, TKey> keySelector;
		}

		[CompilerGenerated]
		private sealed class <Batch>d__0<T> : IEnumerable<IEnumerable<T>>, IEnumerable, IEnumerator<IEnumerable<T>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IEnumerable<T> <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<T> source;

			public IEnumerable<T> <>3__source;

			private int batchSize;

			public int <>3__batchSize;

			private IEnumerator<T> <enumerator>5__2;

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

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

			[DebuggerHidden]
			public <Batch>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 == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<enumerator>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<enumerator>5__2 = source.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<enumerator>5__2.MoveNext())
					{
						<>2__current = YieldBatchElements(<enumerator>5__2, batchSize - 1);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<enumerator>5__2 = 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 (<enumerator>5__2 != null)
				{
					<enumerator>5__2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<IEnumerable<T>> IEnumerable<IEnumerable<T>>.GetEnumerator()
			{
				<Batch>d__0<T> <Batch>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Batch>d__ = this;
				}
				else
				{
					<Batch>d__ = new <Batch>d__0<T>(0);
				}
				<Batch>d__.source = <>3__source;
				<Batch>d__.batchSize = <>3__batchSize;
				return <Batch>d__;
			}

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

		[CompilerGenerated]
		private sealed class <IsLast>d__3<T> : IEnumerable<LastItem<T>>, IEnumerable, IEnumerator<LastItem<T>>, IEnumerator, IDisposable where T : class
		{
			private int <>1__state;

			private LastItem<T> <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<T> source;

			public IEnumerable<T> <>3__source;

			private IEnumerator<T> <>7__wrap1;

			private T <item>5__3;

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

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

			[DebuggerHidden]
			public <IsLast>d__3(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();
					}
				}
				<>7__wrap1 = null;
				<item>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					T val;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						val = null;
						<>7__wrap1 = source.GetEnumerator();
						<>1__state = -3;
						goto IL_00a8;
					case 1:
						<>1__state = -3;
						goto IL_0095;
					case 2:
						{
							<>1__state = -1;
							break;
						}
						IL_00a8:
						if (<>7__wrap1.MoveNext())
						{
							<item>5__3 = <>7__wrap1.Current;
							if (val != null)
							{
								<>2__current = new LastItem<T>
								{
									Item = val,
									IsLast = false
								};
								<>1__state = 1;
								return true;
							}
							goto IL_0095;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						if (val != null)
						{
							<>2__current = new LastItem<T>
							{
								Item = val,
								IsLast = true
							};
							<>1__state = 2;
							return true;
						}
						break;
						IL_0095:
						val = <item>5__3;
						<item>5__3 = null;
						goto IL_00a8;
					}
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<LastItem<T>> IEnumerable<LastItem<T>>.GetEnumerator()
			{
				<IsLast>d__3<T> <IsLast>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<IsLast>d__ = this;
				}
				else
				{
					<IsLast>d__ = new <IsLast>d__3<T>(0);
				}
				<IsLast>d__.source = <>3__source;
				return <IsLast>d__;
			}

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

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

			private T <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<T> source;

			public IEnumerator<T> <>3__source;

			private int batchSize;

			public int <>3__batchSize;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = source.Current;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < batchSize && source.MoveNext())
				{
					<>2__current = source.Current;
					<>1__state = 2;
					return true;
				}
				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]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<YieldBatchElements>d__1<T> <YieldBatchElements>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<YieldBatchElements>d__ = this;
				}
				else
				{
					<YieldBatchElements>d__ = new <YieldBatchElements>d__1<T>(0);
				}
				<YieldBatchElements>d__.source = <>3__source;
				<YieldBatchElements>d__.batchSize = <>3__batchSize;
				return <YieldBatchElements>d__;
			}

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

		[IteratorStateMachine(typeof(<Batch>d__0<>))]
		public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int batchSize)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Batch>d__0<T>(-2)
			{
				<>3__source = source,
				<>3__batchSize = batchSize
			};
		}

		[IteratorStateMachine(typeof(<YieldBatchElements>d__1<>))]
		private static IEnumerable<T> YieldBatchElements<T>(IEnumerator<T> source, int batchSize)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <YieldBatchElements>d__1<T>(-2)
			{
				<>3__source = source,
				<>3__batchSize = batchSize
			};
		}

		public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			<>c__DisplayClass2_0<TSource, TKey> <>c__DisplayClass2_ = new <>c__DisplayClass2_0<TSource, TKey>();
			<>c__DisplayClass2_.comparer = comparer;
			<>c__DisplayClass2_.source = source;
			<>c__DisplayClass2_.keySelector = keySelector;
			if (<>c__DisplayClass2_.source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (<>c__DisplayClass2_.keySelector == null)
			{
				throw new ArgumentNullException("keySelector");
			}
			return _();
			[IteratorStateMachine(typeof(<>c__DisplayClass2_0<, >.<<DistinctBy>g___|0>d))]
			IEnumerable<TSource> _()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass2_0<TSource, TKey>.<<DistinctBy>g___|0>d(-2)
				{
					<>4__this = <>c__DisplayClass2_
				};
			}
		}

		[IteratorStateMachine(typeof(<IsLast>d__3<>))]
		public static IEnumerable<LastItem<T>> IsLast<T>(this IEnumerable<T> source) where T : class
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <IsLast>d__3<T>(-2)
			{
				<>3__source = source
			};
		}
	}
	internal struct LastItem<T>
	{
		public T Item { get; set; }

		public bool IsLast { get; set; }
	}
	internal static class StreamExtensions
	{
		public static void FlushToDisk(this Stream stream)
		{
			if (stream is FileStream fileStream)
			{
				fileStream.Flush(flushToDisk: true);
			}
			else
			{
				stream.Flush();
			}
		}
	}
	internal static class StringExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNullOrWhiteSpace(this string str)
		{
			return string.IsNullOrWhiteSpace(str);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNullOrEmpty(this string str)
		{
			return string.IsNullOrEmpty(str);
		}

		public static bool IsWord(this string str)
		{
			if (string.IsNullOrWhiteSpace(str))
			{
				return false;
			}
			for (int i = 0; i < str.Length; i++)
			{
				if (!Tokenizer.IsWordChar(str[i], i == 0))
				{
					return false;
				}
			}
			return true;
		}

		public static bool SqlLike(this string str, string pattern, Collation collation)
		{
			bool flag = true;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			bool flag6 = false;
			int num = -1;
			int i = 0;
			char c = '\0';
			for (int j = 0; j < str.Length; j++)
			{
				char c2 = str[j];
				if (i < pattern.Length)
				{
					c = pattern[i];
					if (!flag2 && c == '%')
					{
						num = i;
						flag2 = true;
						for (; i < pattern.Length && pattern[i] == '%'; i++)
						{
						}
						c = ((i < pattern.Length) ? pattern[i] : '\0');
					}
					else if (c == '_')
					{
						flag3 = true;
						i++;
					}
				}
				if (flag2)
				{
					if (collation.Compare(c2.ToString(), c.ToString()) == 0)
					{
						flag2 = false;
						i++;
					}
				}
				else if (flag3)
				{
					flag3 = false;
				}
				else if (flag4 || flag5)
				{
					if (flag4)
					{
						if (num < 0)
						{
							flag = false;
							break;
						}
						i = num;
					}
					flag5 = (flag4 = false);
				}
				else if (collation.Compare(c2.ToString(), c.ToString()) == 0)
				{
					i++;
				}
				else
				{
					if (num < 0)
					{
						flag = false;
						break;
					}
					int num2 = i - num - 1;
					j -= num2;
					i = num;
				}
			}
			flag6 = i >= pattern.Length;
			if (flag && !flag6)
			{
				bool flag7 = true;
				for (int k = i; k < pattern.Length; k++)
				{
					if (pattern[k] != '%')
					{
						flag7 = false;
						break;
					}
				}
				if (flag7)
				{
					flag6 = true;
				}
			}
			return flag && flag6;
		}

		public static string SqlLikeStartsWith(this string str, out bool hasMore)
		{
			int i = 0;
			int length = str.Length;
			char c = '\0';
			for (; i < length; i++)
			{
				c = str[i];
				if (c == '%' || c == '_')
				{
					break;
				}
			}
			hasMore = i != length && i != length - 1;
			return str.Substring(0, i);
		}
	}
	internal static class TypeInfoExtensions
	{
		public static bool IsAnonymousType(this Type type)
		{
			if (type.FullName.Contains("AnonymousType"))
			{
				return type.GetTypeInfo().GetCustomAttributes(typeof(CompilerGeneratedAttribute), inherit: false).Any();
			}
			return false;
		}

		public static bool IsEnumerable(this Type type)
		{
			if (type != typeof(string))
			{
				return typeof(IEnumerable).IsAssignableFrom(type);
			}
			return false;
		}
	}
	internal static class FileHelper
	{
		public static string GetSuffixFile(string filename, string suffix = "-temp", bool checkIfExists = true)
		{
			int num = 0;
			string text = Path.Combine(Path.GetDirectoryName(filename), Path.GetFileNameWithoutExtension(filename) + suffix + Path.GetExtension(filename));
			while (checkIfExists && File.Exists(text))
			{
				string? directoryName = Path.GetDirectoryName(filename);
				string[] obj = new string[5]
				{
					Path.GetFileNameWithoutExtension(filename),
					suffix,
					"-",
					null,
					null
				};
				int num2 = ++num;
				obj[3] = num2.ToString();
				obj[4] = Path.GetExtension(filename);
				text = Path.Combine(directoryName, string.Concat(obj));
			}
			return text;
		}

		public static string GetLogFile(string filename)
		{
			return GetSuffixFile(filename, "-log", checkIfExists: false);
		}

		public static string GetTempFile(string filename)
		{
			return GetSuffixFile(filename, "-tmp", checkIfExists: false);
		}

		public static bool IsFileLocked(string filename)
		{
			FileStream fileStream = null;
			FileInfo fileInfo = new FileInfo(filename);
			try
			{
				fileStream = fileInfo.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
			}
			catch (IOException ex)
			{
				return ex.IsLocked();
			}
			finally
			{
				fileStream?.Dispose();
			}
			return false;
		}

		public static bool TryExec(int timeout, Action action)
		{
			DateTime dateTime = DateTime.UtcNow.AddSeconds(timeout);
			do
			{
				try
				{
					action();
					return true;
				}
				catch (IOException ex)
				{
					ex.WaitIfLocked(25);
				}
			}
			while (DateTime.UtcNow < dateTime);
			return false;
		}

		public static void Exec(int timeout, Action action)
		{
			DateTime dateTime = DateTime.UtcNow.AddSeconds(timeout);
			IOException ex2;
			do
			{
				try
				{
					action();
					return;
				}
				catch (IOException ex)
				{
					ex2 = ex;
					ex.WaitIfLocked(25);
				}
			}
			while (DateTime.UtcNow < dateTime);
			throw ex2;
		}

		public static long ParseFileSize(string size)
		{
			Match match = Regex.Match(size, "^(\\d+)\\s*([tgmk])?(b|byte|bytes)?$", RegexOptions.IgnoreCase);
			if (!match.Success)
			{
				return 0L;
			}
			long num = Convert.ToInt64(match.Groups[1].Value);
			string text = match.Groups[2].Value.ToLower();
			switch (text)
			{
			default:
				if (text.Length != 0)
				{
					break;
				}
				return num;
			case "t":
				return num * 1024 * 1024 * 1024 * 1024;
			case "g":
				return num * 1024 * 1024 * 1024;
			case "m":
				return num * 1024 * 1024;
			case "k":
				return num * 1024;
			case null:
				break;
			}
			return 0L;
		}

		public static string FormatFileSize(long byteCount)
		{
			string[] array = new string[5] { "B", "KB", "MB", "GB", "TB" };
			if (byteCount == 0L)
			{
				return "0" + array[0];
			}
			long num = Math.Abs(byteCount);
			long num2 = Convert.ToInt64(Math.Floor(Math.Log(num, 1024.0)));
			double num3 = Math.Round((double)num / Math.Pow(1024.0, num2), 1);
			return (double)Math.Sign(byteCount) * num3 + array[num2];
		}
	}
	internal class LCID
	{
		private static readonly IDictionary<int, string> _mappings = new Dictionary<int, string>
		{
			[1] = "ar",
			[2] = "bg",
			[3] = "ca",
			[4] = "zh-Hans",
			[5] = "cs",
			[6] = "da",
			[7] = "de",
			[8] = "el",
			[9] = "en",
			[10] = "es",
			[11] = "fi",
			[12] = "fr",
			[13] = "he",
			[14] = "hu",
			[15] = "is",
			[16] = "it",
			[17] = "ja",
			[18] = "ko",
			[19] = "nl",
			[20] = "no",
			[21] = "pl",
			[22] = "pt",
			[23] = "rm",
			[24] = "ro",
			[25] = "ru",
			[26] = "hr",
			[27] = "sk",
			[28] = "sq",
			[29] = "sv",
			[30] = "th",
			[31] = "tr",
			[32] = "ur",
			[33] = "id",
			[34] = "uk",
			[35] = "be",
			[36] = "sl",
			[37] = "et",
			[38] = "lv",
			[39] = "lt",
			[40] = "tg",
			[41] = "fa",
			[42] = "vi",
			[43] = "hy",
			[44] = "az",
			[45] = "eu",
			[46] = "hsb",
			[47] = "mk",
			[48] = "st",
			[49] = "ts",
			[50] = "tn",
			[51] = "ve",
			[52] = "xh",
			[53] = "zu",
			[54] = "af",
			[55] = "ka",
			[56] = "fo",
			[57] = "hi",
			[58] = "mt",
			[59] = "se",
			[60] = "ga",
			[61] = "yi",
			[62] = "ms",
			[63] = "kk",
			[64] = "ky",
			[65] = "sw",
			[66] = "tk",
			[67] = "uz",
			[68] = "tt",
			[69] = "bn",
			[70] = "pa",
			[71] = "gu",
			[72] = "or",
			[73] = "ta",
			[74] = "te",
			[75] = "kn",
			[76] = "ml",
			[77] = "as",
			[78] = "mr",
			[79] = "sa",
			[80] = "mn",
			[81] = "bo",
			[82] = "cy",
			[83] = "km",
			[84] = "lo",
			[85] = "my",
			[86] = "gl",
			[87] = "kok",
			[88] = "mni",
			[89] = "sd",
			[90] = "syr",
			[91] = "si",
			[92] = "chr",
			[93] = "iu",
			[94] = "am",
			[95] = "tzm",
			[96] = "ks",
			[97] = "ne",
			[98] = "fy",
			[99] = "ps",
			[100] = "fil",
			[101] = "dv",
			[102] = "bin",
			[103] = "ff",
			[104] = "ha",
			[105] = "ibb",
			[106] = "yo",
			[107] = "quz",
			[108] = "nso",
			[109] = "ba",
			[110] = "lb",
			[111] = "kl",
			[112] = "ig",
			[113] = "kr",
			[114] = "om",
			[115] = "ti",
			[116] = "gn",
			[117] = "haw",
			[118] = "la",
			[119] = "so",
			[120] = "ii",
			[121] = "pap",
			[122] = "arn",
			[124] = "moh",
			[126] = "br",
			[127] = "",
			[128] = "ug",
			[129] = "mi",
			[130] = "oc",
			[131] = "co",
			[132] = "gsw",
			[133] = "sah",
			[134] = "quc",
			[135] = "rw",
			[136] = "wo",
			[140] = "prs",
			[145] = "gd",
			[146] = "ku",
			[1025] = "ar-SA",
			[1026] = "bg-BG",
			[1027] = "ca-ES",
			[1028] = "zh-TW",
			[1029] = "cs-CZ",
			[1030] = "da-DK",
			[1031] = "de-DE",
			[1032] = "el-GR",
			[1033] = "en-US",
			[1035] = "fi-FI",
			[1036] = "fr-FR",
			[1037] = "he-IL",
			[1038] = "hu-HU",
			[1039] = "is-IS",
			[1040] = "it-IT",
			[1041] = "ja-JP",
			[1042] = "ko-KR",
			[1043] = "nl-NL",
			[1044] = "nb-NO",
			[1045] = "pl-PL",
			[1046] = "pt-BR",
			[1047] = "rm-CH",
			[1048] = "ro-RO",
			[1049] = "ru-RU",
			[1050] = "hr-HR",
			[1051] = "sk-SK",
			[1052] = "sq-AL",
			[1053] = "sv-SE",
			[1054] = "th-TH",
			[1055] = "tr-TR",
			[1056] = "ur-PK",
			[1057] = "id-ID",
			[1058] = "uk-UA",
			[1059] = "be-BY",
			[1060] = "sl-SI",
			[1061] = "et-EE",
			[1062] = "lv-LV",
			[1063] = "lt-LT",
			[1064] = "tg-Cyrl-TJ",
			[1065] = "fa-IR",
			[1066] = "vi-VN",
			[1067] = "hy-AM",
			[1068] = "az-Latn-AZ",
			[1069] = "eu-ES",
			[1070] = "hsb-DE",
			[1071] = "mk-MK",
			[1072] = "st-ZA",
			[1073] = "ts-ZA",
			[1074] = "tn-ZA",
			[1075] = "ve-ZA",
			[1076] = "xh-ZA",
			[1077] = "zu-ZA",
			[1078] = "af-ZA",
			[1079] = "ka-GE",
			[1080] = "fo-FO",
			[1081] = "hi-IN",
			[1082] = "mt-MT",
			[1083] = "se-NO",
			[1085] = "yi-001",
			[1086] = "ms-MY",
			[1087] = "kk-KZ",
			[1088] = "ky-KG",
			[1089] = "sw-KE",
			[1090] = "tk-TM",
			[1091] = "uz-Latn-UZ",
			[1092] = "tt-RU",
			[1093] = "bn-IN",
			[1094] = "pa-IN",
			[1095] = "gu-IN",
			[1096] = "or-IN",
			[1097] = "ta-IN",
			[1098] = "te-IN",
			[1099] = "kn-IN",
			[1100] = "ml-IN",
			[1101] = "as-IN",
			[1102] = "mr-IN",
			[1103] = "sa-IN",
			[1104] = "mn-MN",
			[1105] = "bo-CN",
			[1106] = "cy-GB",
			[1107] = "km-KH",
			[1108] = "lo-LA",
			[1109] = "my-MM",
			[1110] = "gl-ES",
			[1111] = "kok-IN",
			[1112] = "mni-IN",
			[1113] = "sd-Deva-IN",
			[1114] = "syr-SY",
			[1115] = "si-LK",
			[1116] = "chr-Cher-US",
			[1117] = "iu-Cans-CA",
			[1118] = "am-ET",
			[1119] = "tzm-Arab-MA",
			[1120] = "ks-Arab",
			[1121] = "ne-NP",
			[1122] = "fy-NL",
			[1123] = "ps-AF",
			[1124] = "fil-PH",
			[1125] = "dv-MV",
			[1126] = "bin-NG",
			[1127] = "ff-NG",
			[1128] = "ha-Latn-NG",
			[1129] = "ibb-NG",
			[1130] = "yo-NG",
			[1131] = "quz-BO",
			[1132] = "nso-ZA",
			[1133] = "ba-RU",
			[1134] = "lb-LU",
			[1135] = "kl-GL",
			[1136] = "ig-NG",
			[1137] = "kr-NG",
			[1138] = "om-ET",
			[1139] = "ti-ET",
			[1140] = "gn-PY",
			[1141] = "haw-US",
			[1142] = "la-001",
			[1143] = "so-SO",
			[1144] = "ii-CN",
			[1145] = "pap-029",
			[1146] = "arn-CL",
			[1148] = "moh-CA",
			[1150] = "br-FR",
			[1152] = "ug-CN",
			[1153] = "mi-NZ",
			[1154] = "oc-FR",
			[1155] = "co-FR",
			[1156] = "gsw-FR",
			[1157] = "sah-RU",
			[1158] = "quc-Latn-GT",
			[1159] = "rw-RW",
			[1160] = "wo-SN",
			[1164] = "prs-AF",
			[1169] = "gd-GB",
			[1170] = "ku-Arab-IQ",
			[2049] = "ar-IQ",
			[2051] = "ca-ES-valencia",
			[2052] = "zh-CN",
			[2055] = "de-CH",
			[2057] = "en-GB",
			[2058] = "es-MX",
			[2060] = "fr-BE",
			[2064] = "it-CH",
			[2067] = "nl-BE",
			[2068] = "nn-NO",
			[2070] = "pt-PT",
			[2072] = "ro-MD",
			[2073] = "ru-MD",
			[2077] = "sv-FI",
			[2080] = "ur-IN",
			[2092] = "az-Cyrl-AZ",
			[2094] = "dsb-DE",
			[2098] = "tn-BW",
			[2107] = "se-SE",
			[2108] = "ga-IE",
			[2110] = "ms-BN",
			[2115] = "uz-Cyrl-UZ",
			[2117] = "bn-BD",
			[2118] = "pa-Arab-PK",
			[2121] = "ta-LK",
			[2128] = "mn-Mong-CN",
			[2137] = "sd-Arab-PK",
			[2141] = "iu-Latn-CA",
			[2143] = "tzm-Latn-DZ",
			[2144] = "ks-Deva-IN",
			[2145] = "ne-IN",
			[2151] = "ff-Latn-SN",
			[2155] = "quz-EC",
			[2163] = "ti-ER",
			[3073] = "ar-EG",
			[3076] = "zh-HK",
			[3079] = "de-AT",
			[3081] = "en-AU",
			[3082] = "es-ES",
			[3084] = "fr-CA",
			[3131] = "se-FI",
			[3152] = "mn-Mong-MN",
			[3153] = "dz-BT",
			[3179] = "quz-PE",
			[4097] = "ar-LY",
			[4100] = "zh-SG",
			[4103] = "de-LU",
			[4105] = "en-CA",
			[4106] = "es-GT",
			[4108] = "fr-CH",
			[4122] = "hr-BA",
			[4155] = "smj-NO",
			[4191] = "tzm-Tfng-MA",
			[5121] = "ar-DZ",
			[5124] = "zh-MO",
			[5127] = "de-LI",
			[5129] = "en-NZ",
			[5130] = "es-CR",
			[5132] = "fr-LU",
			[5146] = "bs-Latn-BA",
			[5179] = "smj-SE",
			[6145] = "ar-MA",
			[6153] = "en-IE",
			[6154] = "es-PA",
			[6156] = "fr-MC",
			[6170] = "sr-Latn-BA",
			[6203] = "sma-NO",
			[7169] = "ar-TN",
			[7177] = "en-ZA",
			[7178] = "es-DO",
			[7180] = "fr-029",
			[7194] = "sr-Cyrl-BA",
			[7227] = "sma-SE",
			[8193] = "ar-OM",
			[8201] = "en-JM",
			[8202] = "es-VE",
			[8204] = "fr-RE",
			[8218] = "bs-Cyrl-BA",
			[8251] = "sms-FI",
			[9217] = "ar-YE",
			[9225] = "en-029",
			[9226] = "es-CO",
			[9228] = "fr-CD",
			[9242] = "sr-Latn-RS",
			[9275] = "smn-FI",
			[10241] = "ar-SY",
			[10249] = "en-BZ",
			[10250] = "es-PE",
			[10252] = "fr-SN",
			[10266] = "sr-Cyrl-RS",
			[11265] = "ar-JO",
			[11273] = "en-TT",
			[11274] = "es-AR",
			[11276] = "fr-CM",
			[11290] = "sr-Latn-ME",
			[12289] = "ar-LB",
			[12297] = "en-ZW",
			[12298] = "es-EC",
			[12300] = "fr-CI",
			[12314] = "sr-Cyrl-ME",
			[13313] = "ar-KW",
			[13321] = "en-PH",
			[13322] = "es-CL",
			[13324] = "fr-ML",
			[14337] = "ar-AE",
			[14345] = "en-ID",
			[14346] = "es-UY",
			[14348] = "fr-MA",
			[15361] = "ar-BH",
			[15369] = "en-HK",
			[15370] = "es-PY",
			[15372] = "fr-HT",
			[16385] = "ar-QA",
			[16393] = "en-IN",
			[16394] = "es-BO",
			[17417] = "en-MY",
			[17418] = "es-SV",
			[18441] = "en-SG",
			[18442] = "es-HN",
			[19466] = "es-NI",
			[20490] = "es-PR",
			[21514] = "es-US",
			[22538] = "es-419",
			[23562] = "es-CU",
			[25626] = "bs-Cyrl",
			[26650] = "bs-Latn",
			[27674] = "sr-Cyrl",
			[28698] = "sr-Latn",
			[28731] = "smn",
			[29740] = "az-Cyrl",
			[29755] = "sms",
			[30724] = "zh",
			[30740] = "nn",
			[30746] = "bs",
			[30764] = "az-Latn",
			[30779] = "sma",
			[30787] = "uz-Cyrl",
			[30800] = "mn-Cyrl",
			[30813] = "iu-Cans",
			[30815] = "tzm-Tfng",
			[31748] = "zh-Hant",
			[31764] = "nb",
			[31770] = "sr",
			[31784] = "tg-Cyrl",
			[31790] = "dsb",
			[31803] = "smj",
			[31811] = "uz-Latn",
			[31814] = "pa-Arab",
			[31824] = "mn-Mong",
			[31833] = "sd-Arab",
			[31836] = "chr-Cher",
			[31837] = "iu-Latn",
			[31839] = "tzm-Latn",
			[31847] = "ff-Latn",
			[31848] = "ha-Latn",
			[31878] = "quc-Latn",
			[31890] = "ku-Arab"
		};

		public static int Current
		{
			get
			{
				string current = CultureInfo.CurrentCulture.Name;
				KeyValuePair<int, string> keyValuePair = _mappings.FirstOrDefault((KeyValuePair<int, string> x) => x.Value == current);
				if (keyValuePair.Key == 0)
				{
					return 127;
				}
				return keyValuePair.Key;
			}
		}

		public static CultureInfo GetCulture(int lcid)
		{
			if (_mappings.TryGetValue(lcid, out var value))
			{
				return new CultureInfo(value);
			}
			throw new ArgumentException("Invalid LCID code");
		}

		public static int GetLCID(string culture)
		{
			foreach (KeyValuePair<int, string> mapping in _mappings)
			{
				if (mapping.Value == culture)
				{
					return mapping.Key;
				}
			}
			throw new LiteException(0, "Invalid culture name");
		}
	}
	internal class LiteException : Exception
	{
		public const int FILE_NOT_FOUND = 101;

		public const int DATABASE_SHUTDOWN = 102;

		public const int INVALID_DATABASE = 103;

		public const int FILE_SIZE_EXCEEDED = 105;

		public const int COLLECTION_LIMIT_EXCEEDED = 106;

		public const int INDEX_DROP_ID = 108;

		public const int INDEX_DUPLICATE_KEY = 110;

		public const int INVALID_INDEX_KEY = 111;

		public const int INDEX_NOT_FOUND = 112;

		public const int INVALID_DBREF = 113;

		public const int LOCK_TIMEOUT = 120;

		public const int INVALID_COMMAND = 121;

		public const int ALREADY_EXISTS_COLLECTION_NAME = 122;

		public const int ALREADY_OPEN_DATAFILE = 124;

		public const int INVALID_TRANSACTION_STATE = 126;

		public const int INDEX_NAME_LIMIT_EXCEEDED = 128;

		public const int INVALID_INDEX_NAME = 129;

		public const int INVALID_COLLECTION_NAME = 130;

		public const int TEMP_ENGINE_ALREADY_DEFINED = 131;

		public const int INVALID_EXPRESSION_TYPE = 132;

		public const int COLLECTION_NOT_FOUND = 133;

		public const int COLLECTION_ALREADY_EXIST = 134;

		public const int INDEX_ALREADY_EXIST = 135;

		public const int INVALID_UPDATE_FIELD = 136;

		public const int ENGINE_DISPOSED = 137;

		public const int INVALID_FORMAT = 200;

		public const int DOCUMENT_MAX_DEPTH = 201;

		public const int INVALID_CTOR = 202;

		public const int UNEXPECTED_TOKEN = 203;

		public const int INVALID_DATA_TYPE = 204;

		public const int PROPERTY_NOT_MAPPED = 206;

		public const int INVALID_TYPED_NAME = 207;

		public const int PROPERTY_READ_WRITE = 209;

		public const int INITIALSIZE_CRYPTO_NOT_SUPPORTED = 210;

		public const int INVALID_INITIALSIZE = 211;

		public const int INVALID_NULL_CHAR_STRING = 212;

		public const int INVALID_FREE_SPACE_PAGE = 213;

		public const int DATA_TYPE_NOT_ASSIGNABLE = 214;

		public const int AVOID_USE_OF_PROCESS = 215;

		public const int NOT_ENCRYPTED = 216;

		public const int INVALID_PASSWORD = 217;

		public const int ILLEGAL_DESERIALIZATION_TYPE = 218;

		public const int ENTITY_INITIALIZATION_FAILED = 219;

		public const int MAPPER_NOT_FOUND = 220;

		public const int MAPPING_ERROR = 221;

		public const int INVALID_DATAFILE_STATE = 999;

		public int ErrorCode { get; private set; }

		public long Position { get; private set; }

		public bool IsCritical => ErrorCode >= 900;

		public LiteException(int code, string message)
			: base(message)
		{
			ErrorCode = code;
		}

		internal LiteException(int code, string message, params object[] args)
			: base(string.Format(message, args))
		{
			ErrorCode = code;
		}

		internal LiteException(int code, Exception inner, string message, params object[] args)
			: base(string.Format(message, args), inner)
		{
			ErrorCode = code;
		}

		internal static LiteException FileNotFound(object fileId)
		{
			return new LiteException(101, "File '{0}' not found.", fileId);
		}

		internal static LiteException DatabaseShutdown()
		{
			return new LiteException(102, "Database is in shutdown process.");
		}

		internal static LiteException InvalidDatabase()
		{
			return new LiteException(103, "File is not a valid LiteDB database format or contains a invalid password.");
		}

		internal static LiteException FileSizeExceeded(long limit)
		{
			return new LiteException(105, "Database size exceeds limit of {0}.", FileHelper.FormatFileSize(limit));
		}

		internal static LiteException CollectionLimitExceeded(int limit)
		{
			return new LiteException(106, "This database exceeded the maximum limit of collection names size: {0} bytes", limit);
		}

		internal static LiteException IndexNameLimitExceeded(int limit)
		{
			return new LiteException(128, "This collection exceeded the maximum limit of indexes names/expression size: {0} bytes", limit);
		}

		internal static LiteException InvalidIndexName(string name, string collection, string reason)
		{
			return new LiteException(129, "Invalid index name '{0}' on collection '{1}': {2}", name, collection, reason);
		}

		internal static LiteException InvalidCollectionName(string name, string reason)
		{
			return new LiteException(130, "Invalid collection name '{0}': {1}", name, reason);
		}

		internal static LiteException IndexDropId()
		{
			return new LiteException(108, "Primary key index '_id' can't be dropped.");
		}

		internal static LiteException TempEngineAlreadyDefined()
		{
			return new LiteException(131, "Temporary engine already defined or auto created.");
		}

		internal static LiteException CollectionNotFound(string key)
		{
			return new LiteException(133, "Collection not found: '{0}'", key);
		}

		internal static LiteException InvalidExpressionType(BsonExpression expr, BsonExpressionType type)
		{
			return new LiteException(132, "Expression '{0}' must be a {1} type.", expr.Source, type);
		}

		internal static LiteException InvalidExpressionTypePredicate(BsonExpression expr)
		{
			return new LiteException(132, "Expression '{0}' are not supported as predicate expression.", expr.Source);
		}

		internal static LiteException CollectionAlreadyExist(string key)
		{
			return new LiteException(134, "Collection already exist: '{0}'", key);
		}

		internal static LiteException IndexAlreadyExist(string name)
		{
			return new LiteException(135, "Index name '{0}' already exist with a differnt expression. Try drop index first.", name);
		}

		internal static LiteException InvalidUpdateField(string field)
		{
			return new LiteException(136, "'{0}' can't be modified in UPDATE command.", field);
		}

		internal static LiteException IndexDuplicateKey(string field, BsonValue key)
		{
			return new LiteException(110, "Cannot insert duplicate key in unique index '{0}'. The duplicate value is '{1}'.", field, key);
		}

		internal static LiteException InvalidIndexKey(string text)
		{
			return new LiteException(111, text);
		}

		internal static LiteException IndexNotFound(string name)
		{
			return new LiteException(112, "Index not found '{0}'.", name);
		}

		internal static LiteException LockTimeout(string mode, TimeSpan ts)
		{
			return new LiteException(120, "Database lock timeout when entering in {0} mode after {1}", mode, ts.ToString());
		}

		internal static LiteException LockTimeout(string mode, string collection, TimeSpan ts)
		{
			return new LiteException(120, "Collection '{0}' lock timeout when entering in {1} mode after {2}", collection, mode, ts.ToString());
		}

		internal static LiteException InvalidCommand(string command)
		{
			return new LiteException(121, "Command '{0}' is not a valid shell command.", command);
		}

		internal static LiteException AlreadyExistsCollectionName(string newName)
		{
			return new LiteException(122, "New collection name '{0}' already exists.", newName);
		}

		internal static LiteException AlreadyOpenDatafile(string filename)
		{
			return new LiteException(124, "Your datafile '{0}' is open in another process.", filename);
		}

		internal static LiteException InvalidDbRef(string path)
		{
			return new LiteException(113, "Invalid value for DbRef in path '{0}'. Value must be document like {{ $ref: \"?\", $id: ? }}", path);
		}

		internal static LiteException AlreadyExistsTransaction()
		{
			return new LiteException(126, "The current thread already contains an open transaction. Use the Commit/Rollback method to release the previous transaction.");
		}

		internal static LiteException CollectionLockerNotFound(string collection)
		{
			return new LiteException(126, "Collection locker '{0}' was not found inside dictionary.", collection);
		}

		internal static LiteException InvalidFormat(string field)
		{
			return new LiteException(200, "Invalid format: {0}", field);
		}

		internal static LiteException DocumentMaxDepth(int depth, Type type)
		{
			return new LiteException(201, "Document has more than {0} nested documents in '{1}'. Check for circular references (use DbRef).", depth, (type == null) ? "-" : type.Name);
		}

		internal static LiteException InvalidCtor(Type type, Exception inner)
		{
			return new LiteException(202, inner, "Failed to create instance for type '{0}' from assembly '{1}'. Checks if the class has a public constructor with no parameters.", type.FullName, type.AssemblyQualifiedName);
		}

		internal static LiteException UnexpectedToken(Token token, string expected = null)
		{
			long valueOrDefault = (token?.Position - (token?.Value?.Length).GetValueOrDefault()).GetValueOrDefault();
			string arg = ((token != null && token.Type == TokenType.EOF) ? "[EOF]" : (token?.Value ?? ""));
			string arg2 = ((expected == null) ? "" : (" Expected `" + expected + "`."));
			return new LiteException(203, $"Unexpected token `{arg}` in position {valueOrDefault}.{arg2}")
			{
				Position = valueOrDefault
			};
		}

		internal static LiteException UnexpectedToken(string message, Token token)
		{
			long valueOrDefault = (token?.Position - (token?.Value?.Length).GetValueOrDefault()).GetValueOrDefault();
			return new LiteException(203, message)
			{
				Position = valueOrDefault
			};
		}

		internal static LiteException InvalidDataType(string field, BsonValue value)
		{
			return new LiteException(204, "Invalid BSON data type '{0}' on field '{1}'.", value.Type, field);
		}

		internal static LiteException PropertyReadWrite(PropertyInfo prop)
		{
			return new LiteException(209, "'{0}' property must have public getter and setter.", prop.Name);
		}

		internal static LiteException PropertyNotMapped(string name)
		{
			return new LiteException(206, "Property '{0}' was not mapped into BsonDocument.", name);
		}

		internal static LiteException InvalidTypedName(string type)
		{
			return new LiteException(207, "Type '{0}' not found in current domain (_type format is 'Type.FullName, AssemblyName').", type);
		}

		internal static LiteException InitialSizeCryptoNotSupported()
		{
			return new LiteException(210, "Initial Size option is not supported for encrypted datafiles.");
		}

		internal static LiteException InvalidInitialSize()
		{
			return new LiteException(211, "Initial Size must be a multiple of page size ({0} bytes).", 8192);
		}

		internal static LiteException EngineDisposed()
		{
			return new LiteException(137, "This engine instance already disposed.");
		}

		internal static LiteException InvalidNullCharInString()
		{
			return new LiteException(212, "Invalid null character (\\0) was found in the string");
		}

		internal static LiteException InvalidPageType(PageType pageType, BasePage page)
		{
			StringBuilder stringBuilder = new StringBuilder($"Invalid {pageType} on {page.PageID}. ");
			stringBuilder.Append($"Full zero: {page.Buffer.All(0)}. ");
			stringBuilder.Append($"Page Type: {page.PageType}. ");
			stringBuilder.Append($"Prev/Next: {page.PrevPageID}/{page.NextPageID}. ");
			stringBuilder.Append($"UniqueID: {page.Buffer.UniqueID}. ");
			stringBuilder.Append($"ShareCounter: {page.Buffer.ShareCounter}. ");
			return new LiteException(0, stringBuilder.ToString());
		}

		internal static LiteException InvalidFreeSpacePage(uint pageID, int freeBytes, int length)
		{
			return new LiteException(213, $"An operation that would corrupt page {pageID} was prevented. The operation required {length} free bytes, but the page had only {freeBytes} available.");
		}

		internal static LiteException DataTypeNotAssignable(string type1, string type2)
		{
			return new LiteException(214, "Data type " + type1 + " is not assignable from data type " + type2);
		}

		internal static LiteException FileNotEncrypted()
		{
			return new LiteException(216, "File is not encrypted.");
		}

		internal static LiteException InvalidPassword()
		{
			return new LiteException(217, "Invalid password.");
		}

		internal static LiteException IllegalDeserializationType(string typeName)
		{
			return new LiteException(218, "Illegal deserialization type: " + typeName);
		}

		internal static LiteException InvalidDatafileState(string message)
		{
			return new LiteException(999, message);
		}
	}
	internal class MimeTypeConverter
	{
		private static readonly IDictionary<string, string> _mappings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ ".323", "text/h323" },
			{ ".3g2", "video/3gpp2" },
			{ ".3gp", "video/3gpp" },
			{ ".3gp2", "video/3gpp2" },
			{ ".3gpp", "video/3gpp" },
			{ ".7z", "application/x-7z-compressed" },
			{ ".aa", "audio/audible" },
			{ ".AAC", "audio/aac" },
			{ ".aaf", "application/octet-stream" },
			{ ".aax", "audio/vnd.audible.aax" },
			{ ".ac3", "audio/ac3" },
			{ ".aca", "application/octet-stream" },
			{ ".accda", "application/msaccess.addin" },
			{ ".accdb", "application/msaccess" },
			{ ".accdc", "application/msaccess.cab" },
			{ ".accde", "application/msaccess" },
			{ ".accdr", "application/msaccess.runtime" },
			{ ".accdt", "application/msaccess" },
			{ ".accdw", "application/msaccess.webapplication" },
			{ ".accft", "application/msaccess.ftemplate" },
			{ ".acx", "application/internet-property-stream" },
			{ ".AddIn", "text/xml" },
			{ ".ade", "application/msaccess" },
			{ ".adobebridge", "application/x-bridge-url" },
			{ ".adp", "application/msaccess" },
			{ ".ADT", "audio/vnd.dlna.adts" },
			{ ".ADTS", "audio/aac" },
			{ ".afm", "application/octet-stream" },
			{ ".ai", "application/postscript" },
			{ ".aif", "audio/x-aiff" },
			{ ".aifc", "audio/aiff" },
			{ ".aiff", "audio/aiff" },
			{ ".air", "application/vnd.adobe.air-application-installer-package+zip" },
			{ ".amc", "application/x-mpeg" },
			{ ".application", "application/x-ms-application" },
			{ ".art", "image/x-jg" },
			{ ".asa", "application/xml" },
			{ ".asax", "application/xml" },
			{ ".ascx", "application/xml" },
			{ ".asd", "application/octet-stream" },
			{ ".asf", "video/x-ms-asf" },
			{ ".ashx", "application/xml" },
			{ ".asi", "application/octet-stream" },
			{ ".asm", "text/plain" },
			{ ".asmx", "application/xml" },
			{ ".aspx", "application/xml" },
			{ ".asr", "video/x-ms-asf" },
			{ ".asx", "video/x-ms-asf" },
			{ ".atom", "application/atom+xml" },
			{ ".au", "audio/basic" },
			{ ".avi", "video/x-msvideo" },
			{ ".axs", "application/olescript" },
			{ ".bas", "text/plain" },
			{ ".bcpio", "application/x-bcpio" },
			{ ".bin", "application/octet-stream" },
			{ ".bmp", "image/bmp" },
			{ ".c", "text/plain" },
			{ ".cab", "application/octet-stream" },
			{ ".caf", "audio/x-caf" },
			{ ".calx", "application/vnd.ms-office.calx" },
			{ ".cat", "application/vnd.ms-pki.seccat" },
			{ ".cc", "text/plain" },
			{ ".cd", "text/plain" },
			{ ".cdda", "audio/aiff" },
			{ ".cdf", "application/x-cdf" },
			{ ".cer", "application/x-x509-ca-cert" },
			{ ".chm", "application/octet-stream" },
			{ ".class", "application/x-java-applet" },
			{ ".clp", "application/x-msclip" },
			{ ".cmx", "image/x-cmx" },
			{ ".cnf", "text/plain" },
			{ ".cod", "image/cis-cod" },
			{ ".config", "application/xml" },
			{ ".contact", "text/x-ms-contact" },
			{ ".coverage", "application/xml" },
			{ ".cpio", "application/x-cpio" },
			{ ".cpp", "text/plain" },
			{ ".crd", "application/x-mscardfile" },
			{ ".crl", "application/pkix-crl" },
			{ ".crt", "application/x-x509-ca-cert" },
			{ ".cs", "text/plain" },
			{ ".csdproj", "text/plain" },
			{ ".csh", "application/x-csh" },
			{ ".csproj", "text/plain" },
			{ ".css", "text/css" },
			{ ".csv", "text/csv" },
			{ ".cur", "application/octet-stream" },
			{ ".cxx", "text/plain" },
			{ ".dat", "application/octet-stream" },
			{ ".datasource", "application/xml" },
			{ ".dbproj", "text/plain" },
			{ ".dcr", "application/x-director" },
			{ ".def", "text/plain" },
			{ ".deploy", "application/octet-stream" },
			{ ".der", "application/x-x509-ca-cert" },
			{ ".dgml", "application/xml" },
			{ ".dib", "image/bmp" },
			{ ".dif", "video/x-dv" },
			{ ".dir", "application/x-director" },
			{ ".disco", "text/xml" },
			{ ".dll", "application/x-msdownload" },
			{ ".dll.config", "text/xml" },
			{ ".dlm", "text/dlm" },
			{ ".doc", "application/msword" },
			{ ".docm", "application/vnd.ms-word.document.macroEnabled.12" },
			{ ".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
			{ ".dot", "application/msword" },
			{ ".dotm", "application/vnd.ms-word.template.macroEnabled.12" },
			{ ".dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template" },
			{ ".dsp", "application/octet-stream" },
			{ ".dsw", "text/plain" },
			{ ".dtd", "text/xml" },
			{ ".dtsConfig", "text/xml" },
			{ ".dv", "video/x-dv" },
			{ ".dvi", "application/x-dvi" },
			{ ".dwf", "drawing/x-dwf" },
			{ ".dwp", "application/octet-stream" },
			{ ".dxr", "application/x-director" },
			{ ".eml", "message/rfc822" },
			{ ".emz", "application/octet-stream" },
			{ ".eot", "application/octet-stream" },
			{ ".eps", "application/postscript" },
			{ ".etl", "application/etl" },
			{ ".etx", "text/x-setext" },
			{ ".evy", "application/envoy" },
			{ ".exe", "application/octet-stream" },
			{ ".exe.config", "text/xml" },
			{ ".fdf", "application/vnd.fdf" },
			{ ".fif", "application/fractals" },
			{ ".filters", "Application/xml" },
			{ ".fla", "application/octet-stream" },
			{ ".flr", "x-world/x-vrml" },
			{ ".flv", "video/x-flv" },
			{ ".fsscript", "application/fsharp-script" },
			{ ".fsx", "application/fsharp-script" },
			{ ".generictest", "application/xml" },
			{ ".gif", "image/gif" },
			{ ".group", "text/x-ms-group" },
			{ ".gsm", "audio/x-gsm" },
			{ ".gtar", "application/x-gtar" },
			{ ".gz", "application/x-gzip" },
			{ ".h", "text/plain" },
			{ ".hdf", "application/x-hdf" },
			{ ".hdml", "text/x-hdml" },
			{ ".hhc", "application/x-oleobject" },
			{ ".hhk", "application/octet-stream" },
			{ ".hhp", "application/octet-stream" },
			{ ".hlp", "application/winhlp" },
			{ ".hpp", "text/plain" },
			{ ".hqx", "application/mac-binhex40" },
			{ ".hta", "application/hta" },
			{ ".htc", "text/x-component" },
			{ ".htm", "text/html" },
			{ ".html", "text/html" },
			{ ".htt", "text/webviewhtml" },
			{ ".hxa", "application/xml" },
			{ ".hxc", "application/xml" },
			{ ".hxd", "application/octet-stream" },
			{ ".hxe", "application/xml" },
			{ ".hxf", "application/xml" },
			{ ".hxh", "application/octet-stream" },
			{ ".hxi", "application/octet-stream" },
			{ ".hxk", "application/xml" },
			{ ".hxq", "application/octet-stream" },
			{ ".hxr", "application/octet-stream" },
			{ ".hxs", "application/octet-stream" },
			{ ".hxt", "text/html" },
			{ ".hxv", "application/xml" },
			{ ".hxw", "application/octet-stream" },
			{ ".hxx", "text/plain" },
			{ ".i", "text/plain" },
			{ ".ico", "image/x-icon" },
			{ ".ics", "application/octet-stream" },
			{ ".idl", "text/plain" },
			{ ".ief", "image/ief" },
			{ ".iii", "application/x-iphone" },
			{ ".inc", "text/plain" },
			{ ".inf", "application/octet-stream" },
			{ ".inl", "text/plain" },
			{ ".ins", "application/x-internet-signup" },
			{ ".ipa", "application/x-itunes-ipa" },
			{ ".ipg", "application/x-itunes-ipg" },
			{ ".ipproj", "text/plain" },
			{ ".ipsw", "application/x-itunes-ipsw" },
			{ ".iqy", "text/x-ms-iqy" },
			{ ".isp", "application/x-internet-signup" },
			{ ".ite", "application/x-itunes-ite" },
			{ ".itlp", "application/x-itunes-itlp" },
			{ ".itms", "application/x-itunes-itms" },
			{ ".itpc", "application/x-itunes-itpc" },
			{ ".IVF", "video/x-ivf" },
			{ ".jar", "application/java-archive" },
			{ ".java", "application/octet-stream" },
			{ ".jck", "application/liquidmotion" },
			{ ".jcz", "application/liquidmotion" },
			{ ".jfif", "image/pjpeg" },
			{ ".jnlp", "application/x-java-jnlp-file" },
			{ ".jpb", "application/octet-stream" },
			{ ".jpe", "image/jpeg" },
			{ ".jpeg", "image/jpeg" },
			{ ".jpg", "image/jpeg" },
			{ ".js", "application/x-javascript" },
			{ ".jsx", "text/jscript" },
			{ ".jsxbin", "text/plain" },
			{ ".latex", "application/x-latex" },
			{ ".library-ms", "application/windows-library+xml" },
			{ ".lit", "application/x-ms-reader" },
			{ ".loadtest", "application/xml" },
			{ ".lpk", "application/octet-stream" },
			{ ".lsf", "video/x-la-asf" },
			{ ".lst", "text/plain" },
			{ ".lsx", "video/x-la-asf" },
			{ ".lzh", "application/octet-stream" },
			{ ".m13", "application/x-msmediaview" },
			{ ".m14", "application/x-msmediaview" },
			{ ".m1v", "video/mpeg" },
			{ ".m2t", "video/vnd.dlna.mpeg-tts" },
			{ ".m2ts", "video/vnd.dlna.mpeg-tts" },
			{ ".m2v", "video/mpeg" },
			{ ".m3u", "audio/x-mpegurl" },
			{ ".m3u8", "audio/x-mpegurl" },
			{ ".m4a", "audio/m4a" },
			{ ".m4b", "audio/m4b" },
			{ ".m4p", "audio/m4p" },
			{ ".m4r", "audio/x-m4r" },
			{ ".m4v", "video/x-m4v" },
			{ ".mac", "image/x-macpaint" },
			{ ".mak", "text/plain" },
			{ ".man", "application/x-troff-man" },
			{ ".manifest", "application/x-ms-manifest" },
			{ ".map", "text/plain" },
			{ ".master", "application/xml" },
			{ ".mda", "application/msaccess" },
			{ ".mdb", "application/x-msaccess" },
			{ ".mde", "application/msaccess" },
			{ ".mdp", "application/octet-stream" },
			{ ".me", "application/x-troff-me" },
			{ ".mfp", "application/x-shockwave-flash" },
			{ ".mht", "message/rfc822" },
			{ ".mhtml", "message/rfc822" },
			{ ".mid", "audio/mid" },
			{ ".midi", "audio/mid" },
			{ ".mix", "application/octet-stream" },
			{ ".mk", "text/plain" },
			{ ".mmf", "application/x-smaf" },
			{ ".mno", "text/xml" },
			{ ".mny", "application/x-msmoney" },
			{ ".mod", "video/mpeg" },
			{ ".mov", "video/quicktime" },
			{ ".movie", "video/x-sgi-movie" },
			{ ".mp2", "video/mpeg" },
			{ ".mp2v", "video/mpeg" },
			{ ".mp3", "audio/mpeg" },
			{ ".mp4", "video/mp4" },
			{ ".mp4v", "video/mp4" },
			{ ".mpa", "video/mpeg" },
			{ ".mpe", "video/mpeg" },
			{ ".mpeg", "video/mpeg" },
			{ ".mpf", "application/vnd.ms-mediapackage" },
			{ ".mpg", "video/mpeg" },
			{ ".mpp", "application/vnd.ms-project" },
			{ ".mpv2", "video/mpeg" },
			{ ".mqv", "video/quicktime" },
			{ ".ms", "application/x-troff-ms" },
			{ ".msi", "application/octet-stream" },
			{ ".mso", "application/octet-stream" },
			{ ".mts", "video/vnd.dlna.mpeg-tts" },
			{ ".mtx", "application/xml" },
			{ ".mvb", "application/x-msmediaview" },
			{ ".mvc", "application/x-miva-compiled" },
			{ ".mxp", "application/x-mmxp" },
			{ ".nc", "application/x-netcdf" },
			{ ".nsc", "video/x-ms-asf" },
			{ ".nws", "message/rfc822" },
			{ ".ocx", "application/octet-stream" },
			{ ".oda", "application/oda" },
			{ ".odc", "text/x-ms-odc" },
			{ ".odh", "text/plain" },
			{ ".odl", "text/plain" },
			{ ".odp", "application/vnd.oasis.opendocument.presentation" },
			{ ".ods", "application/oleobject" },
			{ ".odt", "application/vnd.oasis.opendocument.text" },
			{ ".one", "application/onenote" },
			{ ".onea", "application/onenote" },
			{ ".onepkg", "application/onenote" },
			{ ".onetmp", "application/onenote" },
			{ ".onetoc", "application/onenote" },
			{ ".onetoc2", "application/onenote" },
			{ ".orderedtest", "application/xml" },
			{ ".osdx", "application/opensearchdescription+xml" },
			{ ".p10", "application/pkcs10" },
			{ ".p12", "application/x-pkcs12" },
			{ ".p7b", "application/x-pkcs7-certificates" },
			{ ".p7c", "application/pkcs7-mime" },
			{ ".p7m", "application/pkcs7-mime" },
			{ ".p7r", "application/x-pkcs7-certreqresp" },
			{ ".p7s", "application/pkcs7-signature" },
			{ ".pbm", "image/x-portable-bitmap" },
			{ ".pcast", "application/x-podcast" },
			{ ".pct", "image/pict" },
			{ ".pcx", "application/octet-stream" },
			{ ".pcz", "application/octet-stream" },
			{ ".pdf", "application/pdf" },
			{ ".pfb", "application/octet-stream" },
			{ ".pfm", "application/octet-stream" },
			{ ".pfx", "application/x-pkcs12" },
			{ ".pgm", "image/x-portable-graymap" },
			{ ".pic", "image/pict" },
			{ ".pict", "image/pict" },
			{ ".pkgdef", "text/plain" },
			{ ".pkgundef", "text/plain" },
			{ ".pko", "application/vnd.ms-pki.pko" },
			{ ".pls", "audio/scpls" },
			{ ".pma", "application/x-perfmon" },
			{ ".pmc", "application/x-perfmon" },
			{ ".pml", "application/x-perfmon" },
			{ ".pmr", "application/x-perfmon" },
			{ ".pmw", "application/x-perfmon" },
			{ ".png", "image/png" },
			{ ".pnm", "image/x-portable-anymap" },
			{ ".pnt", "image/x-macpaint" },
			{ ".pntg", "image/x-macpaint" },
			{ ".pnz", "image/png" },
			{ ".pot", "application/vnd.ms-powerpoint" },
			{ ".potm", "application/vnd.ms-powerpoint.template.macroEnabled.12" },
			{ ".potx", "application/vnd.openxmlformats-officedocument.presentationml.template" },
			{ ".ppa", "application/vnd.ms-powerpoint" },
			{ ".ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12" },
			{ ".ppm", "image/x-portable-pixmap" },
			{ ".pps", "application/vnd.ms-powerpoint" },
			{ ".ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12" },
			{ ".ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow" },
			{ ".ppt", "application/vnd.ms-powerpoint" },
			{ ".pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12" },
			{ ".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
			{ ".prf", "application/pics-rules" },
			{ ".prm", "application/octet-stream" },
			{ ".prx", "application/octet-stream" },
			{ ".ps", "application/postscript" },
			{ ".psc1", "application/PowerShell" },
			{ ".psd", "application/octet-stream" },
			{ ".psess", "application/xml" },
			{ ".psm", "application/octet-stream" },
			{ ".psp", "application/octet-stream" },
			{ ".pub", "application/x-mspublisher" },
			{ ".pwz", "application/vnd.ms-powerpoint" },
			{ ".qht", "text/x-html-insertion" },
			{ ".qhtm", "text/x-html-insertion" },
			{ ".qt", "video/quicktime" },
			{ ".qti", "image/x-quicktime" },
			{ ".qtif", "image/x-quicktime" },
			{ ".qtl", "application/x-quicktimeplayer" },
			{ ".qxd", "application/octet-stream" },
			{ ".ra", "audio/x-pn-realaudio" },
			{ ".ram", "audio/x-pn-realaudio" },
			{ ".rar", "application/octet-stream" },
			{ ".ras", "image/x-cmu-raster" },
			{ ".rat", "application/rat-file" },
			{ ".rc", "text/plain" },
			{ ".rc2", "text/plain" },
			{ ".rct", "text/plain" },
			{ ".rdlc", "application/xml" },
			{ ".resx", "application/xml" },
			{ ".rf", "image/vnd.rn-realflash" },
			{ ".rgb", "image/x-rgb" },
			{ ".rgs", "text/plain" },
			{ ".rm", "application/vnd.rn-realmedia" },
			{ ".rmi", "audio/mid" },
			{ ".rmp", "application/vnd.rn-rn_music_package" },
			{ ".roff", "application/x-troff" },
			{ ".rpm", "audio/x-pn-realaudio-plugin" },
			{ ".rqy", "text/x-ms-rqy" },
			{ ".rtf", "application/rtf" },
			{ ".rtx", "text/richtext" },
			{ ".ruleset", "application/xml" },
			{ ".s", "text/plain" },
			{ ".safariextz", "application/x-safari-safariextz" },
			{ ".scd", "application/x-msschedule" },
			{ ".sct", "text/scriptlet" },
			{ ".sd2", "audio/x-sd2" },
			{ ".sdp", "application/sdp" },
			{ ".sea", "application/octet-stream" },
			{ ".searchConnector-ms", "application/windows-search-connector+xml" },
			{ ".setpay", "application/set-payment-initiation" },
			{ ".setreg", "application/set-registration-initiation" },
			{ ".settings", "application/xml" },
			{ ".sgimb", "application/x-sgimb" },
			{ ".sgml", "text/sgml" },
			{ ".sh", "application/x-sh" },
			{ ".shar", "application/x-shar" },
			{ ".shtml", "text/html" },
			{ ".sit", "application/x-stuffit" },
			{ ".sitemap", "application/xml" },
			{ ".skin", "application/xml" },
			{ ".sldm", "application/vnd.ms-powerpoint.slide.macroEnabled.12" },
			{ ".sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide" },
			{ ".slk", "application/vnd.ms-excel" },
			{ ".sln", "text/plain" },
			{ ".slupkg-ms", "application/x-ms-license" },
			{ ".smd", "audio/x-smd" },
			{ ".smi", "application/octet-stream" },
			{ ".smx", "audio/x-smd" },
			{ ".smz", "audio/x-smd" },
			{ ".snd", "audio/basic" },
			{ ".snippet", "application/xml" },
			{ ".snp", "application/octet-stream" },
			{ ".sol", "text/plain" },
			{ ".sor", "text/plain" },
			{ ".spc", "application/x-pkcs7-certificates" },
			{ ".spl", "application/futuresplash" },
			{ ".src", "application/x-wais-source" },
			{ ".srf", "text/plain" },
			{ ".SSISDeploymentManifest", "text/xml" },
			{ ".ssm", "application/streamingmedia" },
			{ ".sst", "application/vnd.ms-pki.certstore" },
			{ ".stl", "application/vnd.ms-pki.stl" },
			{ ".sv4cpio", "application/x-sv4cpio" },
			{ ".sv4crc", "application/x-sv4crc" },
			{ ".svc", "application/xml" },
			{ ".swf", "application/x-shockwave-flash" },
			{ ".t", "application/x-troff" },
			{ ".tar", "application/x-tar" },
			{ ".tcl", "application/x-tcl" },
			{ ".testrunconfig", "application/xml" },
			{ ".testsettings", "application/xml" },
			{ ".tex", "application/x-tex" },
			{ ".texi", "application/x-texinfo" },
			{ ".texinfo", "application/x-texinfo" },
			{ ".tgz", "application/x-compressed" },
			{ ".thmx", "application/vnd.ms-officetheme" },
			{ ".thn", "application/octet-stream" },
			{ ".tif", "image/tiff" },
			{ ".tiff", "image/tiff" },
			{ ".tlh", "text/plain" },
			{ ".tli", "text/plain" },
			{ ".toc", "application/octet-stream" },
			{ ".tr", "application/x-troff" },
			{ ".trm", "application/x-msterminal" },
			{ ".trx", "application/xml" },
			{ ".ts", "video/vnd.dlna.mpeg-tts" },
			{ ".tsv", "text/tab-separated-values" },
			{ ".ttf", "application/octet-stream" },
			{ ".tts", "video/vnd.dlna.mpeg-tts" },
			{ ".txt", "text/plain" },
			{ ".u32", "application/octet-stream" },
			{ ".uls", "text/iuls" },
			{ ".user", "text/plain" },
			{ ".ustar", "application/x-ustar" },
			{ ".vb", "text/plain" },
			{ ".vbdproj", "text/plain" },
			{ ".vbk", "video/mpeg" },
			{ ".vbproj", "text/plain" },
			{ ".vbs", "text/vbscript" },
			{ ".vcf", "text/x-vcard" },
			{ ".vcproj", "Application/xml" },
			{ ".vcs", "text/plain" },
			{ ".vcxproj", "Application/xml" },
			{ ".vddproj", "text/plain" },
			{ ".vdp", "text/plain" },
			{ ".vdproj", "text/plain" },
			{ ".vdx", "application/vnd.ms-visio.viewer" },
			{ ".vml", "text/xml" },
			{ ".vscontent", "application/xml" },
			{ ".vsct", "text/xml" },
			{ ".vsd", "application/vnd.visio" },
			{ ".vsi", "application/ms-vsi" },
			{ ".vsix", "application/vsix" },
			{ ".vsixlangpack", "text/xml" },
			{ ".vsixmanifest", "text/xml" },
			{ ".vsmdi", "application/xml" },
			{ ".vspscc", "text/plain" },
			{ ".vss", "application/vnd.visio" },
			{ ".vsscc", "text/plain" },
			{ ".vssettings", "text/xml" },
			{ ".vssscc", "text/plain" },
			{ ".vst", "application/vnd.visio" },
			{ ".vstemplate", "text/xml" },
			{ ".vsto", "application/x-ms-vsto" },
			{ ".vsw", "application/vnd.visio" },
			{ ".vsx", "application/vnd.visio" },
			{ ".vtx", "application/vnd.visio" },
			{ ".wav", "audio/wav" },
			{ ".wave", "audio/wav" },
			{ ".wax", "audio/x-ms-wax" },
			{ ".wbk", "application/msword" },
			{ ".wbmp", "image/vnd.wap.wbmp" },
			{ ".wcm", "application/vnd.ms-works" },
			{ ".wdb", "application/vnd.ms-works" },
			{ ".wdp", "image/vnd.ms-photo" },
			{ ".webarchive", "application/x-safari-webarchive" },
			{ ".webp", "image/webp" },
			{ ".webtest", "application/xml" },
			{ ".wiq", "application/xml" },
			{ ".wiz", "application/msword" },
			{ ".wks", "application/vnd.ms-works" },
			{ ".WLMP", "application/wlmoviemaker" },
			{ ".wlpginstall", "application/x-wlpg-detect" },
			{ ".wlpginstall3", "application/x-wlpg3-detect" },
			{ ".wm", "video/x-ms-wm" },
			{ ".wma", "audio/x-ms-wma" },
			{ ".wmd", "application/x-ms-wmd" },
			{ ".wmf", "application/x-msmetafile" },
			{ ".wml", "text/vnd.wap.wml" },
			{ ".wmlc", "application/vnd.wap.wmlc" },
			{ ".wmls", "text/vnd.wap.wmlscript" },
			{ ".wmlsc", "application/vnd.wap.wmlscriptc" },
			{ ".wmp", "video/x-ms-wmp" },
			{ ".wmv", "video/x-ms-wmv" },
			{ ".wmx", "video/x-ms-wmx" },
			{ ".wmz", "application/x-ms-wmz" },
			{ ".wpl", "application/vnd.ms-wpl" },
			{ ".wps", "application/vnd.ms-works" },
			{ ".wri", "application/x-mswrite" },
			{ ".wrl", "x-world/x-vrml" },
			{ ".wrz", "x-world/x-vrml" },
			{ ".wsc", "text/scriptlet" },
			{ ".wsdl", "text/xml" },
			{ ".wvx", "video/x-ms-wvx" },
			{ ".x", "application/directx" },
			{ ".xaf", "x-world/x-vrml" },
			{ ".xaml", "application/xaml+xml" },
			{ ".xap", "application/x-silverlight-app" },
			{ ".xbap", "application/x-ms-xbap" },
			{ ".xbm", "image/x-xbitmap" },
			{ ".xdr", "text/plain" },
			{ ".xht", "application/xhtml+xml" },
			{ ".xhtml", "application/xhtml+xml" },
			{ ".xla", "application/vnd.ms-excel" },
			{ ".xlam", "application/vnd.ms-excel.addin.macroEnabled.12" },
			{ ".xlc", "application/vnd.ms-excel" },
			{ ".xld", "application/vnd.ms-excel" },
			{ ".xlk", "application/vnd.ms-excel" },
			{ ".xll", "application/vnd.ms-excel" },
			{ ".xlm", "application/vnd.ms-excel" },
			{ ".xls", "application/vnd.ms-excel" },
			{ ".xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12" },
			{ ".xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12" },
			{ ".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
			{ ".xlt", "application/vnd.ms-excel" },
			{ ".xltm", "application/vnd.ms-excel.template.macroEnabled.12" },
			{ ".xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template" },
			{ ".xlw", "application/vnd.ms-excel" },
			{ ".xml", "text/xml" },
			{ ".xmta", "application/xml" },
			{ ".xof", "x-world/x-vrml" },
			{ ".XOML", "text/plain" },
			{ ".xpm", "image/x-xpixmap" },
			{ ".xps", "application/vnd.ms-xpsdocument" },
			{ ".xrm-ms", "text/xml" },
			{ ".xsc", "application/xml" },
			{ ".xsd", "text/xml" },
			{ ".xsf", "text/xml" },
			{ ".xsl", "text/xml" },
			{ ".xslt", "text/xml" },
			{ ".xsn", "application/octet-stream" },
			{ ".xss", "application/xml" },
			{ ".xtp", "application/octet-stream" },
			{ ".xwd", "image/x-xwindowdump" },
			{ ".z", "application/x-compress" },
			{ ".zip", "application/x-zip-compressed" }
		};

		public static string GetMimeType(string filename)
		{
			if (string.IsNullOrEmpty(filename))
			{
				throw new ArgumentNullException("filename");
			}
			string text = Path.GetExtension(filename);
			if (!text.StartsWith("."))
			{
				text = "." + text;
			}
			if (!_mappings.TryGetValue(text, out var value))
			{
				return "application/octet-stream";
			}
			return value;
		}
	}
	internal static class BucketHelper
	{
		public const int BucketCount = 17;

		private static readonly int[] _bucketSize;

		static BucketHelper()
		{
			_bucketSize = new int[17];
			for (int i = 0; i < 17; i++)
			{
				_bucketSize[i] = GetMaxSizeForBucket(i);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetBucketIndex(int bufferSize)
		{
			for (int i = 0; i < _bucketSize.Length; i++)
			{
				if (_bucketSize[i] >= bufferSize)
				{
					return i;
				}
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetMaxSizeForBucket(int binIndex)
		{
			return 16 << binIndex;
		}
	}
	internal static class Randomizer
	{
		private static readonly Random _random = new Random(0);

		public static int Next()
		{
			lock (_random)
			{
				return _random.Next();
			}
		}

		public static int Next(int minValue, int maxValue)
		{
			lock (_random)
			{
				return _random.Next(minValue, maxValue);
			}
		}
	}
	internal struct Result<T> where T : class
	{
		public T Value;

		public Exception Exception;

		public bool Ok => Exception == null;

		public bool Fail => Exception != null;

		public T GetValue()
		{
			if (!Ok)
			{
				throw Exception;
			}
			return Value;
		}

		public Result(T value, Exception ex = null)
		{
			Value = value;
			Exception = ex;
		}

		public static implicit operator T(Result<T> value)
		{
			return value.Value;
		}

		public static implicit operator Result<T>(T value)
		{
			return new Result<T>(value);
		}
	}
	internal enum TokenType
	{
		OpenBrace,
		CloseBrace,
		OpenBracket,
		CloseBracket,
		OpenParenthesis,
		CloseParenthesis,
		Comma,
		Colon,
		SemiColon,
		At,
		Hashtag,
		Til,
		Period,
		Ampersand,
		Dollar,
		Exclamation,
		NotEquals,
		Equals,
		Greater,
		GreaterOrEquals,
		Less,
		LessOrEquals,
		Minus,
		Plus,
		Asterisk,
		Slash,
		Backslash,
		Percent,
		String,
		Int,
		Double,
		Whitespace,
		Word,
		EOF,
		Unknown
	}
	internal class Token
	{
		private static readonly HashSet<string> _keywords = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "BETWEEN", "LIKE", "IN", "AND", "OR", "VECTOR_SIM" };

		public TokenType Type { get; private set; }

		public string Value { get; private set; }

		public long Position { get; private set; }

		public bool IsOperand
		{
			get
			{
				switch (Type)
				{
				case TokenType.NotEquals:
				case TokenType.Equals:
				case TokenType.Greater:
				case TokenType.GreaterOrEquals:
				case TokenType.Less:
				case TokenType.LessOrEquals:
				case TokenType.Minus:
				case TokenType.Plus:
				case TokenType.Asterisk:
				case TokenType.Slash:
				case TokenType.Percent:
					return true;
				case TokenType.Word:
					return _keywords.Contains(Value);
				default:
					return false;
				}
			}
		}

		public Token(TokenType tokenType, string value, long position)
		{
			Position = position;
			Value = value;
			Type = tokenType;
		}

		public Token Expect(TokenType type)
		{
			if (Type != type)
			{
				throw LiteException.UnexpectedToken(this);
			}
			return this;
		}

		public Token Expect(TokenType type1, TokenType type2)
		{
			if (Type != type1 && Type != type2)
			{
				throw LiteException.UnexpectedToken(this);
			}
			return this;
		}

		public Token Expect(TokenType type1, TokenType type2, TokenType type3)
		{
			if (Type != type1 && Type != type2 && Type != type3)
			{
				throw LiteException.UnexpectedToken(this);
			}
			return this;
		}

		public Token Expect(string value, bool ignoreCase = true)
		{
			if (!Is(value, ignoreCase))
			{
				throw LiteException.UnexpectedToken(this, value);
			}
			return this;
		}

		public bool Is(string value, bool ignoreCase = true)
		{
			if (Type == TokenType.Word)
			{
				return value.Equals(Value, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
			}
			return false;
		}

		public override string ToString()
		{
			return Value + " (" + Type.ToString() + ")";
		}
	}
	internal class Tokenizer
	{
		private readonly TextReader _reader;

		private char _char;

		private Token _ahead;

		private bool _eof;

		public bool EOF
		{
			get
			{
				if (_eof)
				{
					return _ahead == null;
				}
				return false;
			}
		}

		public long Position { get; private set; }

		public Token Current { get; private set; }

		public bool CheckEOF()
		{
			if (_eof)
			{
				throw LiteException.UnexpectedToken(Current);
			}
			return false;
		}

		public Tokenizer(string source)
			: this(new StringReader(source))
		{
		}

		public Tokenizer(TextReader reader)
		{
			_reader = reader;
			Position = 0L;
			ReadChar();
		}

		public static bool IsWordChar(char c, bool first)
		{
			if (first)
			{
				if (!char.IsLetter(c) && c != '_')
				{
					return c == '$';
				}
				return true;
			}
			if (!char.IsLetterOrDigit(c) && c != '_')
			{
				return c == '$';
			}
			return true;
		}

		private char ReadChar()
		{
			if (_eof)
			{
				return '\0';
			}
			int num = _reader.Read();
			Position++;
			if (num == -1)
			{
				_char = '\0';
				_eof = true;
			}
			else
			{
				_char = (char)num;
			}
			return _char;
		}

		public Token LookAhead(bool eatWhitespace = true)
		{
			if (_ahead != null)
			{
				if (eatWhitespace && _ahead.Type == TokenType.Whitespace)
				{
					_ahead = ReadNext(eatWhitespace);
				}
				return _ahead;
			}
			return _ahead = ReadNext(eatWhitespace);
		}

		public Token ReadToken(bool eatWhitespace = true)
		{
			if (_ahead == null)
			{
				return Current = ReadNext(eatWhitespace);
			}
			if (eatWhitespace && _ahead.Type == TokenType.Whitespace)
			{
				_ahead = ReadNext(eatWhitespace);
			}
			Current = _ahead;
			_ahead = null;
			return Current;
		}

		private Token ReadNext(bool eatWhitespace)
		{
			if (eatWhitespace)
			{
				EatWhitespace();
			}
			if (_eof)
			{
				return new Token(TokenType.EOF, null, Position);
			}
			Token token = null;
			switch (_char)
			{
			case '{':
				token = new Token(TokenType.OpenBrace, "{", Position);
				ReadChar();
				break;
			case '}':
				token = new Token(TokenType.CloseBrace, "}", Position);
				ReadChar();
				break;
			case '[':
				token = new Token(TokenType.OpenBracket, "[", Position);
				ReadChar();
				break;
			case ']':
				token = new Token(TokenType.CloseBracket, "]", Position);
				ReadChar();
				break;
			case '(':
				token = new Token(TokenType.OpenParenthesis, "(", Position);
				ReadChar();
				break;
			case ')':
				token = new Token(TokenType.CloseParenthesis, ")", Position);
				ReadChar();
				break;
			case ',':
				token = new Token(TokenType.Comma, ",", Position);
				ReadChar();
				break;
			case ':':
				token = new Token(TokenType.Colon, ":", Position);
				ReadChar();
				break;
			case ';':
				token = new Token(TokenType.SemiColon, ";", Position);
				ReadChar();
				break;
			case '@':
				token = new Token(TokenType.At, "@", Position);
				ReadChar();
				break;
			case '#':
				token = new Token(TokenType.Hashtag, "#", Position);
				ReadChar();
				break;
			case '~':
				token = new Token(TokenType.Til, "~", Position);
				ReadChar();
				break;
			case '.':
				token = new Token(TokenType.Period, ".", Position);
				ReadChar();
				break;
			case '&':
				token = new Token(TokenType.Ampersand, "&", Position);
				ReadChar();
				break;
			case '$':
				ReadChar();
				token = ((!IsWordChar(_char, first: true)) ? new Token(TokenType.Dollar, "$", Position) : new Token(TokenType.Word, "$" + ReadWord(), Position));
				break;
			case '!':
				ReadChar();
				if (_char == '=')
				{
					token = new Token(TokenType.NotEquals, "!=", Position);
					ReadChar();
				}
				else
				{
					token = new Token(TokenType.Exclamation, "!", Position);
				}
				break;
			case '=':
				token = new Token(TokenType.Equals, "=", Position);
				ReadChar();
				break;
			case '>':
				ReadChar();
				if (_char == '=')
				{
					token = new Token(TokenType.GreaterOrEquals, ">=", Position);
					ReadChar();
				}
				else
				{
					token = new Token(TokenType.Greater, ">", Position);
				}
				break;
			case '<':
				ReadChar();
				if (_char == '=')
				{
					token = new Token(TokenType.LessOrEquals, "<=", Position);
					ReadChar();
				}
				else
				{
					token = new Token(TokenType.Less, "<", Position);
				}
				break;
			case '-':
				ReadChar();
				if (_char == '-')
				{
					ReadLine();
					token = ReadNext(eatWhitespace);
				}
				else
				{
					token = new Token(TokenType.Minus, "-", Position);
				}
				break;
			case '+':
				token = new Token(TokenType.Plus, "+", Position);
				ReadChar();
				break;
			case '*':
				token = new Token(TokenType.Asterisk, "*", Position);
				ReadChar();
				break;
			case '/':
				token = new Token(TokenType.Slash, "/", Position);
				ReadChar();
				break;
			case '\\':
				token = new Token(TokenType.Backslash, "\\", Position);
				ReadChar();
				break;
			case '%':
				token = new Token(TokenType.Percent, "%", Position);
				ReadChar();
				break;
			case '"':
			case '\'':
				token = new Token(TokenType.String, ReadString(_char), Position);
				break;
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			{
				bool dbl = false;
				string value = ReadNumber(ref dbl);
				token = new Token(dbl ? TokenType.Double : TokenType.Int, value, Position);
				break;
			}
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			{
				StringBuilder stringBuilder = new StringBuilder();
				while (char.IsWhiteSpace(_char) && !_eof)
				{
					stringBuilder.Append(_char);
					ReadChar();
				}
				token = new Token(TokenType.Whitespace, stringBuilder.ToString(), Position);
				break;
			}
			default:
				if (IsWordChar(_char, first: true))
				{
					token = new Token(TokenType.Word, ReadWord(), Position);
				}
				else
				{
					ReadChar();
				}
				break;
			}
			return token ?? new Token(TokenType.Unknown, _char.ToString(), Position);
		}

		private void EatWhitespace()
		{
			while (char.IsWhiteSpace(_char) && !_eof)
			{
				ReadChar();
			}
		}

		private string ReadWord()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(_char);
			ReadChar();
			while (!_eof && IsWordChar(_char, first: false))
			{
				stringBuilder.Append(_char);
				ReadChar();
			}
			return stringBuilder.ToString();
		}

		private string ReadNumber(ref bool dbl)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(_char);
			bool flag = true;
			bool flag2 = true;
			bool flag3 = false;
			ReadChar();
			while (!_eof && (char.IsDigit(_char) || _char == '+' || _char == '-' || _char == '.' || _char == 'e' || _char == 'E'))
			{
				if (_char == '.')
				{
					if (!flag)
					{
						break;
					}
					dbl = true;
					flag = false;
				}
				else if (_char == 'e' || _char == 'E')
				{
					if (!flag2)
					{
						break;
					}
					flag2 = false;
					flag3 = true;
					dbl = true;
				}
				else if (_char == '-' || _char == '+')
				{
					if (!flag3)
					{
						break;
					}
					flag3 = false;
				}
				stringBuilder.Append(_char);
				ReadChar();
			}
			return stringBuilder.ToString();
		}

		private string ReadString(char quote)
		{
			StringBuilder stringBuilder = new StringBuilder();
			ReadChar();
			while (_char != quote && !_eof)
			{
				if (_char == '\\')
				{
					ReadChar();
					if (_char == quote)
					{
						stringBuilder.Append(quote);
					}
					switch (_char)
					{
					case '\\':
						stringBuilder.Append('\\');
						break;
					case '/':
						stringBuilder.Append('/');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'u':
					{
						uint num = ParseUnicode(ReadChar(), ReadChar(), ReadChar(), ReadChar());
						stringBuilder.Append((char)num);
						break;
					}
					}
				}
				else
				{
					stringBuilder.Append(_char);
				}
				ReadChar();
			}
			ReadChar();
			return stringBuilder.ToString();
		}

		private void ReadLine()
		{
			while (_char != '\n' && !_eof)
			{
				ReadChar();
			}
			if (_char == '\n')
			{
				ReadChar();
			}
		}

		public static uint ParseUnicode(char c1, char c2, char c3, char c4)
		{
			uint num = ParseSingleChar(c1, 4096u);
			uint num2 = ParseSingleChar(c2, 256u);
			uint num3 = ParseSingleChar(c3, 16u);
			uint num4 = ParseSingleChar(c4, 1u);
			return num + num2 + num3 + num4;
		}

		public static uint ParseSingleChar(char c1, uint multiplier)
		{
			uint result = 0u;
			if (c1 >= '0' && c1 <= '9')
			{
				result = (uint)(c1 - 48) * multiplier;
			}
			else if (c1 >= 'A' && c1 <= 'F')
			{
				result = (uint)(c1 - 65 + 10) * multiplier;
			}
			else if (c1 >= 'a' && c1 <= 'f')
			{
				result = (uint)(c1 - 97 + 10) * multiplier;
			}
			return result;
		}

		public override string ToString()
		{
			return Current?.ToString() + " [ahead: " + _ahead?.ToString() + "] - position: " + Position;
		}
	}
}
namespace LiteDB.Utils
{
	internal class TryCatch
	{
		public readonly List<Exception> Exceptions = new List<Exception>();

		public bool InvalidDatafileState => Exceptions.Any((Exception ex) => ex is LiteException ex2 && ex2.ErrorCode == 999);

		public TryCatch()
		{
		}

		public TryCatch(Exception initial)
		{
			Exceptions.Add(initial);
		}

		[DebuggerHidden]
		public void Catch(Action action)
		{
			try
			{
				action();
			}
			catch (Exception item)
			{
				Exceptions.Add(item);
			}
		}
	}
}
namespace LiteDB.Utils.Extensions
{
	internal static class EnumerableExtensions
	{
		[CompilerGenerated]
		private sealed class <OnDispose>d__0<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<T> source;

			public IEnumerable<T> <>3__source;

			private Action onDispose;

			public Action <>3__onDispose;

			private IEnumerator<T> <>7__wrap1;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>1__state = -3;
						<>7__wrap1 = source.GetEnumerator();
						<>1__state = -4;
						break;
					case 1:
						<>1__state = -4;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>7__wrap1 = null;
					<>m__Finally1();
					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;
				onDispose();
			}

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

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<OnDispose>d__0<T> <OnDispose>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnDispose>d__ = this;
				}
				else
				{
					<OnDispose>d__ = new <OnDispose>d__0<T>(0);
				}
				<OnDispose>d__.source = <>3__source;
				<OnDispose>d__.onDispose = <>3__onDispose;
				return <OnDispose>d__;
			}

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

		[IteratorStateMachine(typeof(<OnDispose>d__0<>))]
		public static IEnumerable<T> OnDispose<T>(this IEnumerable<T> source, Action onDispose)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnDispose>d__0<T>(-2)
			{
				<>3__source = source,
				<>3__onDispose = onDispose
			};
		}
	}
	internal static class StopWatchExtensions
	{
		private class DisposableAction : IDisposable
		{
			private readonly Action _action;

			public DisposableAction(Action action)
			{
				_action = action;
			}

			public void Dispose()
			{
				_action();
			}
		}

		public static IDisposable StartDisposable(this Stopwatch stopwatch)
		{
			stopwatch.Start();
			return new DisposableAction(stopwatch.Stop);
		}
	}
}
namespace LiteDB.Engine
{
	internal class DiskReader : IDisposable
	{
		private readonly EngineState _state;

		private readonly MemoryCache _cache;

		private readonly StreamPool _dataPool;

		private readonly StreamPool _logPool;

		private readonly Lazy<Stream> _dataStream;

		private readonly Lazy<Stream> _logStream;

		public DiskReader(EngineState state, MemoryCache cache, StreamPool dataPool, StreamPool logPool)
		{
			_state = state;
			_cache = cache;
			_dataPool = dataPool;
			_logPool = logPool;
			_dataStream = new Lazy<Stream>(() => _dataPool.Rent());
			_logStream = new Lazy<Stream>(() => _logPool.Rent());
		}

		public PageBuffer ReadPage(long position, bool writable, FileOrigin origin)
		{
			Constants.ENSURE(position % 8192 == 0, "invalid page position");
			Stream stream = ((origin == FileOrigin.Data) ? _dataStream.Value : _logStream.Value);
			if (!writable)
			{
				return _cache.GetReadablePage(position, origin, delegate(long pos, BufferSlice buf)
				{
					ReadStream(stream, pos, buf);
				});
			}
			return _cache.GetWritablePage(position, origin, delegate(long pos, BufferSlice buf)
			{
				ReadStream(stream, pos, buf);
			});
		}

		private void ReadStream(Stream stream, long position, BufferSlice buffer)
		{
			stream.Position = position;
			stream.Read(buffer.Array, buffer.Offset, buffer.Count);
		}

		public PageBuffer NewPage()
		{
			return _cache.NewPage();
		}

		public void Dispose()
		{
			if (_dataStream.IsValueCreated)
			{
				_dataPool.Return(_dataStream.Value);
			}
			if (_logStream.IsValueCreated)
			{
				_logPool.Return(_logStream.Value);
			}
		}
	}
	internal class DiskService : IDisposable
	{
		[CompilerGenerated]
		private sealed class <ReadFull>d__23 : IEnumerable<PageBuffer>, IEnumerable, IEnumerator<PageBuffer>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private PageBuffer <>2__current;

			private int <>l__initialThreadId;

			private FileOrigin origin;

			public FileOrigin <>3__origin;

			public DiskService <>4__this;

			private byte[] <buffer>5__2;

			private StreamPool <pool>5__3;

			private Stream <stream>5__4;

			private long <length>5__5;

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

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

			[DebuggerHidden]
			public <ReadFull>d__23(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();
					}
				}
				<buffer>5__2 = null;
				<pool>5__3 = null;
				<stream>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					DiskService diskService = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<buffer>5__2 = new byte[8192];
						<pool>5__3 = ((origin == FileOrigin.Log) ? diskService._logPool : diskService._dataPool);
						<stream>5__4 = <pool>5__3.Rent();
						<>1__state = -3;
						<length>5__5 = diskService.GetFileLength(origin);
						<stream>5__4.Position = 0L;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<stream>5__4.Position < <length>5__5)
					{
						long position = <stream>5__4.Position;
						int num2 = <stream>5__4.Read(<buffer>5__2, 0, 8192);
						Constants.ENSURE(num2 == 8192, "ReadFull must read PAGE_SIZE bytes [{0}]", num2);
						<>2__current = new PageBuffer(<buffer>5__2, 0, 0)
						{
							Position = position,
							Origin = origin,
							ShareCounter = 0
						};
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					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;
				<pool>5__3.Return(<stream>5__4);
			}

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

			[DebuggerHidden]
			IEnumerator<PageBuffer> IEnumerable<PageBuffer>.GetEnumerator()
			{
				<ReadFull>d__23 <ReadFull>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ReadFull>d__ = this;
				}
				else
				{
					<ReadFull>d__ = new <ReadFull>d__23(0)
					{
						<>4__this = <>4__this
					};
				}
				<ReadFull>d__.origin = <>3__origin;
				return <ReadFull>d__;
			}

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

		private readonly MemoryCache _cache;

		private readonly EngineState _state;

		private IStreamFactory _dataFactory;

		private readonly IStreamFactory _logFactory;

		private StreamPool _dataPool;

		private readonly StreamPool _logPool;

		private readonly Lazy<Stream> _writer;

		private long _dataLength;

		private long _logLength;

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		public MemoryCache Cache => _cache;

		public uint MAX_ITEMS_COUNT => (uint)((int)((_dataLength + _logLength) / 8192 + 10) * 255);

		public DiskService(EngineSettings settings, EngineState state, int[] memorySegmentSizes)
		{
			_cache = new MemoryCache(memorySegmentSizes);
			_state = state;
			_dataFactory = settings.CreateDataFactory();
			_logFactory = settings.CreateLogFactory();
			_dataPool = new StreamPool(_dataFactory, appendOnly: false);
			_logPool = new StreamPool(_logFactory, appendOnly: true);
			_writer = _logPool.Writer;
			if (_dataFactory.GetLength() == 0)
			{
				Initialize(_dataPool.Writer.Value, settings.Collation, settings.InitialSize);
			}
			if (!settings.ReadOnly)
			{
				_ = _dataPool.Writer.Value.CanRead;
			}
			_dataLength = _dataFactory.GetLength() - 8192;
			if (_logFactory.Exists())
			{
				_logLength = _logFactory.GetLength() - 8192;
			}
			else
			{
				_logLength = -8192L;
			}
		}

		private void Initialize(Stream stream, Collation collation, long initialSize)
		{
			PageBuffer pageBuffer = new PageBuffer(new byte[8192], 0, 0);
			HeaderPage headerPage = new HeaderPage(pageBuffer, 0u);
			headerPage.Pragmas.Set("COLLATION", (collation ?? Collation.Default).ToString(), validate: false);
			headerPage.UpdateBuffer();
			stream.Write(pageBuffer.Array, pageBuffer.Offset, 8192);
			if (initialSize > 0)
			{
				if (stream is AesStream)
				{
					throw LiteException.InitialSizeCryptoNotSupported();
				}
				if (initialSize % 8192 != 0L)
				{
					throw LiteException.InvalidInitialSize();
				}
				stream.SetLength(initialSize);
			}
			stream.FlushToDisk();
		}

		public DiskReader GetReader()
		{
			return new DiskReader(_state, _cache, _dataPool, _logPool);
		}

		public void DiscardDirtyPages(IEnumerable<PageBuffer> pages)
		{
			foreach (PageBuffer page in pages)
			{
				_cache.DiscardPage(page);
			}
		}

		public void DiscardCleanPages(IEnumerable<PageBuffer> pages)
		{
			foreach (PageBuffer page in pages)
			{
				if (!_cache.TryMoveToReadable(page))
				{
					_cache.DiscardPage(page);
				}
			}
		}

		public PageBuffer NewPage()
		{
			return _cache.NewPage();
		}

		public int WriteLogDisk(IEnumerable<PageBuffer> pages)
		{
			int num = 0;
			Stream value = _writer.Value;
			lock (value)
			{
				foreach (PageBuffer page in pages)
				{
					Constants.ENSURE(page.ShareCounter == Constants.BUFFER_WRITABLE, "to enqueue page, page must be writable");
					page.Position = Interlocked.Add(ref _logLength, 8192L);
					page.Origin = FileOrigin.Log;
					_cache.MoveToReadable(page);
					value.Position = page.Position;
					value.Write(page.Array, page.Offset, 8192);
					page.Release();
					num++;
				}
				value.Flush();
				return num;
			}
		}

		public long GetFileLength(FileOrigin origin)
		{
			if (origin == FileOrigin.Log)
			{
				return _logLength + 8192;
			}
			return _dataLength + 8192;
		}

		internal void MarkAsInvalidState()
		{
			FileHelper.TryExec(60, delegate
			{
				using Stream stream = _dataFactory.GetStream(canWrite: true, sequencial: true);
				byte[] array = _bufferPool.Rent(8192);
				stream.Read(array, 0, 8192);
				array[191] = 1;
				stream.Position = 0L;
				stream.Write(array, 0, 8192);
				_bufferPool.Return(array, clearArray: true);
			});
		}

		[IteratorStateMachine(typeof(<ReadFull>d__23))]
		public IEnumerable<PageBuffer> ReadFull(FileOrigin origin)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReadFull>d__23(-2)
			{
				<>4__this = this,
				<>3__origin = origin
			};
		}

		public void WriteDataDisk(IEnumerable<PageBuffer> pages)
		{
			Stream value = _dataPool.Writer.Value;
			foreach (PageBuffer page in pages)
			{
				Constants.ENSURE(page.ShareCounter == 0, "this page can't be shared to use sync operation - do not use cached pages");
				_dataLength = Math.Max(_dataLength, page.Position);
				value.Position = page.Position;
				value.Write(page.Array, page.Offset, 8192);
			}
			value.FlushToDisk();
		}

		public void SetLength(long length, FileOrigin origin)
		{
			Lazy<Stream> obj = ((origin == FileOrigin.Log) ? _logPool.Writer : _dataPool.Writer);
			if (origin == FileOrigin.Log)
			{
				Interlocked.Exchange(ref _logLength, length - 8192);
			}
			else
			{
				Interlocked.Exchange(ref _dataLength, length - 8192);
			}
			obj.Value.SetLength(length);
		}

		public string GetName(FileOrigin origin)
		{
			if (origin != FileOrigin.Data)
			{
				return _logFactory.Name;
			}
			return _dataFactory.Name;
		}

		public void Dispose()
		{
			bool num = _logFactory.Exists() && _logPool.Writer.Value.Length == 0;
			_dataPool.Dispose();
			_logPool.Dispose();
			if (num)
			{
				_logFactory.Delete();
			}
			_cache.Dispose();
		}
	}
	internal class MemoryCache : IDisposable
	{
		private readonly ConcurrentQueue<PageBuffer> _free = new ConcurrentQueue<PageBuffer>();

		private readonly ConcurrentDictionary<long, PageBuffer> _readable = new ConcurrentDictionary<long, PageBuffer>();

		private int _extends;

		private readonly int[] _segmentSizes;

		public int PagesInUse => _readable.Values.Where((PageBuffer x) => x.ShareCounter != 0).Count();

		public int FreePages => _free.Count;

		public int ExtendSegments => _extends;

		public int ExtendPages => (from x in Enumerable.Range(0, _extends)
			select _segmentSizes[Math.Min(_segmentSizes.Length - 1, x)]).Sum();

		public int WritablePages => ExtendPages - _free.Count - _readable.Count;

		public MemoryCache(int[] memorySegmentSizes)
		{
			_segmentSizes = memorySegmentSizes;
			Extend();
		}

		public PageBuffer GetReadablePage(long position, FileOrigin origin, Action<long, BufferSlice> factory)
		{
			long readableKey = GetReadableKey(position, origin);
			PageBuffer orAdd = _readable.GetOrAdd(readableKey, delegate
			{
				PageBuffer freePage = GetFreePage();
				freePage.Position = position;
				freePage.Origin = origin;
				factory(position, freePage);
				return freePage;
			});
			Interlocked.Exchange(ref orAdd.Timestamp, DateTime.UtcNow.Ticks);
			Interlocked.Increment(ref orAdd.ShareCounter);
			return orAdd;
		}

		private long GetReadableKey(long position, FileOrigin origin)
		{
			Constants.ENSURE(origin != FileOrigin.None, "file origin must be defined");
			if (origin == FileOrigin.Data)
			{
				return position;
			}
			if (position == 0L)
			{
				return long.MinValue;
			}
			return -position;
		}

		public PageBuffer GetWritablePage(long position, FileOrigin origin, Action<long, BufferSlice> factory)
		{
			long readableKey = GetReadableKey(position, origin);
			PageBuffer pageBuffer = NewPage(position, origin);
			if (_readable.TryGetValue(readableKey, out var value))
			{
				Buffer.BlockCopy(value.Array, value.Offset, pageBuffer.Array, pageBuffer.Offset, 8192);
			}
			else
			{
				factory(position, pageBuffer);
			}
			return pageBuffer;
		}

		public PageBuffer NewPage()
		{
			return NewPage(long.MaxValue, FileOrigin.None);
		}

		private PageBuffer NewPage(long position, FileOrigin origin)
		{
			PageBuffer freePage = GetFreePage();
			freePage.Position = position;
			freePage.ShareCounter = Constants.BUFFER_WRITABLE;
			if (freePage.Timestamp > 0)
			{
				freePage.Clear();
			}
			freePage.Origin = origin;
			freePage.Timestamp = DateTime.UtcNow.Ticks;
			return freePage;
		}

		public bool TryMoveToReadable(PageBuffer page)
		{
			Constants.ENSURE(page.Position != long.MaxValue, "page must have a position");
			Constants.ENSURE(page.ShareCounter == Constants.BUFFER_WRITABLE, "page must be writable");
			Constants.ENSURE(page.Origin != FileOrigin.None, "page must have origin defined");
			long readableKey = GetReadableKey(page.Position, page.Origin);
			page.ShareCounter = 0;
			bool num = _readable.TryAdd(readableKey, page);
			if (!num)
			{
				page.ShareCounter = Constants.BUFFER_WRITABLE;
			}
			return num;
		}

		public PageBuffer MoveToReadable(PageBuffer page)
		{
			Constants.ENSURE(page.Position != long.MaxValue, "page must have position to be readable");
			Constants.ENSURE(page.Origin != FileOrigin.None, "page should be a source before move to readable");
			Constants.ENSURE(page.ShareCounter == Constants.BUFFER_WRITABLE, "page must be writable before move to readable dict");
			long readableKey = GetReadableKey(page.Position, page.Origin);
			bool added = true;
			page.ShareCounter = 1;
			PageBuffer result = _readable.AddOrUpdate(readableKey, page, delegate(long newKey, PageBuffer current)
			{
				Constants.ENSURE(current.ShareCounter == 0, "user must ensure this page is not in use when marked as read only");
				Constants.ENSURE(current.Origin == page.Origin, "origin must be same");
				current.ShareCounter = 1;
				Buffer.BlockCopy(page.Array, page.Offset, current.Array, current.Offset, 8192);
				added = false;
				page.ShareCounter = Constants.BUFFER_WRITABLE;
				return current;
			});
			if (!added)
			{
				DiscardPage(page);
			}
			return result;
		}

		public void DiscardPage(PageBuffer page)
		{
			Constants.ENSURE(page.ShareCounter == Constants.BUFFER_WRITABLE, "discarded page must be writable");
			page.ShareCounter = 0;
			page.Position = long.MaxValue;
			page.Origin = FileOrigin.None;
			_free.Enqueue(page);
		}

		private PageBuffer GetFreePage()
		{
			if (_free.TryDequeue(out var result))
			{
				Constants.ENSURE(result.Position == long.MaxValue, "pages in memory store must have no position defined");
				Constants.ENSURE(result.ShareCounter == 0, "pages in memory store must be non-shared");
				Constants.ENSURE(result.Origin == FileOrigin.None, "page in memory must have no page origin");
				return result;
			}
			lock (_free)
			{
				if (_free.Count > 0)
				{
					return GetFreePage();
				}
				Extend();
			}
			return GetFreePage();
		}

		private void Extend()
		{
			int num = _readable.Values.Count((PageBuffer x) => x.ShareCounter == 0);
			int num2 = _segmentSizes[Math.Min(_segmentSizes.Length - 1, _extends)];
			if (num > num2)
			{
				long[] array = (from x in _readable
					where x.Value.ShareCounter == 0
					orderby x.Value.Timestamp
					select x.Key).Take(num2).ToArray();
				foreach (long key in array)
				{
					Constants.ENSURE(_readable.TryRemove(key, out var value), "page should be in readable list before moving to free list");
					if (value.ShareCounter > 0)
					{
						if (!_readable.TryAdd(key, value))
						{
							throw new LiteException(0, "MemoryCache: removed in-use memory page. This situation has no way to fix (yet). Throwing exception to avoid database corruption. No other thread can read/write from database now.");
						}
					}
					else
					{
						Constants.ENSURE(value.ShareCounter == 0, "page should not be in use by anyone");
						value.Position = long.MaxValue;
						value.Origin = FileOrigin.None;
						_free.Enqueue(value);
					}
				}
			}
			else
			{
				byte[] buffer = new byte[8192 * num2];
				int num3 = ExtendPages + 1;
				for (int j = 0; j < num2; j++)
				{
					_free.Enqueue(new PageBuffer(buffer, j * 8192, num3++));
				}
				_extends++;
			}
		}

		public ICollection<PageBuffer> GetPages()
		{
			return _readable.Values;
		}

		public int Clear()
		{
			int num = 0;
			Constants.ENSURE(PagesInUse == 0, "must have no pages in use when call Clear() cache");
			foreach (PageBuffer value in _readable.Values)
			{
				value.Position = long.MaxValue;
				value.Origin = FileOrigin.None;
				_free.Enqueue(value);
				num++;
			}
			_readable.Clear();
			return num;
		}

		public void Dispose()
		{
		}
	}
	internal class BufferReader : IDisposable
	{
		private readonly IEnumerator<BufferSlice> _source;

		private readonly bool _utcDate;

		private BufferSlice _current;

		private int _currentPosition;

		private int _position;

		private bool _isEOF;

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		public int Position => _position;

		public bool IsEOF => _isEOF;

		public BufferReader(byte[] buffer, bool utcDate = false)
			: this(new BufferSlice(buffer, 0, buffer.Length), utcDate)
		{
		}

		public BufferReader(BufferSlice buffer, bool utcDate = false)
		{
			_source = null;
			_utcDate = utcDate;
			_current = buffer;
		}

		public BufferReader(IEnumerable<BufferSlice> source, bool utcDate = false)
		{
			_source = source.GetEnumerator();
			_utcDate = utcDate;
			_source.MoveNext();
			_current = _source.Current;
		}

		private bool MoveForward(int count)
		{
			if (_isEOF)
			{
				return false;
			}
			Constants.ENSURE(_currentPosition + count <= _current.Count, "forward is only for current segment");
			_currentPosition += count;
			_position += count;
			if (_currentPosition == _current.Count)
			{
				if (_source == null || !_source.MoveNext())
				{
					_isEOF = true;
				}
				else
				{
					_current = _source.Current;
					_currentPosition = 0;
				}
				return true;
			}
			return false;
		}

		public int Read(byte[] buffer, int offset, int count)
		{
			int num = 0;
			while (num < count)
			{
				int val = _current.Count - _currentPosition;
				int num2 = Math.Min(count - num, val);
				if (buffer != null)
				{
					Buffer.BlockCopy(_current.Array, _current.Offset + _currentPosition, buffer, offset + num, num2);
				}
				num += num2;
				MoveForward(num2);
				if (_isEOF)
				{
					break;
				}
			}
			Constants.ENSURE(count == num, "current value must fit inside defined buffer");
			return num;
		}

		public int Skip(int count)
		{
			return Read(null, 0, count);
		}

		public void Consume()
		{
			if (_source != null)
			{
				while (_source.MoveNext())
				{
				}
			}
		}

		private bool TryReadCStringCurrentSegment(out string value)
		{
			int i = _currentPosition;
			int num = 0;
			for (; i < _current.Count; i++)
			{
				if (_current[i] == 0)
				{
					value = StringEncoding.UTF8.GetString(_current.Array, _current.Offset + _currentPosition, num);
					MoveForward(num + 1);
					return true;
				}
				num++;
			}
			value = null;
			return false;
		}

		private T ReadNumber<T>(Func<byte[], int, T> convert, int size)
		{
			T result;
			if (_currentPosition + size <= _current.Count)
			{
				result = convert(_current.Array, _current.Offset + _currentPosition);
				MoveForward(size);
			}
			else
			{
				byte[] array = _bufferPool.Rent(size);
				Read(array, 0, size);
				result = convert(array, 0);
				_bufferPool.Return(array, clearArray: true);
			}
			return result;
		}

		public int ReadInt32()
		{
			return ReadNumber(BitConverter.ToInt32, 4);
		}

		public long ReadInt64()
		{
			return ReadNumber(BitConverter.ToInt64, 8);
		}

		public ushort ReadUInt16()
		{
			return ReadNumber(BitConverter.ToUInt16, 2);
		}

		public uint ReadUInt32()
		{
			return ReadNumber(BitConverter.ToUInt32, 4);
		}

		public float ReadSingle()
		{
			return ReadNumber(BitConverter.ToSingle, 4);
		}

		public double ReadDouble()
		{
			return ReadNumber(BitConverter.ToDouble, 8);
		}

		public decimal ReadDecimal()
		{
			int num = ReadInt32();
			int num2 = ReadInt32();
			int num3 = ReadInt32();
			int num4 = ReadInt32();
			return new decimal(new int[4] { num, num2, num3, num4 });
		}

		public DateTime ReadDateTime()
		{
			DateTime result = new DateTime(ReadInt64(), DateTimeKind.Utc);
			if (!_utcDate)
			{
				return result;
			}
			return result.ToLocalTime();
		}

		public Guid ReadGuid()
		{
			Guid result;
			if (_currentPosition + 16 <= _current.Count)
			{
				result = _current.ReadGuid(_currentPosition);
				MoveForward(16);
			}
			else
			{
				result = new Guid(ReadBytes(16));
			}
			return result;
		}

		public ObjectId ReadObjectId()
		{
			ObjectId result;
			if (_currentPosition + 12 <= _current.Count)
			{
				result = new ObjectId(_current.Array, _current.Offset + _currentPosition);
				MoveForward(12);
			}
			else
			{
				byte[] array = _bufferPool.Rent(12);
				Read(array, 0, 12);
				result = new ObjectId(array);
				_bufferPool.Return(array, clearArray: true);
			}
			return result;
		}

		public bool ReadBoolean()
		{
			bool result = _current[_currentPosition] != 0;
			MoveForward(1);
			return result;
		}

		private BsonValue ReadVector()
		{
			ushort num = ReadUInt16();
			float[] array = new float[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = ReadSingle();
			}
			return new BsonVector(array);
		}

		public byte ReadByte()
		{
			byte result = _current[_currentPosition];
			MoveForward(1);
			return result;
		}

		internal PageAddress ReadPageAddress()
		{
			return new PageAddress(ReadUInt32(), ReadByte());
		}

		public byte[] ReadBytes(int count)
		{
			byte[] array = new byte[count];
			Read(array, 0, count);
			return array;
		}

		public BsonValue ReadIndexKey()
		{
			return (BsonType)ReadByte() switch
			{
				BsonType.Null => BsonValue.Null, 
				BsonType.Int32 => ReadInt32(), 
				BsonType.Int64 => ReadInt64(), 
				BsonType.Double => ReadDouble(), 
				BsonType.Decimal => ReadDecimal(), 
				BsonType.String => ReadString(ReadByte()), 
				BsonType.Document => ReadDocument().GetValue(), 
				BsonType.Array => ReadArray().GetValue(), 
				BsonType.Binary => ReadBytes(ReadByte()), 
				BsonType.ObjectId => ReadObjectId(), 
				BsonType.Guid => ReadGuid(), 
				BsonType.Boolean => ReadBoolean(), 
				BsonType.DateTime => ReadDateTime(), 
				BsonType.MinValue => BsonValue.MinValue, 
				BsonType.MaxValue => BsonValue.MaxValue, 
				BsonType.Vector => ReadVector(), 
				_ => throw new NotImplementedException(), 
			};
		}

		public Result<BsonDocument> ReadDocument(HashSet<string> fields = null)
		{
			BsonDocument bsonDocument = new BsonDocument();
			try
			{
				int num = ReadInt32();
				int num2 = _position + num - 5;
				HashSet<string> hashSet = ((fields == null || fields.Count == 0) ? null : new HashSet<string>(fields, StringComparer.OrdinalIgnoreCase));
				while (_position < num2 && (hashSet == null || (hashSet != null && hashSet.Count > 0)))
				{
					string name;
					BsonValue bsonValue = ReadElement(hashSet, out name);
					if (bsonValue != null)
					{
						bsonDocument[name] = bsonValue;
						hashSet?.Remove(name);
					}
				}
				MoveForward(1);
				return bsonDocument;
			}
			catch (Exception ex)
			{
				return new Result<BsonDocument>(bsonDocument, ex);
			}
		}

		public Result<BsonArray> ReadArray()
		{
			BsonArray bsonArray = new BsonArray();
			try
			{
				int num = ReadInt32();
				int num2 = _position + num - 5;
				while (_position < num2)
				{
					string name;
					BsonValue item = ReadElement(null, out name);
					bsonArray.Add(item);
				}
				MoveForward(1);
				return bsonArray;
			}
			catch (Exception ex)
			{
				return new Result<BsonArray>(bsonArray, ex);
			}
		}

		private BsonValue ReadElement(HashSet<string> remaining, out string name)
		{
			byte b = ReadByte();
			name = ReadCString();
			if (remaining != null && !remaining.Contains(name))
			{
				int num;
				switch (b)
				{
				default:
					num = 0;
					break;
				case 3:
				case 4:
					num = ReadInt32() - 4;
					break;
				case 5:
					num = ReadInt32() + 1;
					break;
				case 2:
					num = ReadInt32();
					break;
				case 19:
					num = 16;
					break;
				case 7:
					num = 12;
					break;
				case 1:
				case 9:
				case 18:
					num = 8;
					break;
				case 16:
					num = 4;
					break;
				case 8:
					num = 1;
					break;
				case 10:
				case 127:
				case byte.MaxValue:
					num = 0;
					break;
				}
				int num2 = num;
				if (num2 > 0)
				{
					Skip(num2);
				}
				return null;
			}
			switch (b)
			{
			case 1:
				return ReadDouble();
			case 2:
			{
				int num4 = ReadInt32();
				string text = ReadString(num4 - 1);
				MoveForward(1);
				return text;
			}
			case 3:
				return ReadDocument().GetValue();
			case 4:
				return ReadArray().GetValue();
			case 5:
			{
				int count = ReadInt32();
				byte b2 = ReadByte();
				byte[] array = ReadBytes(count);
				switch (b2)
				{
				case 0:
					return array;
				case 4:
					return new Guid(array);
				}
				break;
			}
			case 7:
				return ReadObjectId();
			case 8:
				return ReadBoolean();
			case 9:
			{
				long num3 = ReadInt64();
				switch (num3)
				{
				case 253402300800000L:
					return DateTime.MaxValue;
				case -62135596800000L:
					return DateTime.MinValue;
				default:
				{
					DateTime unixEpoch = BsonValue.UnixEpoch;
					DateTime dateTime = unixEpoch.AddMilliseconds(num3);
					return _utcDate ? dateTime : dateTime.ToLocalTime();
				}
				}
			}
			case 10:
				return BsonValue.Null;
			case 16:
				return ReadInt32();
			case 18:
				return ReadInt64();
			case 19:
				return ReadDecimal();
			case byte.MaxValue:
				return BsonValue.MinValue;
			case 127:
				return BsonValue.MaxValue;
			case 100:
				return ReadVector();
			}
			throw new NotSupportedException("BSON type not supported");
		}

		public void Dispose()
		{
			_source?.Dispose();
		}

		public string ReadString(int count)
		{
			string @string;
			if (_currentPosition + count <= _current.Count)
			{
				@string = StringEncoding.UTF8.GetString(_current.Array, _current.Offset + _currentPosition, count);
				MoveForward(count);
			}
			else
			{
				byte[] array = _bufferPool.Rent(count);
				Read(array, 0, count);
				@string = StringEncoding.UTF8.GetString(array, 0, count);
				_bufferPool.Return(array, clearArray: true);
			}
			return @string;
		}

		public string ReadCString()
		{
			if (TryReadCStringCurrentSegment(out var value))
			{
				return value;
			}
			using MemoryStream memoryStream = new MemoryStream();
			int count = _current.Count - _currentPosition;
			memoryStream.Write(_current.Array, _current.Offset + _currentPosition, count);
			MoveForward(count);
			while (_current[_currentPosition] != 0 && !_isEOF)
			{
				memoryStream.WriteByte(_current[_currentPosition]);
				MoveForward(1);
			}
			MoveForward(1);
			return StringEncoding.UTF8.GetString(memoryStream.ToArray());
		}
	}
	internal class BufferWriter : IDisposable
	{
		private readonly IEnumerator<BufferSlice> _source;

		private BufferSlice _current;

		private int _currentPosition;

		private int _position;

		private bool _isEOF;

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		public int Position => _position;

		public bool IsEOF => _isEOF;

		public BufferWriter(byte[] buffer)
			: this(new BufferSlice(buffer, 0, buffer.Length))
		{
		}

		public BufferWriter(BufferSlice buffer)
		{
			_source = null;
			_current = buffer;
		}

		public BufferWriter(IEnumerable<BufferSlice> source)
		{
			_source = source.GetEnumerator();
			_source.MoveNext();
			_current = _source.Current;
		}

		private bool MoveForward(int count)
		{
			if (_isEOF)
			{
				return false;
			}
			Constants.ENSURE(_currentPosition + count <= _current.Count, "forward is only for current segment");
			_currentPosition += count;
			_position += count;
			if (_currentPosition == _current.Count)
			{
				if (_source == null || !_source.MoveNext())
				{
					_isEOF = true;
				}
				else
				{
					_current = _source.Current;
					_currentPosition = 0;
				}
				return true;
			}
			return false;
		}

		public int Write(byte[] buffer, int offset, int count)
		{
			int num = 0;
			while (num < count)
			{
				int val = _current.Count - _currentPosition;
				int num2 = Math.Min(count - num, val);
				if (buffer != null)
				{
					Buffer.BlockCopy(buffer, offset + num, _current.Array, _current.Offset + _currentPosition, num2);
				}
				num += num2;
				MoveForward(num2);
				if (_isEOF)
				{
					break;
				}
			}
			Constants.ENSURE(count == num, "current value must fit inside defined buffer");
			return num;
		}

		public int Write(byte[] buffer)
		{
			return Write(buffer, 0, buffer.Length);
		}

		public int Skip(int count)
		{
			return Write(null, 0, count);
		}

		public void Consume()
		{
			if (_source != null)
			{
				while (_source.MoveNext())
				{
				}
			}
		}

		public void WriteCString(string value)
		{
			if (value.IndexOf('\0') > -1)
			{
				throw LiteException.InvalidNullCharInString();
			}
			int byteCount = StringEncoding.UTF8.GetByteCount(value);
			int num = _current.Count - _currentPosition;
			if (byteCount < num)
			{
				StringEncoding.UTF8.GetBytes(value, 0, value.Length, _current.Array, _current.Offset + _currentPosition);
				_current[_currentPosition + byteCount] = 0;
				MoveForward(byteCount + 1);
				return;
			}
			byte[] array = _bufferPool.Rent(byteCount);
			StringEncoding.UTF8.GetBytes(value, 0, value.Length, array, 0);
			Write(array, 0, byteCount);
			_current[_currentPosition] = 0;
			MoveForward(1);
			_bufferPool.Return(array, clearArray: true);
		}

		public void WriteString(string value, bool specs)
		{
			int byteCount = StringEncoding.UTF8.GetByteCount(value);
			if (specs)
			{
				Write(byteCount + 1);
			}
			if (byteCount <= _current.Count - _currentPosition)
			{
				StringEncoding.UTF8.GetBytes(value, 0, value.Length, _current.Array, _current.Offset + _currentPosition);
				MoveForward(byteCount);
			}
			else
			{
				byte[] array = _bufferPool.Rent(byteCount);
				StringEncoding.UTF8.GetBytes(value, 0, value.Length, array, 0);
				Write(array, 0, byteCount);
				_bufferPool.Return(array, clearArray: true);
			}
			if (specs)
			{
				Write((byte)0);
			}
		}

		private void WriteNumber<T>(T value, Action<T, byte[], int> toBytes, int size)
		{
			if (_currentPosition + size <= _current.Count)
			{
				toBytes(value, _current.Array, _current.Offset + _currentPosition);
				MoveForward(size);
				return;
			}
			byte[] array = _bufferPool.Rent(size);
			toBytes(value, array, 0);
			Write(array, 0, size);
			_bufferPool.Return(array, clearArray: true);
		}

		public void Write(int value)
		{
			WriteNumber(value, BufferExtensions.ToBytes, 4);
		}

		public void Write(long value)
		{
			WriteNumber(value, BufferExtensions.ToBytes, 8);
		}

		public void Write(ushort value)
		{
			WriteNumber(value, BufferExtensions.ToBytes, 2);
		}

		public void Write(uint value)
		{
			WriteNumber(value, BufferExtensions.ToBytes, 4);
		}

		public void Write(float value)
		{
			WriteNumber(value, BufferExtensions.ToBytes, 4);
		}

		public void Write(double value)
		{
			WriteNumber(value, BufferExtensions.ToBytes, 8);
		}

		public void Write(decimal value)
		{
			int[] bits = decimal.GetBits(value);
			Write(bits[0]);
			Write(bits[1]);
			Write(bits[2]);
			Write(bits[3]);
		}

		public void Write(DateTime value)
		{
			Write(((value == DateTime.MinValue || value == DateTime.MaxValue) ? value : value.ToUniversalTime()).Ticks);
		}

		public void Write(Guid value)
		{
			byte[] buffer = value.ToByteArray();
			Write(buffer, 0, 16);
		}

		public void Write(ObjectId value)
		{
			if (_currentPosition + 12 <= _current.Count)
			{
				value.ToByteArray(_current.Array, _current.Offset + _currentPosition);
				MoveForward(12);
				return;
			}
			byte[] array = _bufferPool.Rent(12);
			value.ToByteArray(array, 0);
			Write(array, 0, 12);
			_bufferPool.Return(array, clearArray: true);
		}

		public void Write(bool value)
		{
			_current[_currentPosition] = (value ? ((byte)1) : ((byte)0));
			MoveForward(1);
		}

		public void Write(byte value)
		{
			_current[_currentPosition] = value;
			MoveForward(1);
		}

		internal void Write(PageAddress address)
		{
			Write(address.PageID);
			Write(address.Index);
		}

		public void Write(float[] vector)
		{
			Constants.ENSURE(vector.Length <= 65535, "Vector length must fit into UInt16");
			Write((ushort)vector.Length);
			for (int i = 0; i < vector.Length; i++)
			{
				Write(vector[i]);
			}
		}

		public int WriteArray(BsonArray value, bool recalc)
		{
			int bytesCount = value.GetBytesCount(recalc);
			Write(bytesCount);
			for (int i = 0; i < value.Count; i++)
			{
				WriteElement(i.ToString(), value[i]);
			}
			Write((byte)0);
			return bytesCount;
		}

		public int WriteDocument(BsonDocument value, bool recalc)
		{
			int bytesCount = value.GetBytesCount(recalc);
			Write(bytesCount);
			foreach (KeyValuePair<string, BsonValue> element in value.GetElements())
			{
				WriteElement(element.Key, element.Value);
			}
			Write((byte)0);
			return bytesCount;
		}

		private void WriteElement(string key, BsonValue value)
		{
			switch (value.Type)
			{
			case BsonType.Double:
				Write((byte)1);
				WriteCString(key);
				Write(value.AsDouble);
				break;
			case BsonType.String:
				Write((byte)2);
				WriteCString(key);
				WriteString(value.AsString, specs: true);
				break;
			case BsonType.Document:
				Write((byte)3);
				WriteCString(key);
				WriteDocument(value.AsDocument, recalc: false);
				break;
			case BsonType.Array:
				Write((byte)4);
				WriteCString(key);
				WriteArray(value.AsArray, recalc: false);
				break;
			case BsonType.Binary:
			{
				Write((byte)5);
				WriteCString(key);
				byte[] asBinary = value.AsBinary;
				Write(asBinary.Length);
				Write((byte)0);
				Write(asBinary, 0, asBinary.Length);
				break;
			}
			case BsonType.Guid:
			{
				Write((byte)5);
				WriteCString(key);
				Guid asGuid = value.AsGuid;
				Write(16);
				Write((byte)4);
				Write(asGuid);
				break;
			}
			case BsonType.ObjectId:
				Write((byte)7);
				WriteCString(key);
				Write(value.AsObjectId);
				break;
			case BsonType.Boolean:
				Write((byte)8);
				WriteCString(key);
				Write(value.AsBoolean ? ((byte)1) : ((byte)0));
				break;
			case BsonType.DateTime:
			{
				Write((byte)9);
				WriteCString(key);
				DateTime asDateTime = value.AsDateTime;
				Write(Convert.ToInt64((((asDateTime == DateTime.MinValue || asDateTime == DateTime.MaxValue) ? asDateTime : asDateTime.ToUniversalTime()) - BsonValue.UnixEpoch).TotalMilliseconds));
				break;
			}
			case BsonType.Null:
				Write((byte)10);
				WriteCString(key);
				break;
			case BsonType.Int32:
				Write((byte)16);
				WriteCString(key);
				Write(value.AsInt32);
				break;
			case BsonType.Int64:
				Write((byte)18);
				WriteCString(key);
				Write(value.AsInt64);
				break;
			case BsonType.Decimal:
				Write((byte)19);
				WriteCString(key);
				Write(value.AsDecimal);
				break;
			case BsonType.MinValue:
				Write(byte.MaxValue);
				WriteCString(key);
				break;
			case BsonType.MaxValue:
				Write((byte)127);
				WriteCString(key);
				break;
			case BsonType.Vector:
				Write((byte)100);
				WriteCString(key);
				Write(value.AsVector);
				break;
			}
		}

		public void Dispose()
		{
			_source?.Dispose();
		}
	}
	internal class FileStreamFactory : IStreamFactory
	{
		private readonly string _filename;

		private readonly string _password;

		private readonly bool _readonly;

		private readonly bool _hidden;

		private readonly bool _useAesStream;

		public string Name => Path.GetFileName(_filename);

		public bool CloseOnDispose => true;

		public FileStreamFactory(string filename, string password, bool readOnly, bool hidden, bool useAesStream = true)
		{
			_filename = filename;
			_password = password;
			_readonly = readOnly;
			_hidden = hidden;
			_useAesStream = useAesStream;
		}

		public Stream GetStream(bool canWrite, bool sequencial)
		{
			bool num = canWrite && !_readonly;
			FileMode mode = (_readonly ? FileMode.Open : FileMode.OpenOrCreate);
			FileAccess access = ((!num) ? FileAccess.Read : FileAccess.ReadWrite);
			FileShare share = (num ? FileShare.Read : FileShare.ReadWrite);
			FileOptions options = (sequencial ? FileOptions.SequentialScan : FileOptions.RandomAccess);
			bool num2 = num && !Exists();
			FileStream fileStream = new FileStream(_filename, mode, access, share, 8192, options);
			if (num2 && _hidden)
			{
				File.SetAttributes(_filename, FileAttributes.Hidden);
			}
			if (_password != null && _useAesStream)
			{
				return new AesStream(_password, fileStream);
			}
			return fileStream;
		}

		public long GetLength()
		{
			if (!Exists())
			{
				return 0L;
			}
			long num = new FileInfo(_filename).Length;
			if (num % 8192 != 0L)
			{
				num -= num % 8192;
				using FileStream fileStream = new FileStream(_filename, FileMode.Open, FileAccess.Write, FileShare.None, 8192, FileOptions.SequentialScan);
				fileStream.SetLength(num);
				fileStream.FlushToDisk();
			}
			if (num <= 0)
			{
				return 0L;
			}
			return num - ((_password != null) ? 8192 : 0);
		}

		public bool Exists()
		{
			return File.Exists(_filename);
		}

		public void Delete()
		{
			File.Delete(_filename);
		}

		public bool IsLocked()
		{
			if (Exists())
			{
				return FileHelper.IsFileLocked(_filename);
			}
			return false;
		}
	}
	internal interface IStreamFactory
	{
		string Name { get; }

		bool CloseOnDispose { get; }

		Stream GetStream(bool canWrite, bool sequencial);

		long GetLength();

		bool Exists();

		void Delete();

		bool IsLocked();
	}
	internal class StreamFactory : IStreamFactory
	{
		private readonly Stream _stream;

		private readonly string _password;

		public string Name
		{
			get
			{
				if (!(_stream is MemoryStream))
				{
					if (!(_stream is TempStream))
					{
						return ":stream:";
					}
					return ":temp:";
				}
				return ":memory:";
			}
		}

		public bool CloseOnDispose => false;

		public StreamFactory(Stream stream, string password)
		{
			_stream = stream;
			_password = password;
		}

		public Stream GetStream(bool canWrite, bool sequencial)
		{
			if (_password == null)
			{
				return new ConcurrentStream(_stream, canWrite);
			}
			return new AesStream(_password, new ConcurrentStream(_stream, canWrite));
		}

		public long GetLength()
		{
			long num = _stream.Length;
			if (num % 8192 != 0L)
			{
				num -= num % 8192;
				_stream.SetLength(num);
				_stream.FlushToDisk();
			}
			if (num <= 0)
			{
				return 0L;
			}
			return num - ((_password != null) ? 8192 : 0);
		}

		public bool Exists()
		{
			return _stream.Length > 0;
		}

		public void Delete()
		{
		}

		public bool IsLocked()
		{
			return false;
		}
	}
	internal class StreamPool : IDisposable
	{
		private readonly ConcurrentBag<Stream> _pool = new ConcurrentBag<Stream>();

		private readonly Lazy<Stream> _writer;

		private readonly IStreamFactory _factory;

		public Lazy<Stream> Writer => _writer;

		public StreamPool(IStreamFactory factory, bool appendOnly)
		{
			StreamPool streamPool = this;
			_factory = factory;
			_writer = new Lazy<Stream>(() => streamPool._factory.GetStream(canWrite: true, appendOnly), isThreadSafe: true);
		}

		public Stream Rent()
		{
			if (!_pool.TryTake(out var result))
			{
				return _factory.GetStream(canWrite: false, sequencial: false);
			}
			return result;
		}

		public void Return(Stream stream)
		{
			_pool.Add(stream);
		}

		public void Dispose()
		{
			if (!_factory.CloseOnDispose)
			{
				return;
			}
			foreach (Stream item in _pool)
			{
				item.Dispose();
			}
			if (_writer.IsValueCreated)
			{
				_writer.Value.Dispose();
			}
		}
	}
	internal class AesStream : Stream
	{
		private readonly Aes _aes;

		private readonly ICryptoTransform _encryptor;

		private readonly ICryptoTransform _decryptor;

		private readonly string _name;

		private readonly Stream _stream;

		private readonly CryptoStream _reader;

		private readonly CryptoStream _writer;

		private readonly byte[] _decryptedZeroes = new byte[16];

		private static readonly byte[] _emptyContent = new byte[8175];

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		public byte[] Salt { get; }

		public override bool CanRead => _stream.CanRead;

		public override bool CanSeek => _stream.CanSeek;

		public override bool CanWrite => _stream.CanWrite;

		public override long Length => _stream.Length - 8192;

		public override long Position
		{
			get
			{
				return _stream.Position - 8192;
			}
			set
			{
				Seek(value, SeekOrigin.Begin);
			}
		}

		public long StreamPosition => _stream.Position;

		public AesStream(string password, Stream stream)
		{
			_stream = stream;
			_name = ((_stream is FileStream fileStream) ? Path.GetFileName(fileStream.Name) : null);
			bool flag = _stream.Length < 8192;
			_stream.Position = 0L;
			byte[] array = _bufferPool.Rent(32);
			byte[] array2 = _bufferPool.Rent(16);
			try
			{
				if (flag)
				{
					Salt = NewSalt();
					_stream.WriteByte(1);
					_stream.Write(Salt, 0, 16);
				}
				else
				{
					Salt = new byte[16];
					if (_stream.ReadByte() != 1)
					{
						throw LiteException.FileNotEncrypted();
					}
					_stream.Read(Salt, 0, 16);
				}
				_aes = Aes.Create();
				_aes.Padding = PaddingMode.None;
				_aes.Mode = CipherMode.ECB;
				Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, Salt);
				using (rfc2898DeriveBytes)
				{
					_aes.Key = rfc2898DeriveBytes.GetBytes(32);
					_aes.IV = rfc2898DeriveBytes.GetBytes(16);
				}
				_encryptor = _aes.CreateEncryptor();
				_decryptor = _aes.CreateDecryptor();
				_reader = (_stream.CanRead ? new CryptoStream(_stream, _decryptor, CryptoStreamMode.Read) : null);
				_writer = (_stream.CanWrite ? new CryptoStream(_stream, _encryptor, CryptoStreamMode.Write) : null);
				_stream.Position = 32L;
				if (!flag)
				{
					_stream.Read(array, 0, 32);
					flag = array.All((byte x) => x == 0);
					Array.Clear(array, 0, 32);
					_stream.Position = 32L;
				}
				if (flag)
				{
					array.Fill(1, 0, 32);
					_writer.Write(array, 0, 32);
					_stream.Position = 8191L;
					_stream.WriteByte(0);
				}
				else
				{
					_reader.Read(array, 0, 32);
					if (!array.All((byte x) => x == 1))
					{
						throw LiteException.InvalidPassword();
					}
				}
				_stream.Position = 8192L;
				_stream.FlushToDisk();
				using MemoryStream stream2 = new MemoryStream(array2);
				using CryptoStream cryptoStream = new CryptoStream(stream2, _decryptor, CryptoStreamMode.Read);
				cryptoStream.Read(_decryptedZeroes, 0, _decryptedZeroes.Length);
			}
			catch
			{
				_stream.Dispose();
				throw;
			}
			finally
			{
				_bufferPool.Return(array2, clearArray: true);
				_bufferPool.Return(array, clearArray: true);
			}
		}

		public override int Read(byte[] array, int offset, int count)
		{
			Constants.ENSURE(Position % 8192 == 0, "AesRead: position must be in PAGE_SIZE module. Position={0}, File={1}", Position, _name);
			int result = _reader.Read(array, offset, count);
			if (IsBlank(array, offset))
			{
				array.Fill(0, offset, count);
			}
			return result;
		}

		public override void Write(byte[] array, int offset, int count)
		{
			Constants.ENSURE(count == 8192 || count == 1, "buffer size must be PAGE_SIZE");
			Constants.ENSURE(Position == 191 || Position % 8192 == 0, "AesWrite: position must be in PAGE_SIZE module. Position={0}, File={1}", Position, _name);
			_writer.Write(array, offset, count);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			_stream?.Dispose();
			_encryptor.Dispose();
			_decryptor.Dispose();
			_aes.Dispose();
		}

		public static byte[] NewSalt()
		{
			byte[] array = new byte[16];
			using RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
			randomNumberGenerator.GetBytes(array);
			return array;
		}

		public override void Flush()
		{
			_stream.Flush();
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			return _stream.Seek(offset + 8192, origin);
		}

		public override void SetLength(long value)
		{
			_stream.SetLength(value + 8192);
		}

		private unsafe bool IsBlank(byte[] array, int offset)
		{
			fixed (byte* ptr3 = array)
			{
				fixed (byte* ptr = _decryptedZeroes)
				{
					void* ptr2 = ptr;
					ulong* ptr4 = (ulong*)(ptr3 + offset);
					ulong* ptr5 = (ulong*)ptr2;
					if (*ptr4 == *ptr5)
					{
						return ptr4[1] == ptr5[1];
					}
					return false;
				}
			}
		}
	}
	internal class ConcurrentStream : Stream
	{
		private readonly Stream _stream;

		private readonly bool _canWrite;

		private long _position;

		public override bool CanRead => _stream.CanRead;

		public override bool CanSeek => _stream.CanSeek;

		public override bool CanWrite => _canWrite;

		public override long Length => _stream.Length;

		public override long Position
		{
			get
			{
				return _position;
			}
			set
			{
				_position = value;
			}
		}

		public ConcurrentStream(Stream stream, bool canWrite)
		{
			_stream = stream;
			_canWrite = canWrite;
		}

		public override void Flush()
		{
			_stream.Flush();
		}

		public override void SetLength(long value)
		{
			_stream.SetLength(value);
		}

		protected override void Dispose(bool disposing)
		{
			_stream.Dispose();
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			lock (_stream)
			{
				_position = origin switch
				{
					SeekOrigin.Current => _position + offset, 
					SeekOrigin.Begin => offset, 
					_ => _position - offset, 
				};
				return _position;
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			lock (_stream)
			{
				_stream.Position = _position;
				int result = _stream.Read(buffer, offset, count);
				_position = _stream.Position;
				return result;
			}
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			if (!_canWrite)
			{
				throw new NotSupportedException("Current stream are readonly");
			}
			lock (_stream)
			{
				_stream.Position = _position;
				_stream.Write(buffer, offset, count);
				_position = _stream.Position;
			}
		}
	}
	internal class TempStream : Stream
	{
		private Stream _stream = new MemoryStream();

		private string _filename;

		private readonly long _maxMemoryUsage;

		public bool InMemory => _stream is MemoryStream;

		public bool InDisk => _stream is FileStream;

		public string Filename => _filename;

		public override bool CanRead => _stream.CanRead;

		public override bool CanSeek => _stream.CanWrite;

		public override bool CanWrite => _stream.CanWrite;

		public override long Length => _stream.Length;

		public override long Position
		{
			get
			{
				return _stream.Position;
			}
			set
			{
				Seek(value, SeekOrigin.Begin);
			}
		}

		public TempStream(string filename = null, long maxMemoryUsage = 10485760L)
		{
			_maxMemoryUsage = maxMemoryUsage;
			_filename = filename;
		}

		public override void Flush()
		{
			_stream.Flush();
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return _stream.Read(buffer, offset, count);
		}

		public override void SetLength(long value)
		{
			_stream.SetLength(value);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			_stream.Write(buffer, offset, count);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			if (origin switch
			{
				SeekOrigin.Current => _stream.Position + offset, 
				SeekOrigin.Begin => offset, 
				_ => _stream.Position - offset, 
			} > _maxMemoryUsage && InMemory)
			{
				_filename = _filename ?? Path.Combine(Path.GetTempPath(), "litedb_" + Guid.NewGuid().ToString() + ".db");
				FileStream fileStream = new FileStream(_filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None, 8192, FileOptions.RandomAccess);
				_stream.Position = 0L;
				_stream.CopyTo(fileStream);
				_stream.Dispose();
				_stream = fileStream;
			}
			return _stream.Seek(offset, origin);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			_stream.Dispose();
			if (InDisk)
			{
				File.Delete(_filename);
			}
		}
	}
	internal class LiteEngine : ILiteEngine, IDisposable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_0
		{
			public BsonExpression predicate;

			public LiteEngine <>4__this;

			public string collection;

			public BsonExpression transform;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass4_0
		{
			public BsonExpression predicate;

			public LiteEngine <>4__this;

			public string collection;
		}

		[CompilerGenerated]
		private sealed class <SysCols>d__55 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

			private IEnumerator<KeyValuePair<string, uint>> <>7__wrap1;

			private Dictionary<string, SystemCollection>.Enumerator <>7__wrap2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteEngine liteEngine = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = liteEngine._header.GetCollections().GetEnumerator();
						<>1__state = -3;
						goto IL_00a7;
					case 1:
						<>1__state = -3;
						goto IL_00a7;
					case 2:
						{
							<>1__state = -4;
							break;
						}
						IL_00a7:
						if (<>7__wrap1.MoveNext())
						{
							KeyValuePair<string, uint> current = <>7__wrap1.Current;
							<>2__current = new BsonDocument
							{
								["name"] = current.Key,
								["type"] = "user"
							};
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						<>7__wrap2 = liteEngine._systemCollections.GetEnumerator();
						<>1__state = -4;
						break;
					}
					if (<>7__wrap2.MoveNext())
					{
						KeyValuePair<string, SystemCollection> current2 = <>7__wrap2.Current;
						<>2__current = new BsonDocument
						{
							["name"] = current2.Key,
							["type"] = "system"
						};
						<>1__state = 2;
						return true;
					}
					<>m__Finally2();
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysCols>d__55 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysCols>d__55(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <SysDatabase>d__56 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				LiteEngine liteEngine = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					System.Version version = typeof(LiteEngine).GetTypeInfo().Assembly.GetName().Version;
					<>2__current = new BsonDocument
					{
						["name"] = liteEngine._disk.GetName(FileOrigin.Data),
						["encrypted"] = liteEngine._settings.Password != null,
						["readOnly"] = liteEngine._settings.ReadOnly,
						["lastPageID"] = (int)liteEngine._header.LastPageID,
						["freeEmptyPageID"] = (int)liteEngine._header.FreeEmptyPageList,
						["creationTime"] = liteEngine._header.CreationTime,
						["dataFileSize"] = (int)liteEngine._disk.GetFileLength(FileOrigin.Data),
						["logFileSize"] = (int)liteEngine._disk.GetFileLength(FileOrigin.Log),
						["currentReadVersion"] = liteEngine._walIndex.CurrentReadVersion,
						["lastTransactionID"] = liteEngine._walIndex.LastTransactionID,
						["engine"] = $"litedb-ce-v{version.Major}.{version.Minor}.{version.Build}",
						["pragmas"] = new BsonDocument(liteEngine._header.Pragmas.Pragmas.ToDictionary((Pragma x) => x.Name, (Pragma x) => x.Get())),
						["cache"] = new BsonDocument
						{
							["extendSegments"] = liteEngine._disk.Cache.ExtendSegments,
							["extendPages"] = liteEngine._disk.Cache.ExtendPages,
							["freePages"] = liteEngine._disk.Cache.FreePages,
							["readablePages"] = liteEngine._disk.Cache.GetPages().Count,
							["writablePages"] = liteEngine._disk.Cache.WritablePages,
							["pagesInUse"] = liteEngine._disk.Cache.PagesInUse
						},
						["transactions"] = new BsonDocument
						{
							["open"] = liteEngine._monitor.Transactions.Count,
							["maxOpenTransactions"] = 100,
							["initialTransactionSize"] = liteEngine._monitor.InitialSize,
							["availableSize"] = liteEngine._monitor.FreePages
						}
					};
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					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]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysDatabase>d__56 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysDatabase>d__56(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <SysIndexes>d__57 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

			private TransactionService <transaction>5__2;

			private IEnumerator<KeyValuePair<string, uint>> <>7__wrap2;

			private KeyValuePair<string, uint> <collection>5__4;

			private IEnumerator<CollectionIndex> <>7__wrap4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<transaction>5__2 = null;
				<>7__wrap2 = null;
				<>7__wrap4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteEngine liteEngine = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_0132;
					}
					<>1__state = -1;
					<transaction>5__2 = liteEngine._monitor.GetThreadTransaction();
					<>7__wrap2 = liteEngine._header.GetCollections().GetEnumerator();
					<>1__state = -3;
					goto IL_014f;
					IL_0132:
					if (<>7__wrap4.MoveNext())
					{
						CollectionIndex current = <>7__wrap4.Current;
						<>2__current = new BsonDocument
						{
							["collection"] = <collection>5__4.Key,
							["name"] = current.Name,
							["expression"] = current.Expression,
							["unique"] = current.Unique
						};
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>7__wrap4 = null;
					goto IL_014f;
					IL_014f:
					if (<>7__wrap2.MoveNext())
					{
						<collection>5__4 = <>7__wrap2.Current;
						Snapshot snapshot = <transaction>5__2.CreateSnapshot(LockMode.Read, <collection>5__4.Key, addIfNotExists: false);
						<>7__wrap4 = snapshot.CollectionPage.GetCollectionIndexes().GetEnumerator();
						<>1__state = -4;
						goto IL_0132;
					}
					<>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();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<>7__wrap4 != null)
				{
					<>7__wrap4.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysIndexes>d__57 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysIndexes>d__57(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <SysOpenCursors>d__58 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

			private IEnumerator<TransactionService> <>7__wrap1;

			private TransactionService <transaction>5__3;

			private List<CursorInfo>.Enumerator <>7__wrap3;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteEngine liteEngine = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_0199;
					}
					<>1__state = -1;
					<>7__wrap1 = liteEngine._monitor.Transactions.GetEnumerator();
					<>1__state = -3;
					goto IL_01b6;
					IL_0199:
					if (<>7__wrap3.MoveNext())
					{
						CursorInfo current = <>7__wrap3.Current;
						<>2__current = new BsonDocument
						{
							["threadID"] = <transaction>5__3.ThreadID,
							["transactionID"] = (int)<transaction>5__3.TransactionID,
							["elapsedMS"] = (int)current.Elapsed.ElapsedMilliseconds,
							["collection"] = current.Collection,
							["mode"] = (current.Query.ForUpdate ? "write" : "read"),
							["sql"] = current.Query.ToSQL(current.Collection).Replace(Environment.NewLine, " "),
							["running"] = current.Elapsed.IsRunning,
							["fetched"] = current.Fetched
						};
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<transaction>5__3 = null;
					goto IL_01b6;
					IL_01b6:
					if (<>7__wrap1.MoveNext())
					{
						<transaction>5__3 = <>7__wrap1.Current;
						<>7__wrap3 = <transaction>5__3.OpenCursors.GetEnumerator();
						<>1__state = -4;
						goto IL_0199;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				((IDisposable)<>7__wrap3).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysOpenCursors>d__58 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysOpenCursors>d__58(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <SysSequences>d__59 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

			private KeyValuePair<string, long>[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				LiteEngine liteEngine = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					KeyValuePair<string, long>[] array = liteEngine._sequences.ToArray();
					<>7__wrap1 = array;
					<>7__wrap2 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					<>7__wrap2++;
					break;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					KeyValuePair<string, long> keyValuePair = <>7__wrap1[<>7__wrap2];
					<>2__current = new BsonDocument
					{
						["collection"] = keyValuePair.Key,
						["value"] = keyValuePair.Value
					};
					<>1__state = 1;
					return true;
				}
				<>7__wrap1 = null;
				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]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysSequences>d__59 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysSequences>d__59(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <SysSnapshots>d__60 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

			private IEnumerator<TransactionService> <>7__wrap1;

			private TransactionService <transaction>5__3;

			private IEnumerator<Snapshot> <>7__wrap3;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteEngine liteEngine = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_0150;
					}
					<>1__state = -1;
					<>7__wrap1 = liteEngine._monitor.Transactions.GetEnumerator();
					<>1__state = -3;
					goto IL_0174;
					IL_0150:
					if (<>7__wrap3.MoveNext())
					{
						Snapshot current = <>7__wrap3.Current;
						<>2__current = new BsonDocument
						{
							["transactionID"] = (int)<transaction>5__3.TransactionID,
							["collection"] = current.CollectionName,
							["mode"] = current.Mode.ToString(),
							["readVersion"] = current.ReadVersion,
							["pagesInMemory"] = current.LocalPages.Count,
							["collectionDirty"] = current.CollectionPage?.IsDirty ?? false
						};
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>7__wrap3 = null;
					<transaction>5__3 = null;
					goto IL_0174;
					IL_0174:
					if (<>7__wrap1.MoveNext())
					{
						<transaction>5__3 = <>7__wrap1.Current;
						<>7__wrap3 = <transaction>5__3.Snapshots.GetEnumerator();
						<>1__state = -4;
						goto IL_0150;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysSnapshots>d__60 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysSnapshots>d__60(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <SysTransactions>d__61 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public LiteEngine <>4__this;

			private IEnumerator<TransactionService> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <SysTransactions>d__61(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					LiteEngine liteEngine = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = liteEngine._monitor.Transactions.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						TransactionService current = <>7__wrap1.Current;
						<>2__current = new BsonDocument
						{
							["threadID"] = current.ThreadID,
							["transactionID"] = (int)current.TransactionID,
							["startTime"] = current.StartTime,
							["mode"] = current.Mode.ToString(),
							["transactionSize"] = current.Pages.TransactionSize,
							["maxTransactionSize"] = current.MaxTransactionSize,
							["pagesInLogFile"] = current.Pages.DirtyPages.Count,
							["newPages"] = current.Pages.NewPages.Count,
							["deletedPages"] = current.Pages.DeletedPages,
							["modifiedPages"] = current.Snapshots.Select((Snapshot x) => x.GetWritablePages(dirty: true, includeCollectionPage: true).Count()).Sum()
						};
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SysTransactions>d__61 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SysTransactions>d__61(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		private LockService _locker;

		private DiskService _disk;

		private WalIndexService _walIndex;

		private HeaderPage _header;

		private TransactionMonitor _monitor;

		private SortDisk _sortDisk;

		private EngineState _state;

		private readonly EngineSettings _settings;

		private Dictionary<string, SystemCollection> _systemCollections;

		private ConcurrentDictionary<string, long> _sequences;

		public IEnumerable<string> GetCollectionNames()
		{
			return from x in _header.GetCollections()
				select x.Key;
		}

		public bool DropCollection(string name)
		{
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			if (_locker.IsInTransaction)
			{
				throw LiteException.AlreadyExistsTransaction();
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, name, addIfNotExists: false);
				if (snapshot.CollectionPage == null)
				{
					return false;
				}
				snapshot.DropCollection(transaction.Safepoint);
				_sequences.TryRemove(name, out var _);
				return true;
			});
		}

		public bool RenameCollection(string collection, string newName)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (newName.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("newName");
			}
			if (_locker.IsInTransaction)
			{
				throw LiteException.AlreadyExistsTransaction();
			}
			if (collection.Equals(newName, StringComparison.OrdinalIgnoreCase))
			{
				throw LiteException.InvalidCollectionName(newName, "New name must be different from current name");
			}
			CollectionService.CheckName(newName, _header);
			if (_locker.IsInTransaction)
			{
				throw LiteException.AlreadyExistsTransaction();
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: false);
				transaction.CreateSnapshot(LockMode.Write, newName, addIfNotExists: false);
				if (snapshot.CollectionPage == null)
				{
					return false;
				}
				if (_header.GetCollectionPageID(newName) != uint.MaxValue)
				{
					throw LiteException.AlreadyExistsCollectionName(newName);
				}
				transaction.Pages.Commit += delegate(HeaderPage h)
				{
					h.RenameCollection(collection, newName);
				};
				return true;
			});
		}

		public int Delete(string collection, IEnumerable<BsonValue> ids)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (ids == null)
			{
				throw new ArgumentNullException("ids");
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: false);
				CollectionPage collectionPage = snapshot.CollectionPage;
				DataService dataService = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
				IndexService indexService = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				VectorIndexService vectorIndexService = new VectorIndexService(snapshot, _header.Pragmas.Collation);
				if (collectionPage == null)
				{
					return 0;
				}
				int num = 0;
				CollectionIndex pK = collectionPage.PK;
				foreach (BsonValue id in ids)
				{
					IndexNode indexNode = indexService.Find(pK, id, sibling: false, 1);
					if (indexNode != null)
					{
						_state.Validate();
						foreach (var vectorIndex in collectionPage.GetVectorIndexes())
						{
							VectorIndexMetadata item = vectorIndex.Metadata;
							vectorIndexService.Delete(item, indexNode.DataBlock);
						}
						dataService.Delete(indexNode.DataBlock);
						indexService.DeleteAll(indexNode.Position);
						transaction.Safepoint();
						num++;
					}
				}
				return num;
			});
		}

		public int DeleteMany(string collection, BsonExpression predicate)
		{
			<>c__DisplayClass4_0 CS$<>8__locals0 = new <>c__DisplayClass4_0();
			CS$<>8__locals0.predicate = predicate;
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.collection = collection;
			if (CS$<>8__locals0.collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (CS$<>8__locals0.predicate != null && CS$<>8__locals0.predicate.Type == BsonExpressionType.Equal && CS$<>8__locals0.predicate.Left.Type == BsonExpressionType.Path && CS$<>8__locals0.predicate.Left.Source == "$._id" && CS$<>8__locals0.predicate.Right.IsValue)
			{
				BsonValue bsonValue = CS$<>8__locals0.predicate.Right.Execute(_header.Pragmas.Collation).First();
				return Delete(CS$<>8__locals0.collection, new BsonValue[1] { bsonValue });
			}
			return Delete(CS$<>8__locals0.collection, getIds());
			[IteratorStateMachine(typeof(<>c__DisplayClass4_0.<<DeleteMany>g__getIds|0>d))]
			IEnumerable<BsonValue> getIds()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass4_0.<<DeleteMany>g__getIds|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		public bool EnsureIndex(string collection, string name, BsonExpression expression, bool unique)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			if (!expression.IsIndexable)
			{
				throw new ArgumentException("Index expressions must contains at least one document field. Used methods must be immutable. Parameters are not supported.", "expression");
			}
			if (name.Length > Constants.INDEX_NAME_MAX_LENGTH)
			{
				throw LiteException.InvalidIndexName(name, collection, "MaxLength = " + Constants.INDEX_NAME_MAX_LENGTH);
			}
			if (!name.IsWord())
			{
				throw LiteException.InvalidIndexName(name, collection, "Use only [a-Z$_]");
			}
			if (name.StartsWith("$"))
			{
				throw LiteException.InvalidIndexName(name, collection, "Index name can't start with `$`");
			}
			if (!expression.IsScalar && unique)
			{
				throw new LiteException(0, "Multikey index expression do not support unique option");
			}
			if (expression.Source == "$._id")
			{
				return false;
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: true);
				CollectionPage collectionPage = snapshot.CollectionPage;
				IndexService indexService = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				DataService dataService = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
				CollectionIndex collectionIndex = collectionPage.GetCollectionIndex(name);
				if (collectionIndex != null)
				{
					if (collectionIndex.Expression != expression.Source)
					{
						throw LiteException.IndexAlreadyExist(name);
					}
					return false;
				}
				CollectionIndex index = indexService.CreateIndex(name, expression.Source, unique);
				uint num = 0u;
				foreach (IndexNode item in new IndexAll("_id", 1).Run(collectionPage, indexService))
				{
					using (BufferReader bufferReader = new BufferReader(dataService.Read(item.DataBlock)))
					{
						BsonDocument value = bufferReader.ReadDocument(expression.Fields).GetValue();
						IndexNode indexNode = null;
						IndexNode indexNode2 = null;
						foreach (BsonValue indexKey in expression.GetIndexKeys(value, _header.Pragmas.Collation))
						{
							_state.Validate();
							IndexNode indexNode3 = indexService.AddNode(index, indexKey, item.DataBlock, indexNode);
							if (indexNode2 == null)
							{
								indexNode2 = indexNode3;
							}
							indexNode = indexNode3;
							num++;
						}
						if (indexNode2 != null)
						{
							indexNode.SetNextNode(item.NextNode);
							item.SetNextNode(indexNode2.Position);
						}
					}
					transaction.Safepoint();
				}
				return true;
			});
		}

		public bool EnsureVectorIndex(string collection, string name, BsonExpression expression, VectorIndexOptions options)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			if (expression.Fields.Count == 0)
			{
				throw new ArgumentException("Vector index expressions must reference a document field.", "expression");
			}
			if (name.Length > Constants.INDEX_NAME_MAX_LENGTH)
			{
				throw LiteException.InvalidIndexName(name, collection, "MaxLength = " + Constants.INDEX_NAME_MAX_LENGTH);
			}
			if (!name.IsWord())
			{
				throw LiteException.InvalidIndexName(name, collection, "Use only [a-Z$_]");
			}
			if (name.StartsWith("$"))
			{
				throw LiteException.InvalidIndexName(name, collection, "Index name can't start with `$`");
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: true);
				CollectionPage collectionPage = snapshot.CollectionPage;
				IndexService indexer = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				DataService dataService = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
				VectorIndexService vectorIndexService = new VectorIndexService(snapshot, _header.Pragmas.Collation);
				CollectionIndex collectionIndex = collectionPage.GetCollectionIndex(name);
				VectorIndexMetadata vectorIndexMetadata = collectionPage.GetVectorIndexMetadata(name);
				if (collectionIndex != null && collectionIndex.IndexType != 1)
				{
					throw LiteException.IndexAlreadyExist(name);
				}
				if (collectionIndex != null && vectorIndexMetadata != null)
				{
					if (collectionIndex.Expression != expression.Source)
					{
						throw LiteException.IndexAlreadyExist(name);
					}
					if (vectorIndexMetadata.Dimensions != options.Dimensions || vectorIndexMetadata.Metric != options.Metric)
					{
						throw new LiteException(0, "Vector index '" + name + "' already exists with different options.");
					}
					return false;
				}
				(CollectionIndex, VectorIndexMetadata) tuple = collectionPage.InsertVectorIndex(name, expression.Source, options.Dimensions, options.Metric);
				foreach (IndexNode item in new IndexAll("_id", 1).Run(collectionPage, indexer))
				{
					_state.Validate();
					using (BufferReader bufferReader = new BufferReader(dataService.Read(item.DataBlock)))
					{
						BsonDocument value = bufferReader.ReadDocument(expression.Fields).GetValue();
						vectorIndexService.Upsert(tuple.Item1, tuple.Item2, value, item.DataBlock);
					}
					transaction.Safepoint();
				}
				return true;
			});
		}

		public bool DropIndex(string collection, string name)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (name.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("name");
			}
			if (name == "_id")
			{
				throw LiteException.IndexDropId();
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: false);
				CollectionPage collectionPage = snapshot.CollectionPage;
				IndexService indexService = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				if (collectionPage == null)
				{
					return false;
				}
				CollectionIndex collectionIndex = collectionPage.GetCollectionIndex(name);
				if (collectionIndex == null)
				{
					return false;
				}
				if (collectionIndex.IndexType == 1)
				{
					VectorIndexMetadata vectorIndexMetadata = collectionPage.GetVectorIndexMetadata(name);
					if (vectorIndexMetadata != null)
					{
						new VectorIndexService(snapshot, _header.Pragmas.Collation).Drop(vectorIndexMetadata);
					}
					snapshot.CollectionPage.DeleteCollectionIndex(name);
					return true;
				}
				indexService.DropIndex(collectionIndex);
				snapshot.CollectionPage.DeleteCollectionIndex(name);
				return true;
			});
		}

		public int Insert(string collection, IEnumerable<BsonDocument> docs, BsonAutoId autoId)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (docs == null)
			{
				throw new ArgumentNullException("docs");
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: true);
				int num = 0;
				IndexService indexer = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				DataService data = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
				VectorIndexService vectorService = new VectorIndexService(snapshot, _header.Pragmas.Collation);
				foreach (BsonDocument doc in docs)
				{
					_state.Validate();
					transaction.Safepoint();
					InsertDocument(snapshot, doc, autoId, indexer, data, vectorService);
					num++;
				}
				return num;
			});
		}

		private void InsertDocument(Snapshot snapshot, BsonDocument doc, BsonAutoId autoId, IndexService indexer, DataService data, VectorIndexService vectorService)
		{
			if (!doc.TryGetValue("_id", out var value))
			{
				value = (doc["_id"] = autoId switch
				{
					BsonAutoId.Guid => new BsonValue(Guid.NewGuid()), 
					BsonAutoId.ObjectId => new BsonValue(ObjectId.NewObjectId()), 
					_ => GetSequence(snapshot, autoId), 
				});
			}
			else if (value.IsNumber)
			{
				SetSequence(snapshot, value);
			}
			if (value.IsNull || value.IsMinValue || value.IsMaxValue)
			{
				throw LiteException.InvalidDataType("_id", value);
			}
			PageAddress dataBlock = data.Insert(doc);
			IndexNode last = null;
			foreach (CollectionIndex item in from x in snapshot.CollectionPage.GetCollectionIndexes()
				where x.IndexType == 0
				select x)
			{
				foreach (BsonValue indexKey in item.BsonExpr.GetIndexKeys(doc, _header.Pragmas.Collation))
				{
					last = indexer.AddNode(item, indexKey, dataBlock, last);
				}
			}
			foreach (var (index, metadata) in snapshot.CollectionPage.GetVectorIndexes())
			{
				vectorService.Upsert(index, metadata, doc, dataBlock);
			}
		}

		public BsonValue Pragma(string name)
		{
			return _header.Pragmas.Get(name);
		}

		public bool Pragma(string name, BsonValue value)
		{
			if (Pragma(name) == value)
			{
				return false;
			}
			if (_locker.IsInTransaction)
			{
				throw LiteException.AlreadyExistsTransaction();
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				transaction.Pages.Commit += delegate(HeaderPage h)
				{
					h.Pragmas.Set(name, value, validate: true);
				};
				return true;
			});
		}

		public IBsonDataReader Query(string collection, Query query)
		{
			if (string.IsNullOrWhiteSpace(collection))
			{
				throw new ArgumentNullException("collection");
			}
			if (query == null)
			{
				throw new ArgumentNullException("query");
			}
			IEnumerable<BsonDocument> source = null;
			if (collection.StartsWith("$"))
			{
				SqlParser.ParseCollection(new Tokenizer(collection), out var name, out var options);
				SystemCollection systemCollection = GetSystemCollection(name);
				source = systemCollection.Input(options);
				collection = systemCollection.Name;
			}
			return new QueryExecutor(this, _state, _monitor, _sortDisk, _disk, _header.Pragmas, collection, query, source).ExecuteQuery();
		}

		public long Rebuild(RebuildOptions options)
		{
			if (string.IsNullOrEmpty(_settings.Filename))
			{
				return 0L;
			}
			Close();
			long result = new RebuildService(_settings).Rebuild(options);
			Open();
			_state.Disposed = false;
			return result;
		}

		public long Rebuild()
		{
			Collation collation = new Collation(Pragma("COLLATION"));
			string password = _settings.Password;
			return Rebuild(new RebuildOptions
			{
				Password = password,
				Collation = collation
			});
		}

		internal void RebuildContent(IFileReader reader)
		{
			bool isNew;
			TransactionService transaction = _monitor.GetTransaction(create: true, queryOnly: false, out isNew);
			try
			{
				foreach (string collection in reader.GetCollections())
				{
					Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: true);
					IndexService indexer = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
					DataService data = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
					VectorIndexService vectorService = new VectorIndexService(snapshot, _header.Pragmas.Collation);
					foreach (BsonDocument document in reader.GetDocuments(collection))
					{
						transaction.Safepoint();
						InsertDocument(snapshot, document, BsonAutoId.ObjectId, indexer, data, vectorService);
					}
					foreach (IndexInfo index in reader.GetIndexes(collection))
					{
						if (index.IndexType == 1 && index.VectorMetadata != null)
						{
							EnsureVectorIndex(collection, index.Name, BsonExpression.Create(index.Expression), new VectorIndexOptions(index.VectorMetadata.Dimensions, index.VectorMetadata.Metric));
						}
						else
						{
							EnsureIndex(collection, index.Name, BsonExpression.Create(index.Expression), index.Unique);
						}
					}
				}
				transaction.Commit();
				_monitor.ReleaseTransaction(transaction);
			}
			catch (Exception ex)
			{
				Close(ex);
				throw;
			}
		}

		private void Recovery(Collation collation)
		{
			RebuildService rebuildService = new RebuildService(_settings);
			RebuildOptions options = new RebuildOptions
			{
				Collation = collation,
				Password = _settings.Password,
				IncludeErrorReport = true
			};
			rebuildService.Rebuild(options);
		}

		private BsonValue GetSequence(Snapshot snapshot, BsonAutoId autoId)
		{
			long num = _sequences.AddOrUpdate(snapshot.CollectionName, delegate
			{
				BsonValue lastId = GetLastId(snapshot);
				if (lastId.IsMinValue)
				{
					return 1L;
				}
				if (!lastId.IsNumber)
				{
					throw new LiteException(0, $"It's not possible use AutoId={autoId} because '{snapshot.CollectionName}' collection contains not only numbers in _id index ({lastId}).");
				}
				return lastId.AsInt64 + 1;
			}, (string s, long value) => value + 1);
			if (autoId != BsonAutoId.Int32)
			{
				return new BsonValue(num);
			}
			return new BsonValue((int)num);
		}

		private void SetSequence(Snapshot snapshot, BsonValue newId)
		{
			_sequences.AddOrUpdate(snapshot.CollectionName, delegate
			{
				BsonValue lastId = GetLastId(snapshot);
				return lastId.IsNumber ? Math.Max(lastId.AsInt64, newId.AsInt64) : newId.AsInt64;
			}, (string s, long value) => Math.Max(value, newId.AsInt64));
		}

		private BsonValue GetLastId(Snapshot snapshot)
		{
			CollectionIndex pK = snapshot.CollectionPage.PK;
			IndexPage page = snapshot.GetPage<IndexPage>(pK.Tail.PageID);
			PageAddress pageAddress = page.GetIndexNode(pK.Tail.Index).Prev[0];
			if (pageAddress == pK.Head)
			{
				return BsonValue.MinValue;
			}
			return ((pageAddress.PageID == page.PageID) ? page : snapshot.GetPage<IndexPage>(pageAddress.PageID)).GetIndexNode(pageAddress.Index).Key;
		}

		internal SystemCollection GetSystemCollection(string name)
		{
			if (_systemCollections.TryGetValue(name, out var value))
			{
				return value;
			}
			throw new LiteException(0, "System collection '" + name + "' are not registered as system collection");
		}

		internal void RegisterSystemCollection(SystemCollection systemCollection)
		{
			if (systemCollection == null)
			{
				throw new ArgumentNullException("systemCollection");
			}
			_systemCollections[systemCollection.Name] = systemCollection;
		}

		internal void RegisterSystemCollection(string collectionName, Func<IEnumerable<BsonDocument>> factory)
		{
			if (collectionName.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collectionName");
			}
			if (factory == null)
			{
				throw new ArgumentNullException("factory");
			}
			_systemCollections[collectionName] = new SystemCollection(collectionName, factory);
		}

		public bool BeginTrans()
		{
			_state.Validate();
			bool isNew;
			TransactionService transaction = _monitor.GetTransaction(create: true, queryOnly: false, out isNew);
			transaction.ExplicitTransaction = true;
			if (transaction.OpenCursors.Count > 0)
			{
				throw new LiteException(0, "This thread contains an open cursors/query. Close cursors before Begin()");
			}
			return isNew;
		}

		public bool Commit()
		{
			_state.Validate();
			bool isNew;
			TransactionService transaction = _monitor.GetTransaction(create: false, queryOnly: false, out isNew);
			if (transaction != null)
			{
				if (transaction.OpenCursors.Count > 0)
				{
					throw new LiteException(0, "Current transaction contains open cursors. Close cursors before run Commit()");
				}
				if (transaction.State == TransactionState.Active)
				{
					CommitAndReleaseTransaction(transaction);
					return true;
				}
			}
			return false;
		}

		public bool Rollback()
		{
			_state.Validate();
			bool isNew;
			TransactionService transaction = _monitor.GetTransaction(create: false, queryOnly: false, out isNew);
			if (transaction != null && transaction.State == TransactionState.Active)
			{
				transaction.Rollback();
				_monitor.ReleaseTransaction(transaction);
				return true;
			}
			return false;
		}

		private T AutoTransaction<T>(Func<TransactionService, T> fn)
		{
			_state.Validate();
			bool isNew;
			TransactionService transaction = _monitor.GetTransaction(create: true, queryOnly: false, out isNew);
			try
			{
				T result = fn(transaction);
				if (isNew)
				{
					CommitAndReleaseTransaction(transaction);
				}
				return result;
			}
			catch (Exception ex)
			{
				if (_state.Handle(ex))
				{
					transaction.Rollback();
					_monitor.ReleaseTransaction(transaction);
				}
				throw;
			}
		}

		private void CommitAndReleaseTransaction(TransactionService transaction)
		{
			transaction.Commit();
			_monitor.ReleaseTransaction(transaction);
			if (_header.Pragmas.Checkpoint > 0 && _disk.GetFileLength(FileOrigin.Log) >= _header.Pragmas.Checkpoint * 8192)
			{
				_walIndex.TryCheckpoint();
			}
		}

		public int Update(string collection, IEnumerable<BsonDocument> docs)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (docs == null)
			{
				throw new ArgumentNullException("docs");
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: false);
				CollectionPage collectionPage = snapshot.CollectionPage;
				IndexService indexer = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				DataService data = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
				VectorIndexService vectorService = new VectorIndexService(snapshot, _header.Pragmas.Collation);
				int num = 0;
				if (collectionPage == null)
				{
					return 0;
				}
				foreach (BsonDocument doc in docs)
				{
					_state.Validate();
					transaction.Safepoint();
					if (UpdateDocument(snapshot, collectionPage, doc, indexer, data, vectorService))
					{
						num++;
					}
				}
				return num;
			});
		}

		public int UpdateMany(string collection, BsonExpression transform, BsonExpression predicate)
		{
			<>c__DisplayClass29_0 CS$<>8__locals0 = new <>c__DisplayClass29_0();
			CS$<>8__locals0.predicate = predicate;
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.collection = collection;
			CS$<>8__locals0.transform = transform;
			if (CS$<>8__locals0.collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (CS$<>8__locals0.transform == null)
			{
				throw new ArgumentNullException("transform");
			}
			return Update(CS$<>8__locals0.collection, transformDocs());
			[IteratorStateMachine(typeof(<>c__DisplayClass29_0.<<UpdateMany>g__transformDocs|0>d))]
			IEnumerable<BsonDocument> transformDocs()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass29_0.<<UpdateMany>g__transformDocs|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private bool UpdateDocument(Snapshot snapshot, CollectionPage col, BsonDocument doc, IndexService indexer, DataService data, VectorIndexService vectorService)
		{
			BsonValue bsonValue = doc["_id"];
			if (bsonValue.IsNull || bsonValue.IsMinValue || bsonValue.IsMaxValue)
			{
				throw LiteException.InvalidDataType("_id", bsonValue);
			}
			IndexNode indexNode = indexer.Find(col.PK, bsonValue, sibling: false, 1);
			if (indexNode == null)
			{
				return false;
			}
			data.Update(col, indexNode.DataBlock, doc);
			foreach (var (index, metadata) in col.GetVectorIndexes())
			{
				vectorService.Upsert(index, metadata, doc, indexNode.DataBlock);
			}
			Tuple<byte, BsonValue, PageAddress>[] oldKeys = (from x in indexer.GetNodeList(indexNode.NextNode)
				select new Tuple<byte, BsonValue, PageAddress>(x.Slot, x.Key, x.Position)).ToArray();
			List<Tuple<byte, BsonValue, string>> newKeys = new List<Tuple<byte, BsonValue, string>>();
			foreach (CollectionIndex item in from x in col.GetCollectionIndexes()
				where x.Name != "_id" && x.IndexType == 0
				select x)
			{
				foreach (BsonValue indexKey in item.BsonExpr.GetIndexKeys(doc, _header.Pragmas.Collation))
				{
					newKeys.Add(new Tuple<byte, BsonValue, string>(item.Slot, indexKey, item.Name));
				}
			}
			if (oldKeys.Length == 0 && newKeys.Count == 0)
			{
				return true;
			}
			HashSet<PageAddress> hashSet = new HashSet<PageAddress>(from x in oldKeys
				where !newKeys.Any((Tuple<byte, BsonValue, string> n) => n.Item1 == x.Item1 && n.Item2 == x.Item2)
				select x.Item3);
			Tuple<byte, BsonValue, string>[] array = newKeys.Where((Tuple<byte, BsonValue, string> x) => !oldKeys.Any((Tuple<byte, BsonValue, PageAddress> o) => o.Item1 == x.Item1 && o.Item2 == x.Item2)).ToArray();
			if (hashSet.Count == 0 && array.Length == 0)
			{
				return true;
			}
			IndexNode last = indexer.DeleteList(indexNode.Position, hashSet);
			Tuple<byte, BsonValue, string>[] array2 = array;
			foreach (Tuple<byte, BsonValue, string> tuple2 in array2)
			{
				CollectionIndex collectionIndex = col.GetCollectionIndex(tuple2.Item3);
				last = indexer.AddNode(collectionIndex, tuple2.Item2, indexNode.DataBlock, last);
			}
			return true;
		}

		private void TryUpgrade()
		{
			if (!File.Exists(_settings.Filename))
			{
				return;
			}
			byte[] array = _bufferPool.Rent(1024);
			using (FileStream fileStream = new FileStream(_settings.Filename, FileMode.Open, FileAccess.Read, FileShare.Read, 1024))
			{
				fileStream.Position = 0L;
				fileStream.Read(array, 0, 1024);
				if (!FileReaderV7.IsVersion(array))
				{
					return;
				}
			}
			_bufferPool.Return(array, clearArray: true);
			Recovery(_settings.Collation);
		}

		[Obsolete("Upgrade your LiteDB v4 datafiles using Upgrade=true in EngineSettings. You can use upgrade=true in connection string.")]
		public static bool Upgrade(string filename, string password = null, Collation collation = null)
		{
			if (filename.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("filename");
			}
			if (!File.Exists(filename))
			{
				return false;
			}
			using (new LiteEngine(new EngineSettings
			{
				Filename = filename,
				Password = password,
				Collation = collation,
				Upgrade = true
			}))
			{
			}
			return true;
		}

		public int Upsert(string collection, IEnumerable<BsonDocument> docs, BsonAutoId autoId)
		{
			if (collection.IsNullOrWhiteSpace())
			{
				throw new ArgumentNullException("collection");
			}
			if (docs == null)
			{
				throw new ArgumentNullException("docs");
			}
			return AutoTransaction(delegate(TransactionService transaction)
			{
				Snapshot snapshot = transaction.CreateSnapshot(LockMode.Write, collection, addIfNotExists: true);
				CollectionPage collectionPage = snapshot.CollectionPage;
				IndexService indexer = new IndexService(snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
				DataService data = new DataService(snapshot, _disk.MAX_ITEMS_COUNT);
				VectorIndexService vectorService = new VectorIndexService(snapshot, _header.Pragmas.Collation);
				int num = 0;
				foreach (BsonDocument doc in docs)
				{
					_state.Validate();
					transaction.Safepoint();
					if (doc["_id"] == BsonValue.Null || !UpdateDocument(snapshot, collectionPage, doc, indexer, data, vectorService))
					{
						InsertDocument(snapshot, doc, autoId, indexer, data, vectorService);
						num++;
					}
				}
				return num;
			});
		}

		public LiteEngine()
			: this(new EngineSettings
			{
				DataStream = new MemoryStream()
			})
		{
		}

		public LiteEngine(string filename)
			: this(new EngineSettings
			{
				Filename = filename
			})
		{
		}

		public LiteEngine(EngineSettings settings)
		{
			_settings = settings ?? throw new ArgumentNullException("settings");
			Open();
		}

		internal bool Open()
		{
			_systemCollections = new Dictionary<string, SystemCollection>(StringComparer.OrdinalIgnoreCase);
			_sequences = new ConcurrentDictionary<string, long>(StringComparer.OrdinalIgnoreCase);
			try
			{
				_state = new EngineState(this, _settings);
				if (_settings.Upgrade)
				{
					TryUpgrade();
				}
				_disk = new DiskService(_settings, _state, Constants.MEMORY_SEGMENT_SIZES);
				PageBuffer pageBuffer = _disk.ReadFull(FileOrigin.Data).First();
				if (pageBuffer[0] == 1)
				{
					throw new LiteException(0, "This data file is encrypted and needs a password to open");
				}
				_header = new HeaderPage(pageBuffer);
				if (pageBuffer[191] != 0 && _settings.AutoRebuild)
				{
					_disk.Dispose();
					_disk = null;
					Recovery(_header.Pragmas.Collation);
					_disk = new DiskService(_settings, _state, Constants.MEMORY_SEGMENT_SIZES);
					pageBuffer = _disk.ReadFull(FileOrigin.Data).First();
					_header = new HeaderPage(pageBuffer);
				}
				if (_settings.Collation != null && _settings.Collation.ToString() != _header.Pragmas.Collation.ToString())
				{
					throw new LiteException(0, $"Datafile collation '{_header.Pragmas.Collation}' is different from engine settings. Use Rebuild database to change collation.");
				}
				_locker = new LockService(_header.Pragmas);
				_walIndex = new WalIndexService(_disk, _locker);
				if (_disk.GetFileLength(FileOrigin.Log) > 0)
				{
					_walIndex.RestoreIndex(ref _header);
				}
				_sortDisk = new SortDisk(_settings.CreateTempFactory(), 819200, _header.Pragmas);
				_monitor = new TransactionMonitor(_header, _locker, _disk, _walIndex);
				InitializeSystemCollections();
				return true;
			}
			catch (Exception ex)
			{
				Close(ex);
				throw;
			}
		}

		internal List<Exception> Close()
		{
			if (_state.Disposed)
			{
				return new List<Exception>();
			}
			_state.Disposed = true;
			TryCatch tryCatch = new TryCatch();
			tryCatch.Catch(delegate
			{
				_monitor?.Dispose();
			});
			HeaderPage header = _header;
			if (header != null && header.Pragmas.Checkpoint > 0)
			{
				tryCatch.Catch(delegate
				{
					_walIndex?.TryCheckpoint();
				});
			}
			tryCatch.Catch(delegate
			{
				_disk?.Dispose();
			});
			tryCatch.Catch(delegate
			{
				_sortDisk?.Dispose();
			});
			tryCatch.Catch(delegate
			{
				_locker?.Dispose();
			});
			return tryCatch.Exceptions;
		}

		internal List<Exception> Close(Exception ex)
		{
			if (_state.Disposed)
			{
				return new List<Exception>();
			}
			_state.Disposed = true;
			TryCatch tryCatch = new TryCatch(ex);
			tryCatch.Catch(delegate
			{
				_monitor?.Dispose();
			});
			tryCatch.Catch(delegate
			{
				_disk?.Dispose();
			});
			tryCatch.Catch(delegate
			{
				_sortDisk?.Dispose();
			});
			tryCatch.Catch(delegate
			{
				_locker?.Dispose();
			});
			if (tryCatch.InvalidDatafileState)
			{
				tryCatch.Catch(delegate
				{
					_disk.MarkAsInvalidState();
				});
			}
			return tryCatch.Exceptions;
		}

		public int Checkpoint()
		{
			return _walIndex.Checkpoint();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			Close();
		}

		private void InitializeSystemCollections()
		{
			RegisterSystemCollection("$database", () => SysDatabase());
			RegisterSystemCollection("$cols", () => SysCols());
			RegisterSystemCollection("$indexes", () => SysIndexes());
			RegisterSystemCollection("$sequences", () => SysSequences());
			RegisterSystemCollection("$transactions", () => SysTransactions());
			RegisterSystemCollection("$snapshots", () => SysSnapshots());
			RegisterSystemCollection("$open_cursors", () => SysOpenCursors());
			RegisterSystemCollection(new SysFile());
			RegisterSystemCollection(new SysDump(_header, _monitor));
			RegisterSystemCollection(new SysPageList(_header, _monitor));
			RegisterSystemCollection(new SysQuery(this));
		}

		[IteratorStateMachine(typeof(<SysCols>d__55))]
		private IEnumerable<BsonDocument> SysCols()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysCols>d__55(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SysDatabase>d__56))]
		private IEnumerable<BsonDocument> SysDatabase()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysDatabase>d__56(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SysIndexes>d__57))]
		private IEnumerable<BsonDocument> SysIndexes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysIndexes>d__57(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SysOpenCursors>d__58))]
		private IEnumerable<BsonDocument> SysOpenCursors()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysOpenCursors>d__58(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SysSequences>d__59))]
		private IEnumerable<BsonDocument> SysSequences()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysSequences>d__59(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SysSnapshots>d__60))]
		private IEnumerable<BsonDocument> SysSnapshots()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysSnapshots>d__60(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SysTransactions>d__61))]
		private IEnumerable<BsonDocument> SysTransactions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SysTransactions>d__61(-2)
			{
				<>4__this = this
			};
		}
	}
	internal class EnginePragmas
	{
		public const int P_USER_VERSION = 76;

		public const int P_COLLATION_LCID = 80;

		public const int P_COLLATION_SORT = 84;

		public const int P_TIMEOUT = 88;

		public const int P_UTC_DATE = 96;

		public const int P_CHECKPOINT = 97;

		public const int P_LIMIT_SIZE = 101;

		private readonly Dictionary<string, Pragma> _pragmas;

		private bool _isDirty;

		private readonly HeaderPage _headerPage;

		public int UserVersion { get; private set; }

		public Collation Collation { get; private set; } = Collation.Default;


		public TimeSpan Timeout { get; private set; } = TimeSpan.FromMinutes(1.0);


		public long LimitSize { get; private set; } = long.MaxValue;


		public bool UtcDate { get; private set; }

		public int Checkpoint { get; private set; } = 1000;


		public IEnumerable<Pragma> Pragmas => _pragmas.Values;

		public EnginePragmas(HeaderPage headerPage)
		{
			_headerPage = headerPage;
			_pragmas = new Dictionary<string, Pragma>(StringComparer.OrdinalIgnoreCase)
			{
				["USER_VERSION"] = new Pragma
				{
					Name = "USER_VERSION",
					Get = () => UserVersion,
					Set = delegate(BsonValue v)
					{
						UserVersion = v.AsInt32;
					},
					Read = delegate(BufferSlice b)
					{
						UserVersion = b.ReadInt32(76);
					},
					Validate = delegate
					{
					},
					Write = delegate(BufferSlice b)
					{
						b.Write(UserVersion, 76);
					}
				},
				["COLLATION"] = new Pragma
				{
					Name = "COLLATION",
					Get = () => Collation.ToString(),
					Set = delegate(BsonValue v)
					{
						Collation = new Collation(v.AsString);
					},
					Read = delegate(BufferSlice b)
					{
						Collation = new Collation(b.ReadInt32(80), (CompareOptions)b.ReadInt32(84));
					},
					Validate = delegate
					{
						throw new LiteException(0, "Pragma COLLATION is read only. Use Rebuild options.");
					},
					Write = delegate(BufferSlice b)
					{
						b.Write(Collation.LCID, 80);
						b.Write((int)Collation.SortOptions, 84);
					}
				},
				["TIMEOUT"] = new Pragma
				{
					Name = "TIMEOUT",
					Get = () => (int)Timeout.TotalSeconds,
					Set = delegate(BsonValue v)
					{
						Timeout = TimeSpan.FromSeconds(v.AsInt32);
					},
					Read = delegate(BufferSlice b)
					{
						Timeout = TimeSpan.FromSeconds(b.ReadInt32(88));
					},
					Validate = delegate(BsonValue v, HeaderPage h)
					{
						if (v <= 0)
						{
							throw new LiteException(0, "Pragma TIMEOUT must be greater than zero");
						}
					},
					Write = delegate(BufferSlice b)
					{
						b.Write((int)Timeout.TotalSeconds, 88);
					}
				},
				["LIMIT_SIZE"] = new Pragma
				{
					Name = "LIMIT_SIZE",
					Get = () => LimitSize,
					Set = delegate(BsonValue v)
					{
						LimitSize = v.AsInt64;
					},
					Read = delegate(BufferSlice b)
					{
						long num = b.ReadInt64(101);
						LimitSize = ((num == 0L) ? long.MaxValue : num);
					},
					Validate = delegate(BsonValue v, HeaderPage h)
					{
						if (v < 32768)
						{
							throw new LiteException(0, "Pragma LIMIT_SIZE must be at least 4 pages (32768 bytes)");
						}
						if (h != null && v.AsInt64 < (h.LastPageID + 1) * 8192)
						{
							throw new LiteException(0, "Pragma LIMIT_SIZE must be greater or equal to the current file size");
						}
					},
					Write = delegate(BufferSlice b)
					{
						b.Write(LimitSize, 101);
					}
				},
				["UTC_DATE"] = new Pragma
				{
					Name = "UTC_DATE",
					Get = () => UtcDate,
					Set = delegate(BsonValue v)
					{
						UtcDate = v.AsBoolean;
					},
					Read = delegate(BufferSlice b)
					{
						UtcDate = b.ReadBool(96);
					},
					Validate = delegate
					{
					},
					Write = delegate(BufferSlice b)
					{
						b.Write(UtcDate, 96);
					}
				},
				["CHECKPOINT"] = new Pragma
				{
					Name = "CHECKPOINT",
					Get = () => Checkpoint,
					Set = delegate(BsonValue v)
					{
						Checkpoint = v.AsInt32;
					},
					Read = delegate(BufferSlice b)
					{
						Checkpoint = b.ReadInt32(97);
					},
					Validate = delegate(BsonValue v, HeaderPage h)
					{
						if (v < 0)
						{
							throw new LiteException(0, "Pragma CHECKPOINT must be greater or equal to zero");
						}
					},
					Write = delegate(BufferSlice b)
					{
						b.Write(Checkpoint, 97);
					}
				}
			};
			_isDirty = true;
		}

		public EnginePragmas(BufferSlice buffer, HeaderPage headerPage)
			: this(headerPage)
		{
			foreach (Pragma value in _pragmas.Values)
			{
				value.Read(buffer);
			}
			_isDirty = false;
		}

		public void UpdateBuffer(BufferSlice buffer)
		{
			if (!_isDirty)
			{
				return;
			}
			foreach (KeyValuePair<string, Pragma> pragma in _pragmas)
			{
				pragma.Value.Write(buffer);
			}
			_isDirty = false;
		}

		public BsonValue Get(string name)
		{
			if (_pragmas.TryGetValue(name, out var value))
			{
				return value.Get();
			}
			throw new LiteException(0, "Pragma `" + name + "` not exist");
		}

		public void Set(string name, BsonValue value, bool validate)
		{
			if (_pragmas.TryGetValue(name, out var value2))
			{
				if (validate)
				{
					value2.Validate(value, _headerPage);
				}
				value2.Set(value);
				_isDirty = true;
				return;
			}
			throw new LiteException(0, "Pragma `" + name + "` not exist");
		}
	}
	internal class EngineSettings
	{
		public Stream DataStream { get; set; }

		public Stream LogStream { get; set; }

		public Stream TempStream { get; set; }

		public string Filename { get; set; }

		public string Password { get; set; }

		public long InitialSize { get; set; }

		public Collation Collation { get; set; }

		public bool ReadOnly { get; set; }

		public bool AutoRebuild { get; set; }

		public bool Upgrade { get; set; }

		public Func<string, BsonValue, BsonValue> ReadTransform { get; set; }

		public SharedMutexNameStrategy SharedMutexNameStrategy { get; set; }

		internal IStreamFactory CreateDataFactory(bool useAesStream = true)
		{
			if (DataStream != null)
			{
				return new StreamFactory(DataStream, Password);
			}
			if (Filename == ":memory:")
			{
				return new StreamFactory(new MemoryStream(), Password);
			}
			if (Filename == ":temp:")
			{
				return new StreamFactory(new TempStream(null, 10485760L), Password);
			}
			if (!string.IsNullOrEmpty(Filename))
			{
				return new FileStreamFactory(Filename, Password, ReadOnly, hidden: false, useAesStream);
			}
			throw new ArgumentException("EngineSettings must have Filename or DataStream as data source");
		}

		internal IStreamFactory CreateLogFactory()
		{
			if (LogStream != null)
			{
				return new StreamFactory(LogStream, Password);
			}
			if (Filename == ":memory:")
			{
				return new StreamFactory(new MemoryStream(), Password);
			}
			if (Filename == ":temp:")
			{
				return new StreamFactory(new TempStream(null, 10485760L), Password);
			}
			if (!string.IsNullOrEmpty(Filename))
			{
				return new FileStreamFactory(FileHelper.GetLogFile(Filename), Password, ReadOnly, hidden: false);
			}
			return new StreamFactory(new MemoryStream(), Password);
		}

		internal IStreamFactory CreateTempFactory()
		{
			if (TempStream != null)
			{
				return new StreamFactory(TempStream, Password);
			}
			if (Filename == ":memory:")
			{
				return new StreamFactory(new MemoryStream(), Password);
			}
			if (Filename == ":temp:")
			{
				return new StreamFactory(new TempStream(null, 10485760L), Password);
			}
			if (!string.IsNullOrEmpty(Filename))
			{
				return new FileStreamFactory(FileHelper.GetTempFile(Filename), Password, readOnly: false, hidden: true);
			}
			return new StreamFactory(new TempStream(null, 10485760L), Password);
		}
	}
	internal class EngineState
	{
		public bool Disposed;

		private Exception _exception;

		private readonly LiteEngine _engine;

		private readonly EngineSettings _settings;

		public EngineState(LiteEngine engine, EngineSettings settings)
		{
			_engine = engine;
			_settings = settings;
		}

		public void Validate()
		{
			if (Disposed)
			{
				throw _exception ?? LiteException.EngineDisposed();
			}
		}

		public bool Handle(Exception ex)
		{
			if (ex is IOException || (ex is LiteException ex2 && ex2.ErrorCode == 999))
			{
				_exception = ex;
				_engine?.Close(ex);
				return false;
			}
			return true;
		}

		public BsonValue ReadTransform(string collection, BsonValue value)
		{
			if (_settings?.ReadTransform == null)
			{
				return value;
			}
			return _settings.ReadTransform(collection, value);
		}
	}
	internal class FileReaderError
	{
		public DateTime Created { get; } = DateTime.Now;


		public FileOrigin Origin { get; set; }

		public long Position { get; set; }

		public uint? PageID { get; set; }

		public PageType PageType { get; set; }

		public string Collection { get; set; }

		public string Message { get; set; }

		public Exception Exception { get; set; }
	}
	internal class FileReaderV7 : IFileReader, IDisposable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public BsonValue dataBlock;

			internal bool <GetDocuments>b__0(BsonValue x)
			{
				return x["index"] == dataBlock["index"];
			}
		}

		[CompilerGenerated]
		private sealed class <GetDocuments>d__14 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public FileReaderV7 <>4__this;

			private string collection;

			public string <>3__collection;

			private HashSet<uint>.Enumerator <>7__wrap1;

			private IEnumerator<BsonValue> <>7__wrap2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					FileReaderV7 fileReaderV = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_0285;
					}
					<>1__state = -1;
					uint asInt = (uint)fileReaderV._header["collections"].AsDocument[collection].AsInt32;
					uint asInt2 = (uint)fileReaderV.ReadPage(asInt)["indexes"][0]["headPageID"].AsInt32;
					HashSet<uint> hashSet = fileReaderV.VisitIndexPages(asInt2);
					<>7__wrap1 = hashSet.GetEnumerator();
					<>1__state = -3;
					goto IL_02a2;
					IL_0285:
					while (<>7__wrap2.MoveNext())
					{
						BsonValue current = <>7__wrap2.Current;
						<>c__DisplayClass14_0 CS$<>8__locals0 = new <>c__DisplayClass14_0
						{
							dataBlock = current["dataBlock"]
						};
						if (CS$<>8__locals0.dataBlock["pageID"].AsInt32 == -1)
						{
							continue;
						}
						BsonDocument bsonDocument = fileReaderV.ReadPage((uint)CS$<>8__locals0.dataBlock["pageID"].AsInt32);
						if (bsonDocument["pageType"].AsInt32 != 4)
						{
							continue;
						}
						BsonDocument bsonDocument2 = bsonDocument["blocks"].AsArray.FirstOrDefault((BsonValue x) => x["index"] == CS$<>8__locals0.dataBlock["index"])?.AsDocument;
						if (bsonDocument2 == null)
						{
							continue;
						}
						byte[] array = ((bsonDocument2["extendPageID"] == -1) ? bsonDocument2["data"].AsBinary : fileReaderV.ReadExtendData((uint)bsonDocument2["extendPageID"].AsInt32));
						if (array.Length == 0)
						{
							continue;
						}
						BsonDocument bsonDocument3 = BsonSerializer.Deserialize(array);
						if (collection == "_chunks")
						{
							string[] array2 = bsonDocument3["_id"].AsString.Split(new char[1] { '\\' });
							if (!int.TryParse(array2[1], out var result))
							{
								throw LiteException.InvalidFormat("_id");
							}
							bsonDocument3["_id"] = new BsonDocument
							{
								["f"] = array2[0],
								["n"] = result
							};
						}
						<>2__current = bsonDocument3;
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>7__wrap2 = null;
					goto IL_02a2;
					IL_02a2:
					if (<>7__wrap1.MoveNext())
					{
						uint current2 = <>7__wrap1.Current;
						BsonDocument bsonDocument4 = fileReaderV.ReadPage(current2);
						<>7__wrap2 = bsonDocument4["nodes"].AsArray.GetEnumerator();
						<>1__state = -4;
						goto IL_0285;
					}
					<>m__Finally1();
					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;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<GetDocuments>d__14 <GetDocuments>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetDocuments>d__ = this;
				}
				else
				{
					<GetDocuments>d__ = new <GetDocuments>d__14(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetDocuments>d__.collection = <>3__collection;
				return <GetDocuments>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetIndexes>d__13 : IEnumerable<IndexInfo>, IEnumerable, IEnumerator<IndexInfo>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexInfo <>2__current;

			private int <>l__initialThreadId;

			public FileReaderV7 <>4__this;

			private string collection;

			public string <>3__collection;

			private IEnumerator<BsonValue> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <GetIndexes>d__13(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					FileReaderV7 fileReaderV = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						uint asInt = (uint)fileReaderV._header["collections"].AsDocument[collection].AsInt32;
						BsonDocument bsonDocument = fileReaderV.ReadPage(asInt);
						<>7__wrap1 = bsonDocument["indexes"].AsArray.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						BsonValue current = <>7__wrap1.Current;
						string text = Regex.Replace(current["name"].AsString, "[^a-z0-9]", "", RegexOptions.IgnoreCase | RegexOptions.Compiled);
						if (text.Length > Constants.INDEX_NAME_MAX_LENGTH)
						{
							text = text.Substring(0, Constants.INDEX_NAME_MAX_LENGTH);
						}
						<>2__current = new IndexInfo
						{
							Collection = collection,
							Name = text,
							Expression = current["expression"].AsString,
							Unique = current["unique"].AsBoolean
						};
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<IndexInfo> IEnumerable<IndexInfo>.GetEnumerator()
			{
				<GetIndexes>d__13 <GetIndexes>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetIndexes>d__ = this;
				}
				else
				{
					<GetIndexes>d__ = new <GetIndexes>d__13(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetIndexes>d__.collection = <>3__collection;
				return <GetIndexes>d__;
			}

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

		private const int V7_PAGE_SIZE = 4096;

		private readonly EngineSettings _settings;

		private Stream _stream;

		private AesEncryption _aes;

		private BsonDocument _header;

		private byte[] _buffer = new byte[4096];

		private bool _disposedValue;

		private static readonly byte[] arrayByteEmpty = new byte[0];

		public IDictionary<string, BsonValue> GetPragmas()
		{
			return new Dictionary<string, BsonValue>
			{
				{
					"USER_VERSION",
					_header["userVersion"].AsInt32
				},
				{ "CHECKPOINT", 1000 },
				{ "TIMEOUT", 60 },
				{
					"LIMIT_SIZE",
					long.MaxValue
				},
				{ "UTC_DATE", true }
			};
		}

		public FileReaderV7(EngineSettings settings)
		{
			_settings = settings;
		}

		public void Open()
		{
			IStreamFactory streamFactory = _settings.CreateDataFactory(useAesStream: false);
			_stream = streamFactory.GetStream(canWrite: true, sequencial: true);
			_header = ReadPage(0u);
			if (_settings.Password == null && !_header["salt"].AsBinary.IsFullZero())
			{
				throw LiteException.InvalidPassword();
			}
			if (_settings.Password != null)
			{
				if (_header["salt"].AsBinary.IsFullZero())
				{
					throw LiteException.FileNotEncrypted();
				}
				if (!((ReadOnlySpan<byte>)AesEncryption.HashSHA1(_settings.Password)).SequenceEqual((ReadOnlySpan<byte>)_header["password"].AsBinary))
				{
					throw LiteException.InvalidPassword();
				}
			}
			_aes = ((_settings.Password == null) ? null : new AesEncryption(_settings.Password, _header["salt"].AsBinary));
		}

		public static bool IsVersion(byte[] buffer)
		{
			string @string = Encoding.UTF8.GetString(buffer, 25, "** This is a LiteDB file **".Length);
			byte b = buffer[52];
			if (@string == "** This is a LiteDB file **")
			{
				return b == 7;
			}
			return false;
		}

		public IEnumerable<string> GetCollections()
		{
			return _header["collections"].AsDocument.Keys;
		}

		[IteratorStateMachine(typeof(<GetIndexes>d__13))]
		public IEnumerable<IndexInfo> GetIndexes(string collection)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetIndexes>d__13(-2)
			{
				<>4__this = this,
				<>3__collection = collection
			};
		}

		[IteratorStateMachine(typeof(<GetDocuments>d__14))]
		public IEnumerable<BsonDocument> GetDocuments(string collection)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetDocuments>d__14(-2)
			{
				<>4__this = this,
				<>3__collection = collection
			};
		}

		private BsonDocument ReadPage(uint pageID)
		{
			if (pageID * 4096 > _stream.Length)
			{
				return null;
			}
			_stream.Position = pageID * 4096;
			_stream.Read(_buffer, 0, 4096);
			if (_aes != null && pageID != 0)
			{
				_buffer = _aes.Decrypt(_buffer);
			}
			ByteReader byteReader = new ByteReader(_buffer);
			BsonDocument bsonDocument = new BsonDocument
			{
				["pageID"] = (int)byteReader.ReadUInt32(),
				["pageType"] = (int)byteReader.ReadByte(),
				["prevPageID"] = (int)byteReader.ReadUInt32(),
				["nextPageID"] = (int)byteReader.ReadUInt32(),
				["itemCount"] = (int)byteReader.ReadUInt16()
			};
			byteReader.ReadBytes(10);
			if (bsonDocument["pageType"] == 1)
			{
				string strA = byteReader.ReadString(27);
				byte b = byteReader.ReadByte();
				if (string.CompareOrdinal(strA, "** This is a LiteDB file **") != 0 || b != 7)
				{
					throw LiteException.InvalidDatabase();
				}
				byteReader.ReadBytes(10);
				bsonDocument["userVersion"] = (int)byteReader.ReadUInt16();
				bsonDocument["password"] = byteReader.ReadBytes(20);
				bsonDocument["salt"] = byteReader.ReadBytes(16);
				bsonDocument["collections"] = new BsonDocument();
				byte b2 = byteReader.ReadByte();
				for (int i = 0; i < b2; i++)
				{
					string name = byteReader.ReadString();
					uint num = byteReader.ReadUInt32();
					bsonDocument["collections"][name] = (int)num;
				}
			}
			else if (bsonDocument["pageType"] == 2)
			{
				bsonDocument["collectionName"] = byteReader.ReadString();
				bsonDocument["indexes"] = new BsonArray();
				byteReader.ReadBytes(12);
				for (int j = 0; j < 16; j++)
				{
					BsonDocument bsonDocument2 = new BsonDocument();
					string text = byteReader.ReadString();
					int num2 = text.IndexOf('=');
					if (num2 > 0)
					{
						bsonDocument2["name"] = text.Substring(0, num2);
						bsonDocument2["expression"] = text.Substring(num2 + 1);
					}
					else
					{
						bsonDocument2["name"] = text;
						bsonDocument2["expression"] = "$." + text;
					}
					bsonDocument2["unique"] = byteReader.ReadBoolean();
					bsonDocument2["headPageID"] = (int)byteReader.ReadUInt32();
					byteReader.ReadBytes(12);
					if (text.Length > 0)
					{
						bsonDocument["indexes"].AsArray.Add(bsonDocument2);
					}
				}
			}
			else if (bsonDocument["pageType"] == 3)
			{
				bsonDocument["nodes"] = new BsonArray();
				for (int k = 0; k < bsonDocument["itemCount"].AsInt32; k++)
				{
					BsonDocument bsonDocument3 = new BsonDocument { ["index"] = (int)byteReader.ReadUInt16() };
					byte b3 = byteReader.ReadByte();
					byteReader.ReadBytes(13);
					ushort num3 = byteReader.ReadUInt16();
					byteReader.ReadBytes(1 + num3);
					bsonDocument3["dataBlock"] = new BsonDocument
					{
						["pageID"] = (int)byteReader.ReadUInt32(),
						["index"] = (int)byteReader.ReadUInt16()
					};
					bsonDocument3["prev"] = new BsonDocument
					{
						["pageID"] = (int)byteReader.ReadUInt32(),
						["index"] = (int)byteReader.ReadUInt16()
					};
					bsonDocument3["next"] = new BsonDocument
					{
						["pageID"] = (int)byteReader.ReadUInt32(),
						["index"] = (int)byteReader.ReadUInt16()
					};
					byteReader.ReadBytes((b3 - 1) * 12);
					bsonDocument["nodes"].AsArray.Add(bsonDocument3);
				}
			}
			else if (bsonDocument["pageType"] == 4)
			{
				bsonDocument["blocks"] = new BsonArray();
				for (int l = 0; l < bsonDocument["itemCount"].AsInt32; l++)
				{
					BsonDocument bsonDocument4 = new BsonDocument
					{
						["index"] = (int)byteReader.ReadUInt16(),
						["extendPageID"] = (int)byteReader.ReadUInt32()
					};
					ushort count = byteReader.ReadUInt16();
					bsonDocument4["data"] = byteReader.ReadBytes(count);
					bsonDocument["blocks"].AsArray.Add(bsonDocument4);
				}
			}
			else if (bsonDocument["pageType"] == 5)
			{
				bsonDocument["data"] = byteReader.ReadBytes(bsonDocument["itemCount"].AsInt32);
			}
			return bsonDocument;
		}

		private byte[] ReadExtendData(uint extendPageID)
		{
			using MemoryStream memoryStream = new MemoryStream();
			while (extendPageID != uint.MaxValue)
			{
				BsonDocument bsonDocument = ReadPage(extendPageID);
				if (bsonDocument["pageType"].AsInt32 != 5)
				{
					return arrayByteEmpty;
				}
				memoryStream.Write(bsonDocument["data"].AsBinary, 0, bsonDocument["itemCount"].AsInt32);
				extendPageID = (uint)bsonDocument["nextPageID"].AsInt32;
			}
			return memoryStream.ToArray();
		}

		private HashSet<uint> VisitIndexPages(uint startPageID)
		{
			HashSet<uint> hashSet = new HashSet<uint> { startPageID };
			HashSet<uint> hashSet2 = new HashSet<uint>();
			while (hashSet.Count > 0)
			{
				uint num = hashSet.First();
				hashSet.Remove(num);
				BsonDocument bsonDocument = ReadPage(num);
				if (bsonDocument == null || bsonDocument["pageType"] != 3)
				{
					continue;
				}
				hashSet2.Add(num);
				foreach (BsonValue item in bsonDocument["nodes"].AsArray)
				{
					uint asInt = (uint)item["prev"]["pageID"].AsInt32;
					uint asInt2 = (uint)item["next"]["pageID"].AsInt32;
					if (!hashSet2.Contains(asInt))
					{
						hashSet.Add(asInt);
					}
					if (!hashSet2.Contains(asInt2))
					{
						hashSet.Add(asInt2);
					}
				}
			}
			return hashSet2;
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposedValue)
			{
				if (disposing)
				{
					_stream?.Dispose();
					_aes?.Dispose();
				}
				_disposedValue = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal class FileReaderV8 : IFileReader, IDisposable
	{
		private struct PageInfo
		{
			public uint PageID;

			public FileOrigin Origin;

			public PageType PageType;

			public long Position;

			public uint ColID;
		}

		[CompilerGenerated]
		private sealed class <GetDocuments>d__17 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public FileReaderV8 <>4__this;

			private string collection;

			public string <>3__collection;

			private uint <colID>5__2;

			private HashSet<BsonValue> <uniqueIDs>5__3;

			private List<uint>.Enumerator <>7__wrap3;

			private PageInfo <pageInfo>5__5;

			private PageBuffer <buffer>5__6;

			private byte <highestIndex>5__7;

			private int <i>5__8;

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

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

			[DebuggerHidden]
			public <GetDocuments>d__17(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();
					}
				}
				<uniqueIDs>5__3 = null;
				<buffer>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					FileReaderV8 fileReaderV = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_04ea;
					}
					<>1__state = -1;
					if (!fileReaderV._collections.ContainsKey(collection))
					{
						return false;
					}
					<colID>5__2 = fileReaderV._collections[collection];
					if (!fileReaderV._collectionsDataPages.ContainsKey(<colID>5__2))
					{
						return false;
					}
					List<uint> list = fileReaderV._collectionsDataPages[<colID>5__2];
					<uniqueIDs>5__3 = new HashSet<BsonValue>();
					<>7__wrap3 = list.GetEnumerator();
					<>1__state = -3;
					goto IL_0514;
					IL_0514:
					while (true)
					{
						if (<>7__wrap3.MoveNext())
						{
							uint current = <>7__wrap3.Current;
							Result<BasePage> result = fileReaderV.ReadPage(current, out <pageInfo>5__5);
							if (result.Fail)
							{
								fileReaderV.HandleError(result.Exception, <pageInfo>5__5);
								continue;
							}
							<buffer>5__6 = result.Value.Buffer;
							byte itemsCount = result.Value.ItemsCount;
							<highestIndex>5__7 = result.Value.HighestIndex;
							if (itemsCount != 0 && <highestIndex>5__7 != byte.MaxValue)
							{
								break;
							}
							continue;
						}
						<>m__Finally1();
						return false;
					}
					<i>5__8 = 0;
					goto IL_04fc;
					IL_04fc:
					BsonDocument bsonDocument;
					if (<i>5__8 <= <highestIndex>5__7)
					{
						try
						{
							int offset = BasePage.CalcPositionAddr((byte)<i>5__8);
							int offset2 = BasePage.CalcLengthAddr((byte)<i>5__8);
							ushort num2 = <buffer>5__6.ReadUInt16(offset);
							ushort num3 = <buffer>5__6.ReadUInt16(offset2);
							if (num2 != 0)
							{
								Constants.ENSURE(num2 > 0 && num3 > 0, "Invalid footer ref position {0} with length {1}", num2, num3);
								Constants.ENSURE(num2 + num3 < 8192, "Invalid footer ref position {0} with length {1}", num2, num3);
								BufferSlice bufferSlice = <buffer>5__6.Slice(num2, num3);
								bool num4 = bufferSlice.ReadBool(0);
								PageAddress pageAddress = bufferSlice.ReadPageAddress(1);
								BufferSlice bufferSlice2 = bufferSlice.Slice(6, bufferSlice.Count - 6);
								if (!num4)
								{
									using (MemoryStream memoryStream = new MemoryStream())
									{
										memoryStream.Write(bufferSlice2.Array, bufferSlice2.Offset, bufferSlice2.Count);
										while (!pageAddress.IsEmpty)
										{
											Result<BasePage> result2 = fileReaderV.ReadPage(pageAddress.PageID, out <pageInfo>5__5);
											if (result2.Fail)
											{
												throw result2.Exception;
											}
											PageBuffer buffer = result2.Value.Buffer;
											Constants.ENSURE(result2.Value.PageType == PageType.Data, "Invalid PageType (excepted Data, get {0})", result2.Value.PageType);
											Constants.ENSURE(result2.Value.ColID == <colID>5__2, "Invalid ColID in this page (expected {0}, get {1})", <colID>5__2, result2.Value.ColID);
											Constants.ENSURE(result2.Value.ItemsCount > 0, "Page with no items count");
											offset = BasePage.CalcPositionAddr(pageAddress.Index);
											offset2 = BasePage.CalcLengthAddr(pageAddress.Index);
											num2 = buffer.ReadUInt16(offset);
											num3 = buffer.ReadUInt16(offset2);
											Constants.ENSURE(num3 > 0, "Last DataBlock request a next extend to {0}, but this block are empty footer", pageAddress);
											bufferSlice = buffer.Slice(num2, num3);
											bool conditional = bufferSlice.ReadBool(0);
											pageAddress = bufferSlice.ReadPageAddress(1);
											bufferSlice2 = bufferSlice.Slice(6, bufferSlice.Count - 6);
											Constants.ENSURE(conditional, "Next datablock always be an extend. Invalid data block {0}", pageAddress);
											memoryStream.Write(bufferSlice2.Array, bufferSlice2.Offset, bufferSlice2.Count);
										}
										using BufferReader bufferReader = new BufferReader(memoryStream.ToArray());
										Result<BsonDocument> result3 = bufferReader.ReadDocument();
										BsonValue bsonValue = result3.Value["_id"];
										Constants.ENSURE(!(bsonValue == BsonValue.Null) && !(bsonValue == BsonValue.MinValue) && !(bsonValue == BsonValue.MaxValue), "Invalid _id value: {0}", bsonValue);
										Constants.ENSURE(!<uniqueIDs>5__3.Contains(bsonValue), "Duplicated _id value: {0}", bsonValue);
										<uniqueIDs>5__3.Add(bsonValue);
										if (result3.Fail)
										{
											fileReaderV.HandleError(result3.Exception, <pageInfo>5__5);
										}
										bsonDocument = result3.Value;
									}
									goto IL_04c5;
								}
							}
						}
						catch (Exception ex)
						{
							fileReaderV.HandleError(ex, <pageInfo>5__5);
							bsonDocument = null;
							goto IL_04c5;
						}
						goto IL_04ea;
					}
					<buffer>5__6 = null;
					goto IL_0514;
					IL_04c5:
					if (bsonDocument != null)
					{
						<>2__current = bsonDocument;
						<>1__state = 1;
						return true;
					}
					goto IL_04ea;
					IL_04ea:
					<i>5__8++;
					goto IL_04fc;
				}
				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;
				((IDisposable)<>7__wrap3).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<GetDocuments>d__17 <GetDocuments>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetDocuments>d__ = this;
				}
				else
				{
					<GetDocuments>d__ = new <GetDocuments>d__17(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetDocuments>d__.collection = <>3__collection;
				return <GetDocuments>d__;
			}

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

		private readonly Dictionary<string, uint> _collections = new Dictionary<string, uint>();

		private readonly Dictionary<string, List<IndexInfo>> _indexes = new Dictionary<string, List<IndexInfo>>();

		private readonly Dictionary<uint, List<uint>> _collectionsDataPages = new Dictionary<uint, List<uint>>();

		private readonly Dictionary<string, BsonValue> _pragmas = new Dictionary<string, BsonValue>
		{
			["USER_VERSION"] = 0,
			["CHECKPOINT"] = 1000,
			["TIMEOUT"] = 60,
			["UTC_DATE"] = true,
			["LIMIT_SIZE"] = long.MaxValue
		};

		private Stream _dataStream;

		private Stream _logStream;

		private readonly IDictionary<uint, long> _logIndexMap = new Dictionary<uint, long>();

		private uint _maxPageID;

		private bool _disposed;

		private readonly EngineSettings _settings;

		private readonly IList<FileReaderError> _errors;

		public FileReaderV8(EngineSettings settings, IList<FileReaderError> errors)
		{
			_settings = settings;
			_errors = errors;
		}

		public void Open()
		{
			try
			{
				IStreamFactory streamFactory = _settings.CreateDataFactory();
				IStreamFactory streamFactory2 = _settings.CreateLogFactory();
				_maxPageID = (uint)((streamFactory.GetLength() + streamFactory2.GetLength()) / 8192);
				_dataStream = streamFactory.GetStream(canWrite: true, sequencial: false);
				_dataStream.Position = 0L;
				if (streamFactory2.Exists())
				{
					_logStream = streamFactory2.GetStream(canWrite: false, sequencial: true);
					LoadIndexMap();
				}
				LoadPragmas();
				LoadDataPages();
				LoadCollections();
				LoadIndexes();
			}
			catch (Exception ex)
			{
				HandleError(ex, default(PageInfo));
			}
		}

		public IDictionary<string, BsonValue> GetPragmas()
		{
			return _pragmas;
		}

		public IEnumerable<string> GetCollections()
		{
			return _collections.Keys;
		}

		public IEnumerable<IndexInfo> GetIndexes(string collection)
		{
			if (!_indexes.ContainsKey(collection))
			{
				return new List<IndexInfo>();
			}
			return _indexes[collection];
		}

		[IteratorStateMachine(typeof(<GetDocuments>d__17))]
		public IEnumerable<BsonDocument> GetDocuments(string collection)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetDocuments>d__17(-2)
			{
				<>4__this = this,
				<>3__collection = collection
			};
		}

		private void LoadPragmas()
		{
			PageInfo pageInfo;
			Result<BasePage> result = ReadPage(0u, out pageInfo);
			if (result.Ok)
			{
				PageBuffer buffer = result.Value.Buffer;
				_pragmas["USER_VERSION"] = buffer.ReadInt32(76);
				_pragmas["CHECKPOINT"] = buffer.ReadInt32(97);
				_pragmas["TIMEOUT"] = buffer.ReadInt32(88);
				_pragmas["UTC_DATE"] = buffer.ReadBool(96);
				_pragmas["LIMIT_SIZE"] = buffer.ReadInt64(101);
			}
			else
			{
				HandleError(result.Exception, pageInfo);
			}
		}

		private void LoadDataPages()
		{
			PageInfo pageInfo;
			uint num = ReadPage(0u, out pageInfo).GetValue().Buffer.ReadUInt32(64);
			Constants.ENSURE(num <= _maxPageID, "LastPageID {0} should be less or equals to maxPageID {1}", num, _maxPageID);
			for (uint num2 = 0u; num2 <= num; num2++)
			{
				Result<BasePage> result = ReadPage(num2, out pageInfo);
				if (result.Ok)
				{
					BasePage value = result.Value;
					if (value.PageType == PageType.Data)
					{
						if (_collectionsDataPages.TryGetValue(value.ColID, out var value2))
						{
							value2.Add(value.PageID);
							continue;
						}
						_collectionsDataPages[value.ColID] = new List<uint> { value.PageID };
					}
				}
				else
				{
					HandleError(result.Exception, pageInfo);
				}
			}
		}

		private void LoadCollections()
		{
			PageInfo pageInfo;
			BufferSlice bufferSlice = ReadPage(0u, out pageInfo).GetValue().Buffer.Slice(192, 8000);
			using (BufferReader bufferReader = new BufferReader(new BufferSlice[1] { bufferSlice }))
			{
				Result<BsonDocument> result = bufferReader.ReadDocument();
				BsonDocument value = result.Value;
				foreach (string key in value.Keys)
				{
					BsonValue bsonValue = value[key];
					if (!bsonValue.IsNumber)
					{
						HandleError($"ColID expect a number but get {bsonValue}", pageInfo);
					}
					else
					{
						_collections[key] = (uint)value[key].AsInt32;
					}
				}
				if (result.Fail)
				{
					HandleError(result.Exception, pageInfo);
				}
			}
			foreach (KeyValuePair<uint, List<uint>> collectionsDataPage in _collectionsDataPages)
			{
				if (!_collections.ContainsValue(collectionsDataPage.Key))
				{
					_collections["col_" + collectionsDataPage.Key] = collectionsDataPage.Key;
				}
			}
		}

		private void LoadIndexes()
		{
			foreach (KeyValuePair<string, uint> collection in _collections)
			{
				PageInfo pageInfo;
				Result<BasePage> result = ReadPage(collection.Value, out pageInfo);
				if (result.Fail)
				{
					HandleError(result.Exception, pageInfo);
					continue;
				}
				try
				{
					CollectionPage collectionPage = new CollectionPage(result.Value.Buffer);
					foreach (CollectionIndex collectionIndex in collectionPage.GetCollectionIndexes())
					{
						if (!(collectionIndex.Name == "_id"))
						{
							IndexInfo item = new IndexInfo
							{
								Collection = collection.Key,
								Name = collectionIndex.Name,
								Expression = collectionIndex.Expression,
								Unique = collectionIndex.Unique,
								IndexType = collectionIndex.IndexType,
								VectorMetadata = ((collectionIndex.IndexType == 1) ? collectionPage.GetVectorIndexMetadata(collectionIndex.Name) : null)
							};
							if (_indexes.TryGetValue(collection.Key, out var value))
							{
								value.Add(item);
								continue;
							}
							_indexes[collection.Key] = new List<IndexInfo> { item };
						}
					}
				}
				catch (Exception ex)
				{
					HandleError(ex, pageInfo);
				}
			}
		}

		public static bool IsVersion(byte[] buffer)
		{
			string @string = Encoding.UTF8.GetString(buffer, 32, "** This is a LiteDB file **".Length);
			byte b = buffer[59];
			if (!(@string == "** This is a LiteDB file **") || b != 8)
			{
				return buffer[0] == 1;
			}
			return true;
		}

		private void LoadIndexMap()
		{
			PageBuffer pageBuffer = new PageBuffer(new byte[8192], 0, 0);
			Dictionary<uint, List<PagePosition>> dictionary = new Dictionary<uint, List<PagePosition>>();
			List<uint> list = new List<uint>();
			long num = 0L;
			PageInfo pageInfo = default(PageInfo);
			pageInfo.Origin = FileOrigin.Log;
			PageInfo pageInfo2 = pageInfo;
			_logStream.Position = 0L;
			while (_logStream.Position < _logStream.Length)
			{
				try
				{
					_logStream.Position = (pageInfo2.Position = num);
					int num2 = _logStream.Read(pageBuffer.Array, pageBuffer.Offset, 8192);
					if (pageBuffer.IsBlank())
					{
						num += 8192;
						continue;
					}
					uint pageID = pageBuffer.ReadUInt32(0);
					bool flag = pageBuffer.ReadBool(18);
					uint num3 = pageBuffer.ReadUInt32(14);
					pageInfo2.PageID = pageID;
					pageInfo2.ColID = pageBuffer.ReadUInt32(19);
					Constants.ENSURE(num2 == 8192, "Page position {0} read only than {1} bytes (instead {2})", _logStream, num2, 8192);
					PagePosition item = new PagePosition(pageID, num);
					if (dictionary.TryGetValue(num3, out var value))
					{
						value.Add(item);
					}
					else
					{
						dictionary[num3] = new List<PagePosition> { item };
					}
					if (flag)
					{
						list.Add(num3);
					}
				}
				catch (Exception ex)
				{
					HandleError(ex, pageInfo2);
				}
				finally
				{
					num += 8192;
				}
			}
			foreach (uint item2 in list)
			{
				foreach (PagePosition item3 in dictionary[item2])
				{
					_logIndexMap[item3.PageID] = item3.Position;
				}
			}
		}

		private Result<BasePage> ReadPage(uint pageID, out PageInfo pageInfo)
		{
			pageInfo = new PageInfo
			{
				PageID = pageID
			};
			try
			{
				Constants.ENSURE(pageID <= _maxPageID, "PageID: {0} should be less then or equals to maxPageID: {1}", pageID, _maxPageID);
				PageBuffer pageBuffer = new PageBuffer(new byte[8192], 0, 8192);
				Stream stream;
				if (_logIndexMap.TryGetValue(pageID, out pageInfo.Position))
				{
					pageInfo.Origin = FileOrigin.Log;
					stream = _logStream;
				}
				else
				{
					pageInfo.Origin = FileOrigin.Data;
					pageInfo.Position = BasePage.GetPagePosition(pageID);
					stream = _dataStream;
				}
				stream.Position = pageInfo.Position;
				int num = stream.Read(pageBuffer.Array, pageBuffer.Offset, pageBuffer.Count);
				Constants.ENSURE(num == 8192, "Page position {0} read only than {1} bytes (instead {2})", stream.Position, num, 8192);
				BasePage basePage = new BasePage(pageBuffer);
				pageInfo.ColID = basePage.ColID;
				Constants.ENSURE(basePage.PageID == pageID, "Expect read pageID: {0} but header contains pageID: {1}", pageID, basePage.PageID);
				return basePage;
			}
			catch (Exception ex)
			{
				return new Result<BasePage>(null, ex);
			}
		}

		private void HandleError(Exception ex, PageInfo pageInfo)
		{
			string key = _collections.FirstOrDefault((KeyValuePair<string, uint> x) => x.Value == pageInfo.ColID).Key;
			_errors.Add(new FileReaderError
			{
				Position = pageInfo.Position,
				Origin = pageInfo.Origin,
				PageID = pageInfo.PageID,
				PageType = pageInfo.PageType,
				Collection = key,
				Message = ex.Message,
				Exception = ex
			});
			if (ex is IOException)
			{
				throw ex;
			}
		}

		private void HandleError(string message, PageInfo pageInfo)
		{
			HandleError(new Exception(message), pageInfo);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				_dataStream?.Dispose();
				_logStream?.Dispose();
				_disposed = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal interface IFileReader : IDisposable
	{
		void Open();

		IDictionary<string, BsonValue> GetPragmas();

		IEnumerable<string> GetCollections();

		IEnumerable<IndexInfo> GetIndexes(string name);

		IEnumerable<BsonDocument> GetDocuments(string collection);
	}
	internal class IndexInfo
	{
		public string Collection { get; set; }

		public string Name { get; set; }

		public string Expression { get; set; }

		public bool Unique { get; set; }

		public byte IndexType { get; set; }

		public VectorIndexMetadata VectorMetadata { get; set; }
	}
	internal interface ILiteEngine : IDisposable
	{
		int Checkpoint();

		long Rebuild(RebuildOptions options);

		bool BeginTrans();

		bool Commit();

		bool Rollback();

		IBsonDataReader Query(string collection, Query query);

		int Insert(string collection, IEnumerable<BsonDocument> docs, BsonAutoId autoId);

		int Update(string collection, IEnumerable<BsonDocument> docs);

		int UpdateMany(string collection, BsonExpression transform, BsonExpression predicate);

		int Upsert(string collection, IEnumerable<BsonDocument> docs, BsonAutoId autoId);

		int Delete(string collection, IEnumerable<BsonValue> ids);

		int DeleteMany(string collection, BsonExpression predicate);

		bool DropCollection(string name);

		bool RenameCollection(string name, string newName);

		bool EnsureIndex(string collection, string name, BsonExpression expression, bool unique);

		bool EnsureVectorIndex(string collection, string name, BsonExpression expression, VectorIndexOptions options);

		bool DropIndex(string collection, string name);

		BsonValue Pragma(string name);

		bool Pragma(string name, BsonValue value);
	}
	internal enum PageType
	{
		Empty,
		Header,
		Collection,
		Index,
		Data,
		VectorIndex
	}
	internal class BasePage
	{
		[CompilerGenerated]
		private sealed class <GetUsedIndexs>d__88 : IEnumerable<byte>, IEnumerable, IEnumerator<byte>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private byte <>2__current;

			private int <>l__initialThreadId;

			public BasePage <>4__this;

			private byte <index>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				BasePage basePage = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0081;
				}
				<>1__state = -1;
				if (basePage.ItemsCount == 0)
				{
					return false;
				}
				Constants.ENSURE(basePage.HighestIndex != byte.MaxValue, "if has items count, Highest index should be not empty");
				<index>5__2 = 0;
				goto IL_0092;
				IL_0081:
				<index>5__2++;
				goto IL_0092;
				IL_0092:
				if (<index>5__2 <= basePage.HighestIndex)
				{
					int offset = CalcPositionAddr(<index>5__2);
					if (basePage._buffer.ReadUInt16(offset) != 0)
					{
						<>2__current = <index>5__2;
						<>1__state = 1;
						return true;
					}
					goto IL_0081;
				}
				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]
			IEnumerator<byte> IEnumerable<byte>.GetEnumerator()
			{
				<GetUsedIndexs>d__88 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetUsedIndexs>d__88(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		protected readonly PageBuffer _buffer;

		public const int SLOT_SIZE = 4;

		public const int P_PAGE_ID = 0;

		public const int P_PAGE_TYPE = 4;

		public const int P_PREV_PAGE_ID = 5;

		public const int P_NEXT_PAGE_ID = 9;

		public const int P_INITIAL_SLOT = 13;

		public const int P_TRANSACTION_ID = 14;

		public const int P_IS_CONFIRMED = 18;

		public const int P_COL_ID = 19;

		public const int P_ITEMS_COUNT = 23;

		public const int P_USED_BYTES = 24;

		public const int P_FRAGMENTED_BYTES = 26;

		public const int P_NEXT_FREE_POSITION = 28;

		public const int P_HIGHEST_INDEX = 30;

		private byte _startIndex;

		public uint PageID { get; }

		public PageType PageType { get; private set; }

		public uint PrevPageID { get; set; }

		public uint NextPageID { get; set; }

		public byte PageListSlot { get; set; }

		public byte ItemsCount { get; private set; }

		public ushort UsedBytes { get; private set; }

		public ushort FragmentedBytes { get; private set; }

		public ushort NextFreePosition { get; private set; }

		public byte HighestIndex { get; private set; }

		public int FreeBytes
		{
			get
			{
				if (ItemsCount != byte.MaxValue)
				{
					return 8160 - UsedBytes - FooterSize;
				}
				return 0;
			}
		}

		public int FooterSize
		{
			get
			{
				if (HighestIndex != byte.MaxValue)
				{
					return (HighestIndex + 1) * 4;
				}
				return 0;
			}
		}

		public uint ColID { get; set; }

		public uint TransactionID { get; set; }

		public bool IsConfirmed { get; set; }

		public bool IsDirty { get; set; }

		public PageBuffer Buffer => _buffer;

		public BasePage(PageBuffer buffer, uint pageID, PageType pageType)
		{
			_buffer = buffer;
			PageID = pageID;
			PageType = pageType;
			PrevPageID = uint.MaxValue;
			NextPageID = uint.MaxValue;
			PageListSlot = byte.MaxValue;
			ColID = uint.MaxValue;
			TransactionID = uint.MaxValue;
			IsConfirmed = false;
			ItemsCount = 0;
			UsedBytes = 0;
			FragmentedBytes = 0;
			NextFreePosition = 32;
			HighestIndex = byte.MaxValue;
			IsDirty = false;
			_buffer.Write(PageID, 0);
			_buffer.Write((byte)PageType, 4);
		}

		public BasePage(PageBuffer buffer)
		{
			_buffer = buffer;
			PageID = _buffer.ReadUInt32(0);
			PageType = (PageType)_buffer.ReadByte(4);
			PrevPageID = _buffer.ReadUInt32(5);
			NextPageID = _buffer.ReadUInt32(9);
			PageListSlot = _buffer.ReadByte(13);
			TransactionID = _buffer.ReadUInt32(14);
			IsConfirmed = _buffer.ReadBool(18);
			ColID = _buffer.ReadUInt32(19);
			ItemsCount = _buffer.ReadByte(23);
			UsedBytes = _buffer.ReadUInt16(24);
			FragmentedBytes = _buffer.ReadUInt16(26);
			NextFreePosition = _buffer.ReadUInt16(28);
			HighestIndex = _buffer.ReadByte(30);
		}

		public virtual PageBuffer UpdateBuffer()
		{
			Constants.ENSURE(PageID == _buffer.ReadUInt32(0), "pageID can't be changed");
			_buffer.Write(PrevPageID, 5);
			_buffer.Write(NextPageID, 9);
			_buffer.Write(PageListSlot, 13);
			_buffer.Write(TransactionID, 14);
			_buffer.Write(IsConfirmed, 18);
			_buffer.Write(ColID, 19);
			_buffer.Write(ItemsCount, 23);
			_buffer.Write(UsedBytes, 24);
			_buffer.Write(FragmentedBytes, 26);
			_buffer.Write(NextFreePosition, 28);
			_buffer.Write(HighestIndex, 30);
			return _buffer;
		}

		public void MarkAsEmtpy()
		{
			IsDirty = true;
			PageType = PageType.Empty;
			PrevPageID = uint.MaxValue;
			NextPageID = uint.MaxValue;
			PageListSlot = byte.MaxValue;
			ColID = uint.MaxValue;
			TransactionID = uint.MaxValue;
			IsConfirmed = false;
			ItemsCount = 0;
			UsedBytes = 0;
			FragmentedBytes = 0;
			NextFreePosition = 32;
			HighestIndex = byte.MaxValue;
			_buffer.Clear(32, 8160);
			_buffer.Write((byte)PageType, 4);
		}

		public BufferSlice Get(byte index)
		{
			Constants.ENSURE(ItemsCount > 0, "should have items in this page");
			Constants.ENSURE(HighestIndex != byte.MaxValue, "should have at least 1 index in this page");
			Constants.ENSURE(index <= HighestIndex, "get only index below highest index");
			int offset = CalcPositionAddr(index);
			int offset2 = CalcLengthAddr(index);
			ushort num = _buffer.ReadUInt16(offset);
			ushort num2 = _buffer.ReadUInt16(offset2);
			Constants.ENSURE(IsValidPos(num), "invalid segment position in index footer: {0}/{1}", this, index);
			Constants.ENSURE(IsValidLen(num2), "invalid segment length in index footer: {0}/{1}", this, index);
			return _buffer.Slice(num, num2);
		}

		public BufferSlice Insert(ushort bytesLength, out byte index)
		{
			index = byte.MaxValue;
			return InternalInsert(bytesLength, ref index);
		}

		private BufferSlice InternalInsert(ushort bytesLength, ref byte index)
		{
			bool flag = index == byte.MaxValue;
			Constants.ENSURE(_buffer.ShareCounter == Constants.BUFFER_WRITABLE, "page must be writable to support changes");
			Constants.ENSURE(bytesLength > 0, "must insert more than 0 bytes");
			Constants.ENSURE(FreeBytes >= bytesLength + (flag ? 4 : 0), "length must be always lower than current free space");
			Constants.ENSURE(ItemsCount < byte.MaxValue, "page full");
			Constants.ENSURE(FreeBytes >= FragmentedBytes, "fragmented bytes must be at most free bytes");
			if (FreeBytes < bytesLength + (flag ? 4 : 0))
			{
				throw LiteException.InvalidFreeSpacePage(PageID, FreeBytes, bytesLength + (flag ? 4 : 0));
			}
			int num = FreeBytes - FragmentedBytes - (flag ? 4 : 0);
			Constants.ENSURE(num == 8192 - NextFreePosition - FooterSize - (flag ? 4 : 0), "continuousBlock must be same as from NextFreePosition");
			if (bytesLength > num)
			{
				Defrag();
			}
			if (index == byte.MaxValue)
			{
				index = GetFreeIndex();
			}
			if (index > HighestIndex || HighestIndex == byte.MaxValue)
			{
				Constants.ENSURE(index == (byte)(HighestIndex + 1), "new index must be next highest index");
				HighestIndex = index;
			}
			int offset = CalcPositionAddr(index);
			int offset2 = CalcLengthAddr(index);
			Constants.ENSURE(_buffer.ReadUInt16(offset) == 0, "slot position must be empty before use");
			Constants.ENSURE(_buffer.ReadUInt16(offset2) == 0, "slot length must be empty before use");
			ushort nextFreePosition = NextFreePosition;
			_buffer.Write(nextFreePosition, offset);
			_buffer.Write(bytesLength, offset2);
			ItemsCount++;
			UsedBytes += bytesLength;
			NextFreePosition += bytesLength;
			IsDirty = true;
			Constants.ENSURE(nextFreePosition + bytesLength <= 8192 - (HighestIndex + 1) * 4, "new buffer slice could not override footer area");
			return _buffer.Slice(nextFreePosition, bytesLength);
		}

		public void Delete(byte index)
		{
			Constants.ENSURE(_buffer.ShareCounter == Constants.BUFFER_WRITABLE, "page must be writable to support changes");
			int offset = CalcPositionAddr(index);
			int offset2 = CalcLengthAddr(index);
			ushort num = _buffer.ReadUInt16(offset);
			ushort num2 = _buffer.ReadUInt16(offset2);
			Constants.ENSURE(IsValidPos(num), "invalid segment position");
			Constants.ENSURE(IsValidLen(num2), "invalid segment length");
			((BufferSlice)_buffer).Write((ushort)0, offset);
			((BufferSlice)_buffer).Write((ushort)0, offset2);
			ItemsCount--;
			UsedBytes -= num2;
			_buffer.Array.Fill(0, _buffer.Offset + num, num2);
			if (num + num2 == NextFreePosition)
			{
				NextFreePosition = num;
			}
			else
			{
				FragmentedBytes += num2;
			}
			if (HighestIndex == index)
			{
				UpdateHighestIndex();
			}
			_startIndex = 0;
			if (ItemsCount == 0)
			{
				Constants.ENSURE(HighestIndex == byte.MaxValue, "if there is no items, HighestIndex must be clear");
				Constants.ENSURE(UsedBytes == 0, "should be no bytes used in clean page");
				NextFreePosition = 32;
				FragmentedBytes = 0;
			}
			IsDirty = true;
		}

		public BufferSlice Update(byte index, ushort bytesLength)
		{
			Constants.ENSURE(_buffer.ShareCounter == Constants.BUFFER_WRITABLE, "page must be writable to support changes");
			Constants.ENSURE(bytesLength > 0, "must update more than 0 bytes");
			int offset = CalcPositionAddr(index);
			int offset2 = CalcLengthAddr(index);
			ushort num = _buffer.ReadUInt16(offset);
			ushort num2 = _buffer.ReadUInt16(offset2);
			Constants.ENSURE(IsValidPos(num), "invalid segment position");
			Constants.ENSURE(IsValidLen(num2), "invalid segment length");
			bool flag = num + num2 == NextFreePosition;
			IsDirty = true;
			if (bytesLength == num2)
			{
				return _buffer.Slice(num, num2);
			}
			if (bytesLength < num2)
			{
				ushort num3 = (ushort)(num2 - bytesLength);
				if (flag)
				{
					NextFreePosition -= num3;
				}
				else
				{
					FragmentedBytes += num3;
				}
				UsedBytes -= num3;
				_buffer.Write(bytesLength, offset2);
				_buffer.Clear(num + bytesLength, num3);
				return _buffer.Slice(num, bytesLength);
			}
			_buffer.Clear(num, num2);
			ItemsCount--;
			UsedBytes -= num2;
			if (flag)
			{
				NextFreePosition = num;
			}
			else
			{
				FragmentedBytes += num2;
			}
			((BufferSlice)_buffer).Write((ushort)0, offset);
			((BufferSlice)_buffer).Write((ushort)0, offset2);
			return InternalInsert(bytesLength, ref index);
		}

		public void Defrag()
		{
			Constants.ENSURE(FragmentedBytes > 0, "do not call this when page has no fragmentation");
			Constants.ENSURE(_buffer.ShareCounter == Constants.BUFFER_WRITABLE, "page must be writable to support changes");
			Constants.ENSURE(HighestIndex < byte.MaxValue, "there is no items in this page to run defrag");
			SortedList<ushort, byte> sortedList = new SortedList<ushort, byte>();
			for (int i = 0; i <= HighestIndex; i++)
			{
				int offset = CalcPositionAddr((byte)i);
				ushort num = _buffer.ReadUInt16(offset);
				if (num != 0)
				{
					Constants.ENSURE(IsValidPos(num), "invalid segment position");
					sortedList.Add(num, (byte)i);
				}
			}
			ushort num2 = 32;
			foreach (KeyValuePair<ushort, byte> item in sortedList)
			{
				byte value = item.Value;
				ushort key = item.Key;
				int offset2 = CalcLengthAddr(value);
				ushort num3 = _buffer.ReadUInt16(offset2);
				Constants.ENSURE(IsValidLen(num3), "invalid segment length");
				if (key != num2)
				{
					Constants.ENSURE(key > num2, "current segment position must be greater than current empty space");
					System.Buffer.BlockCopy(_buffer.Array, _buffer.Offset + key, _buffer.Array, _buffer.Offset + num2, num3);
					int offset3 = CalcPositionAddr(value);
					_buffer.Write(num2, offset3);
				}
				num2 += num3;
			}
			int count = 8192 - num2 - FooterSize;
			_buffer.Array.Fill(0, _buffer.Offset + num2, count);
			FragmentedBytes = 0;
			NextFreePosition = num2;
		}

		private byte GetFreeIndex()
		{
			for (byte b = _startIndex; b <= HighestIndex; b++)
			{
				int offset = CalcPositionAddr(b);
				if (_buffer.ReadUInt16(offset) == 0)
				{
					_startIndex = (byte)(b + 1);
					return b;
				}
			}
			return (byte)(HighestIndex + 1);
		}

		[IteratorStateMachine(typeof(<GetUsedIndexs>d__88))]
		public IEnumerable<byte> GetUsedIndexs()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetUsedIndexs>d__88(-2)
			{
				<>4__this = this
			};
		}

		private void UpdateHighestIndex()
		{
			Constants.ENSURE(HighestIndex < byte.MaxValue, "can run only if contains a valid HighestIndex");
			if (HighestIndex == 0)
			{
				HighestIndex = byte.MaxValue;
				return;
			}
			for (int num = HighestIndex - 1; num >= 0; num--)
			{
				int offset = CalcPositionAddr((byte)num);
				ushort num2 = _buffer.ReadUInt16(offset);
				if (num2 != 0)
				{
					Constants.ENSURE(IsValidPos(num2), "invalid segment position");
					HighestIndex = (byte)num;
					return;
				}
			}
			HighestIndex = byte.MaxValue;
		}

		private bool IsValidPos(ushort position)
		{
			if (position >= 32)
			{
				return position < 8192 - FooterSize;
			}
			return false;
		}

		private bool IsValidLen(ushort length)
		{
			if (length > 0)
			{
				return length <= 8160 - FooterSize;
			}
			return false;
		}

		public static int CalcPositionAddr(byte index)
		{
			return 8192 - (index + 1) * 4 + 2;
		}

		public static int CalcLengthAddr(byte index)
		{
			return 8192 - (index + 1) * 4;
		}

		public static long GetPagePosition(uint pageID)
		{
			checked
			{
				return unchecked((long)pageID) * 8192L;
			}
		}

		public static long GetPagePosition(int pageID)
		{
			Constants.ENSURE(pageID >= 0, "page could not be less than 0.");
			return GetPagePosition((uint)pageID);
		}

		public static T ReadPage<T>(PageBuffer buffer) where T : BasePage
		{
			if (typeof(T) == typeof(BasePage))
			{
				return (T)new BasePage(buffer);
			}
			if (typeof(T) == typeof(HeaderPage))
			{
				return (T)(BasePage)new HeaderPage(buffer);
			}
			if (typeof(T) == typeof(CollectionPage))
			{
				return (T)(BasePage)new CollectionPage(buffer);
			}
			if (typeof(T) == typeof(IndexPage))
			{
				return (T)(BasePage)new IndexPage(buffer);
			}
			if (typeof(T) == typeof(VectorIndexPage))
			{
				return (T)(BasePage)new VectorIndexPage(buffer);
			}
			if (typeof(T) == typeof(DataPage))
			{
				return (T)(BasePage)new DataPage(buffer);
			}
			throw new InvalidCastException();
		}

		public static T CreatePage<T>(PageBuffer buffer, uint pageID) where T : BasePage
		{
			if (typeof(T) == typeof(CollectionPage))
			{
				return (T)(BasePage)new CollectionPage(buffer, pageID);
			}
			if (typeof(T) == typeof(IndexPage))
			{
				return (T)(BasePage)new IndexPage(buffer, pageID);
			}
			if (typeof(T) == typeof(VectorIndexPage))
			{
				return (T)(BasePage)new VectorIndexPage(buffer, pageID);
			}
			if (typeof(T) == typeof(DataPage))
			{
				return (T)(BasePage)new DataPage(buffer, pageID);
			}
			throw new InvalidCastException();
		}

		public override string ToString()
		{
			return $"PageID: {PageID.ToString().PadLeft(4, '0')} : {PageType} ({ItemsCount} Items)";
		}
	}
	internal class CollectionPage : BasePage
	{
		[CompilerGenerated]
		private sealed class <GetVectorIndexes>d__17 : IEnumerable<(CollectionIndex Index, VectorIndexMetadata Metadata)>, IEnumerable, IEnumerator<(CollectionIndex Index, VectorIndexMetadata Metadata)>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private (CollectionIndex Index, VectorIndexMetadata Metadata) <>2__current;

			private int <>l__initialThreadId;

			public CollectionPage <>4__this;

			private Dictionary<string, VectorIndexMetadata>.Enumerator <>7__wrap1;

			(CollectionIndex, VectorIndexMetadata) IEnumerator<(CollectionIndex, VectorIndexMetadata)>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <GetVectorIndexes>d__17(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();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					CollectionPage collectionPage = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = collectionPage._vectorIndexes.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						KeyValuePair<string, VectorIndexMetadata> current = <>7__wrap1.Current;
						if (collectionPage._indexes.TryGetValue(current.Key, out var value))
						{
							<>2__current = (value, current.Value);
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					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;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<(CollectionIndex Index, VectorIndexMetadata Metadata)> IEnumerable<(CollectionIndex, VectorIndexMetadata)>.GetEnumerator()
			{
				<GetVectorIndexes>d__17 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetVectorIndexes>d__17(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public const int P_INDEXES = 96;

		public const int P_INDEXES_COUNT = 8096;

		private readonly Dictionary<string, CollectionIndex> _indexes = new Dictionary<string, CollectionIndex>();

		private readonly Dictionary<string, VectorIndexMetadata> _vectorIndexes = new Dictionary<string, VectorIndexMetadata>();

		public uint[] FreeDataPageList { get; } = new uint[5];


		public CollectionIndex PK => _indexes["_id"];

		public CollectionPage(PageBuffer buffer, uint pageID)
			: base(buffer, pageID, PageType.Collection)
		{
			for (int i = 0; i < 5; i++)
			{
				FreeDataPageList[i] = uint.MaxValue;
			}
		}

		public CollectionPage(PageBuffer buffer)
			: base(buffer)
		{
			Constants.ENSURE(base.PageType == PageType.Collection, "page type must be collection page");
			if (base.PageType != PageType.Collection)
			{
				throw LiteException.InvalidPageType(PageType.Collection, this);
			}
			BufferSlice bufferSlice = _buffer.Slice(32, 8160);
			using BufferReader bufferReader = new BufferReader(new BufferSlice[1] { bufferSlice });
			for (int i = 0; i < 5; i++)
			{
				FreeDataPageList[i] = bufferReader.ReadUInt32();
			}
			bufferReader.Skip(64 - bufferReader.Position);
			byte b = bufferReader.ReadByte();
			for (int j = 0; j < b; j++)
			{
				CollectionIndex collectionIndex = new CollectionIndex(bufferReader);
				_indexes[collectionIndex.Name] = collectionIndex;
			}
			byte b2 = bufferReader.ReadByte();
			for (int k = 0; k < b2; k++)
			{
				string key = bufferReader.ReadCString();
				VectorIndexMetadata value = new VectorIndexMetadata(bufferReader);
				_vectorIndexes[key] = value;
			}
		}

		public override PageBuffer UpdateBuffer()
		{
			if (base.PageType == PageType.Empty)
			{
				return base.UpdateBuffer();
			}
			using (BufferWriter bufferWriter = new BufferWriter(_buffer.Slice(32, 8160)))
			{
				for (int i = 0; i < 5; i++)
				{
					bufferWriter.Write(FreeDataPageList[i]);
				}
				bufferWriter.Skip(64 - bufferWriter.Position);
				bufferWriter.Write((byte)_indexes.Count);
				foreach (CollectionIndex value in _indexes.Values)
				{
					value.UpdateBuffer(bufferWriter);
				}
				bufferWriter.Write((byte)_vectorIndexes.Count);
				foreach (KeyValuePair<string, VectorIndexMetadata> vectorIndex in _vectorIndexes)
				{
					bufferWriter.WriteCString(vectorIndex.Key);
					vectorIndex.Value.UpdateBuffer(bufferWriter);
				}
			}
			return base.UpdateBuffer();
		}

		public CollectionIndex GetCollectionIndex(string name)
		{
			if (_indexes.TryGetValue(name, out var value))
			{
				return value;
			}
			return null;
		}

		public ICollection<CollectionIndex> GetCollectionIndexes()
		{
			return _indexes.Values;
		}

		public CollectionIndex[] GetCollectionIndexesSlots()
		{
			CollectionIndex[] array = new CollectionIndex[_indexes.Max((KeyValuePair<string, CollectionIndex> x) => x.Value.Slot) + 1];
			foreach (CollectionIndex value in _indexes.Values)
			{
				array[value.Slot] = value;
			}
			return array;
		}

		private int GetSerializedLength(int additionalIndexLength, int additionalVectorLength)
		{
			return 1 + _indexes.Sum((KeyValuePair<string, CollectionIndex> x) => CollectionIndex.GetLength(x.Value)) + additionalIndexLength + (1 + _vectorIndexes.Sum((KeyValuePair<string, VectorIndexMetadata> x) => GetVectorMetadataLength(x.Key)) + additionalVectorLength);
		}

		private static int GetVectorMetadataLength(string name)
		{
			return StringEncoding.UTF8.GetByteCount(name) + 1 + VectorIndexMetadata.GetLength();
		}

		[IteratorStateMachine(typeof(<GetVectorIndexes>d__17))]
		public IEnumerable<(CollectionIndex Index, VectorIndexMetadata Metadata)> GetVectorIndexes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetVectorIndexes>d__17(-2)
			{
				<>4__this = this
			};
		}

		public VectorIndexMetadata GetVectorIndexMetadata(string name)
		{
			if (!_vectorIndexes.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		public CollectionIndex InsertCollectionIndex(string name, string expr, bool unique)
		{
			if (_indexes.ContainsKey(name) || _vectorIndexes.ContainsKey(name))
			{
				throw LiteException.IndexAlreadyExist(name);
			}
			int serializedLength = GetSerializedLength(CollectionIndex.GetLength(name, expr), 0);
			if (_indexes.Count == 255 || serializedLength >= 8096)
			{
				throw new LiteException(0, "This collection has no more space for new indexes");
			}
			CollectionIndex collectionIndex = new CollectionIndex((byte)((_indexes.Count != 0) ? ((uint)(_indexes.Max((KeyValuePair<string, CollectionIndex> x) => x.Value.Slot) + 1)) : 0u), 0, name, expr, unique);
			_indexes[name] = collectionIndex;
			base.IsDirty = true;
			return collectionIndex;
		}

		public (CollectionIndex Index, VectorIndexMetadata Metadata) InsertVectorIndex(string name, string expr, ushort dimensions, VectorDistanceMetric metric)
		{
			if (_indexes.ContainsKey(name) || _vectorIndexes.ContainsKey(name))
			{
				throw LiteException.IndexAlreadyExist(name);
			}
			int serializedLength = GetSerializedLength(CollectionIndex.GetLength(name, expr), GetVectorMetadataLength(name));
			if (_indexes.Count == 255 || serializedLength >= 8096)
			{
				throw new LiteException(0, "This collection has no more space for new indexes");
			}
			byte slot = (byte)((_indexes.Count != 0) ? (_indexes.Max((KeyValuePair<string, CollectionIndex> x) => x.Value.Slot) + 1) : 0);
			CollectionIndex collectionIndex = new CollectionIndex(slot, 1, name, expr, unique: false);
			VectorIndexMetadata vectorIndexMetadata = new VectorIndexMetadata(slot, dimensions, metric);
			_indexes[name] = collectionIndex;
			_vectorIndexes[name] = vectorIndexMetadata;
			base.IsDirty = true;
			return (collectionIndex, vectorIndexMetadata);
		}

		public CollectionIndex UpdateCollectionIndex(string name)
		{
			base.IsDirty = true;
			return _indexes[name];
		}

		public void DeleteCollectionIndex(string name)
		{
			_indexes.Remove(name);
			_vectorIndexes.Remove(name);
			base.IsDirty = true;
		}
	}
	internal class DataPage : BasePage
	{
		[CompilerGenerated]
		private sealed class <GetBlocks>d__6 : IEnumerable<PageAddress>, IEnumerable, IEnumerator<PageAddress>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private PageAddress <>2__current;

			private int <>l__initialThreadId;

			public DataPage <>4__this;

			private IEnumerator<byte> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <GetBlocks>d__6(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					DataPage dataPage = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = dataPage.GetUsedIndexs().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						byte current = <>7__wrap1.Current;
						int offset = BasePage.CalcPositionAddr(current);
						ushort offset2 = dataPage._buffer.ReadUInt16(offset);
						if (!dataPage._buffer.ReadBool(offset2))
						{
							<>2__current = new PageAddress(dataPage.PageID, current);
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<PageAddress> IEnumerable<PageAddress>.GetEnumerator()
			{
				<GetBlocks>d__6 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetBlocks>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private static readonly int[] _freePageSlots = new int[4] { 7344, 6120, 4896, 2448 };

		public DataPage(PageBuffer buffer)
			: base(buffer)
		{
			Constants.ENSURE(base.PageType == PageType.Data, "Page type must be data page: {0}", base.PageType);
			if (base.PageType != PageType.Data)
			{
				throw LiteException.InvalidPageType(PageType.Data, this);
			}
		}

		public DataPage(PageBuffer buffer, uint pageID)
			: base(buffer, pageID, PageType.Data)
		{
		}

		public DataBlock GetBlock(byte index)
		{
			BufferSlice segment = Get(index);
			return new DataBlock(this, index, segment);
		}

		public DataBlock InsertBlock(int bytesLength, bool extend)
		{
			byte index;
			BufferSlice segment = Insert((ushort)(bytesLength + 6), out index);
			return new DataBlock(this, index, segment, extend, PageAddress.Empty);
		}

		public DataBlock UpdateBlock(DataBlock currentBlock, int bytesLength)
		{
			BufferSlice segment = Update(currentBlock.Position.Index, (ushort)(bytesLength + 6));
			return new DataBlock(this, currentBlock.Position.Index, segment, currentBlock.Extend, currentBlock.NextBlock);
		}

		public void DeleteBlock(byte index)
		{
			Delete(index);
		}

		[IteratorStateMachine(typeof(<GetBlocks>d__6))]
		public IEnumerable<PageAddress> GetBlocks()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetBlocks>d__6(-2)
			{
				<>4__this = this
			};
		}

		public static byte FreeIndexSlot(int freeBytes)
		{
			Constants.ENSURE(freeBytes >= 0, "FreeBytes must be positive: {0}", freeBytes);
			for (int i = 0; i < _freePageSlots.Length; i++)
			{
				if (freeBytes >= _freePageSlots[i])
				{
					return (byte)i;
				}
			}
			return 4;
		}

		public static int GetMinimumIndexSlot(int length)
		{
			return FreeIndexSlot(length) - 1;
		}
	}
	internal class HeaderPage : BasePage
	{
		[CompilerGenerated]
		private sealed class <GetCollections>d__34 : IEnumerable<KeyValuePair<string, uint>>, IEnumerable, IEnumerator<KeyValuePair<string, uint>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<string, uint> <>2__current;

			private int <>l__initialThreadId;

			public HeaderPage <>4__this;

			private IEnumerator<KeyValuePair<string, BsonValue>> <>7__wrap1;

			KeyValuePair<string, uint> IEnumerator<KeyValuePair<string, uint>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <GetCollections>d__34(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					HeaderPage headerPage = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = headerPage._collections.GetElements().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						KeyValuePair<string, BsonValue> current = <>7__wrap1.Current;
						<>2__current = new KeyValuePair<string, uint>(current.Key, (uint)current.Value.AsInt32);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<KeyValuePair<string, uint>> IEnumerable<KeyValuePair<string, uint>>.GetEnumerator()
			{
				<GetCollections>d__34 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetCollections>d__34(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<string, uint>>)this).GetEnumerator();
			}
		}

		public const string HEADER_INFO = "** This is a LiteDB file **";

		public const byte FILE_VERSION = 8;

		public const int P_HEADER_INFO = 32;

		public const int P_FILE_VERSION = 59;

		public const int P_FREE_EMPTY_PAGE_ID = 60;

		public const int P_LAST_PAGE_ID = 64;

		public const int P_CREATION_TIME = 68;

		public const int P_INVALID_DATAFILE_STATE = 191;

		public const int P_COLLECTIONS = 192;

		public const int COLLECTIONS_SIZE = 8000;

		private BsonDocument _collections;

		private bool _isCollectionsChanged;

		public uint FreeEmptyPageList { get; set; }

		public uint LastPageID { get; set; }

		public DateTime CreationTime { get; }

		public EnginePragmas Pragmas { get; set; }

		public HeaderPage(PageBuffer buffer, uint pageID)
			: base(buffer, 0u, PageType.Header)
		{
			CreationTime = DateTime.UtcNow;
			FreeEmptyPageList = uint.MaxValue;
			LastPageID = 0u;
			Pragmas = new EnginePragmas(this);
			_buffer.Write("** This is a LiteDB file **", 32);
			((BufferSlice)_buffer).Write((byte)8, 59);
			_buffer.Write(CreationTime, 68);
			_collections = new BsonDocument();
		}

		public HeaderPage(PageBuffer buffer)
			: base(buffer)
		{
			CreationTime = _buffer.ReadDateTime(68);
			LoadPage();
		}

		private void LoadPage()
		{
			string strA = _buffer.ReadString(32, "** This is a LiteDB file **".Length);
			byte b = _buffer[59];
			if (string.CompareOrdinal(strA, "** This is a LiteDB file **") != 0 || b != 8)
			{
				throw LiteException.InvalidDatabase();
			}
			FreeEmptyPageList = _buffer.ReadUInt32(60);
			LastPageID = _buffer.ReadUInt32(64);
			Pragmas = new EnginePragmas(_buffer, this);
			BufferSlice bufferSlice = _buffer.Slice(192, 8000);
			using (BufferReader bufferReader = new BufferReader(new BufferSlice[1] { bufferSlice }))
			{
				_collections = bufferReader.ReadDocument().GetValue();
			}
			_isCollectionsChanged = false;
		}

		public override PageBuffer UpdateBuffer()
		{
			_buffer.Write(FreeEmptyPageList, 60);
			_buffer.Write(LastPageID, 64);
			Pragmas.UpdateBuffer(_buffer);
			if (_isCollectionsChanged)
			{
				using (BufferWriter bufferWriter = new BufferWriter(_buffer.Slice(192, 8000)))
				{
					bufferWriter.WriteDocument(_collections, recalc: true);
				}
				_isCollectionsChanged = false;
			}
			return base.UpdateBuffer();
		}

		public PageBuffer Savepoint()
		{
			UpdateBuffer();
			PageBuffer pageBuffer = new PageBuffer(new byte[8192], 0, 0);
			System.Buffer.BlockCopy(_buffer.Array, _buffer.Offset, pageBuffer.Array, pageBuffer.Offset, 8192);
			return pageBuffer;
		}

		public void Restore(PageBuffer savepoint)
		{
			System.Buffer.BlockCopy(savepoint.Array, savepoint.Offset, _buffer.Array, _buffer.Offset, 8192);
			LoadPage();
		}

		public uint GetCollectionPageID(string collection)
		{
			if (_collections.TryGetValue(collection, out var value))
			{
				return (uint)value.AsInt32;
			}
			return uint.MaxValue;
		}

		[IteratorStateMachine(typeof(<GetCollections>d__34))]
		public IEnumerable<KeyValuePair<string, uint>> GetCollections()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetCollections>d__34(-2)
			{
				<>4__this = this
			};
		}

		public void InsertCollection(string name, uint pageID)
		{
			_collections[name] = (int)pageID;
			_isCollectionsChanged = true;
		}

		public void DeleteCollection(string name)
		{
			_collections.Remove(name);
			_isCollectionsChanged = true;
		}

		public void RenameCollection(string oldName, string newName)
		{
			BsonValue value = _collections[oldName];
			_collections.Remove(oldName);
			_collections.Add(newName, value);
			_isCollectionsChanged = true;
		}

		public int GetAvailableCollectionSpace()
		{
			return 8000 - _collections.GetBytesCount(recalc: true) - 1 - 1 - 4 - 8;
		}
	}
	internal class IndexPage : BasePage
	{
		[CompilerGenerated]
		private sealed class <GetIndexNodes>d__5 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			public IndexPage <>4__this;

			private IEnumerator<byte> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <GetIndexNodes>d__5(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					IndexPage indexPage = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = indexPage.GetUsedIndexs().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						byte current = <>7__wrap1.Current;
						<>2__current = indexPage.GetIndexNode(current);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<GetIndexNodes>d__5 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetIndexNodes>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public IndexPage(PageBuffer buffer)
			: base(buffer)
		{
			Constants.ENSURE(base.PageType == PageType.Index, "page type must be index page");
			if (base.PageType != PageType.Index)
			{
				throw LiteException.InvalidPageType(PageType.Index, this);
			}
		}

		public IndexPage(PageBuffer buffer, uint pageID)
			: base(buffer, pageID, PageType.Index)
		{
		}

		public IndexNode GetIndexNode(byte index)
		{
			BufferSlice segment = Get(index);
			return new IndexNode(this, index, segment);
		}

		public IndexNode InsertIndexNode(byte slot, byte level, BsonValue key, PageAddress dataBlock, int bytesLength)
		{
			byte index;
			BufferSlice segment = Insert((ushort)bytesLength, out index);
			return new IndexNode(this, index, segment, slot, level, key, dataBlock);
		}

		public void DeleteIndexNode(byte index)
		{
			Delete(index);
		}

		[IteratorStateMachine(typeof(<GetIndexNodes>d__5))]
		public IEnumerable<IndexNode> GetIndexNodes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetIndexNodes>d__5(-2)
			{
				<>4__this = this
			};
		}

		public static byte FreeIndexSlot(int freeBytes)
		{
			Constants.ENSURE(freeBytes >= 0, "freeBytes must be positive");
			return (freeBytes < 1400) ? ((byte)1) : ((byte)0);
		}
	}
	internal sealed class VectorIndexPage : BasePage
	{
		[CompilerGenerated]
		private sealed class <GetNodes>d__5 : IEnumerable<VectorIndexNode>, IEnumerable, IEnumerator<VectorIndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private VectorIndexNode <>2__current;

			private int <>l__initialThreadId;

			public VectorIndexPage <>4__this;

			private IEnumerator<byte> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <GetNodes>d__5(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					VectorIndexPage vectorIndexPage = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = vectorIndexPage.GetUsedIndexs().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						byte current = <>7__wrap1.Current;
						<>2__current = vectorIndexPage.GetNode(current);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<VectorIndexNode> IEnumerable<VectorIndexNode>.GetEnumerator()
			{
				<GetNodes>d__5 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetNodes>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public VectorIndexPage(PageBuffer buffer)
			: base(buffer)
		{
			Constants.ENSURE(base.PageType == PageType.VectorIndex, "page type must be vector index page");
			if (base.PageType != PageType.VectorIndex)
			{
				throw LiteException.InvalidPageType(PageType.VectorIndex, this);
			}
		}

		public VectorIndexPage(PageBuffer buffer, uint pageID)
			: base(buffer, pageID, PageType.VectorIndex)
		{
		}

		public VectorIndexNode GetNode(byte index)
		{
			BufferSlice segment = Get(index);
			return new VectorIndexNode(this, index, segment);
		}

		public VectorIndexNode InsertNode(PageAddress dataBlock, float[] vector, int bytesLength, byte levelCount, PageAddress externalVector)
		{
			byte index;
			BufferSlice segment = Insert((ushort)bytesLength, out index);
			return new VectorIndexNode(this, index, segment, dataBlock, vector, levelCount, externalVector);
		}

		public void DeleteNode(byte index)
		{
			Delete(index);
		}

		[IteratorStateMachine(typeof(<GetNodes>d__5))]
		public IEnumerable<VectorIndexNode> GetNodes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetNodes>d__5(-2)
			{
				<>4__this = this
			};
		}

		public static byte FreeListSlot(int freeBytes)
		{
			Constants.ENSURE(freeBytes >= 0, "freeBytes must be positive");
			return (freeBytes < 1400) ? ((byte)1) : ((byte)0);
		}
	}
	internal static class Pragmas
	{
		public const string USER_VERSION = "USER_VERSION";

		public const string COLLATION = "COLLATION";

		public const string TIMEOUT = "TIMEOUT";

		public const string LIMIT_SIZE = "LIMIT_SIZE";

		public const string UTC_DATE = "UTC_DATE";

		public const string CHECKPOINT = "CHECKPOINT";
	}
	internal abstract class Index
	{
		public string Name { get; private set; }

		public int Order { get; set; }

		internal Index(string name, int order)
		{
			Name = name;
			Order = order;
		}

		public abstract uint GetCost(CollectionIndex index);

		public abstract IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index);

		public virtual IEnumerable<IndexNode> Run(CollectionPage col, IndexService indexer)
		{
			CollectionIndex collectionIndex = col.GetCollectionIndex(Name);
			if (collectionIndex == null)
			{
				throw LiteException.IndexNotFound(Name);
			}
			return Execute(indexer, collectionIndex).DistinctBy((IndexNode x) => x.DataBlock, null);
		}
	}
	internal class IndexAll : Index
	{
		public IndexAll(string name, int order)
			: base(name, order)
		{
		}

		public override uint GetCost(CollectionIndex index)
		{
			return 100u;
		}

		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			return indexer.FindAll(index, base.Order);
		}

		public override string ToString()
		{
			return $"FULL INDEX SCAN({base.Name})";
		}
	}
	internal class IndexEquals : Index
	{
		[CompilerGenerated]
		private sealed class <Execute>d__3 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			private IndexService indexer;

			public IndexService <>3__indexer;

			private CollectionIndex index;

			public CollectionIndex <>3__index;

			public IndexEquals <>4__this;

			private IndexNode <node>5__2;

			private IndexNode <first>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<node>5__2 = null;
				<first>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				IndexEquals indexEquals = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<node>5__2 = indexer.Find(index, indexEquals._value, sibling: false, 1);
					if (<node>5__2 == null)
					{
						return false;
					}
					<>2__current = <node>5__2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (index.Unique)
					{
						break;
					}
					<first>5__3 = <node>5__2;
					goto IL_00d3;
				case 2:
					<>1__state = -1;
					goto IL_00d3;
				case 3:
					{
						<>1__state = -1;
						goto IL_0181;
					}
					IL_00d3:
					if (!<node>5__2.Next[0].IsEmpty && (<node>5__2 = indexer.GetNode(<node>5__2.Next[0])).Key.CompareTo(indexEquals._value, indexer.Collation) == 0 && !<node>5__2.Key.IsMinValue && !<node>5__2.Key.IsMaxValue)
					{
						<>2__current = <node>5__2;
						<>1__state = 2;
						return true;
					}
					<node>5__2 = <first>5__3;
					goto IL_0181;
					IL_0181:
					if (!<node>5__2.Prev[0].IsEmpty && (<node>5__2 = indexer.GetNode(<node>5__2.Prev[0])).Key.CompareTo(indexEquals._value, indexer.Collation) == 0 && !<node>5__2.Key.IsMinValue && !<node>5__2.Key.IsMaxValue)
					{
						<>2__current = <node>5__2;
						<>1__state = 3;
						return true;
					}
					<first>5__3 = null;
					break;
				}
				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]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<Execute>d__3 <Execute>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Execute>d__ = this;
				}
				else
				{
					<Execute>d__ = new <Execute>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Execute>d__.indexer = <>3__indexer;
				<Execute>d__.index = <>3__index;
				return <Execute>d__;
			}

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

		private readonly BsonValue _value;

		public IndexEquals(string name, BsonValue value)
			: base(name, 1)
		{
			_value = value;
		}

		public override uint GetCost(CollectionIndex index)
		{
			if (index.Unique)
			{
				return 1u;
			}
			return 10u;
		}

		[IteratorStateMachine(typeof(<Execute>d__3))]
		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Execute>d__3(-2)
			{
				<>4__this = this,
				<>3__indexer = indexer,
				<>3__index = index
			};
		}

		public override string ToString()
		{
			return $"INDEX SEEK({base.Name} = {_value})";
		}
	}
	internal class IndexIn : Index
	{
		[CompilerGenerated]
		private sealed class <Execute>d__3 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			public IndexIn <>4__this;

			private IndexService indexer;

			public IndexService <>3__indexer;

			private CollectionIndex index;

			public CollectionIndex <>3__index;

			private IEnumerator<BsonValue> <>7__wrap1;

			private IEnumerator<IndexNode> <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					IndexIn indexIn = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_00b3;
					}
					<>1__state = -1;
					<>7__wrap1 = indexIn._values.Distinct().GetEnumerator();
					<>1__state = -3;
					goto IL_00cd;
					IL_00b3:
					if (<>7__wrap2.MoveNext())
					{
						IndexNode current = <>7__wrap2.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>7__wrap2 = null;
					goto IL_00cd;
					IL_00cd:
					if (<>7__wrap1.MoveNext())
					{
						BsonValue current2 = <>7__wrap1.Current;
						IndexEquals indexEquals = new IndexEquals(indexIn.Name, current2);
						<>7__wrap2 = indexEquals.Execute(indexer, index).GetEnumerator();
						<>1__state = -4;
						goto IL_00b3;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<Execute>d__3 <Execute>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Execute>d__ = this;
				}
				else
				{
					<Execute>d__ = new <Execute>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Execute>d__.indexer = <>3__indexer;
				<Execute>d__.index = <>3__index;
				return <Execute>d__;
			}

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

		private readonly BsonArray _values;

		public IndexIn(string name, BsonArray values, int order)
			: base(name, order)
		{
			_values = values;
		}

		public override uint GetCost(CollectionIndex index)
		{
			if (!index.Unique)
			{
				return (uint)(_values.Count * 10);
			}
			return (uint)_values.Count;
		}

		[IteratorStateMachine(typeof(<Execute>d__3))]
		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Execute>d__3(-2)
			{
				<>4__this = this,
				<>3__indexer = indexer,
				<>3__index = index
			};
		}

		public override string ToString()
		{
			return $"INDEX SEEK({base.Name} IN {JsonSerializer.Serialize(_values)})";
		}
	}
	internal class IndexLike : Index
	{
		[CompilerGenerated]
		private sealed class <ExecuteStartsWith>d__7 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			private IndexService indexer;

			public IndexService <>3__indexer;

			private CollectionIndex index;

			public CollectionIndex <>3__index;

			public IndexLike <>4__this;

			private IndexNode <first>5__2;

			private IndexNode <node>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<first>5__2 = null;
				<node>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				IndexLike indexLike = <>4__this;
				string text;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<first>5__2 = indexer.Find(index, indexLike._startsWith, sibling: true, indexLike.Order);
					<node>5__3 = <first>5__2;
					if (<first>5__2 == null)
					{
						return false;
					}
					goto IL_0172;
				case 1:
					<>1__state = -1;
					goto IL_014e;
				case 2:
					{
						<>1__state = -1;
						goto IL_02a1;
					}
					IL_02c4:
					if (<node>5__3 == null || <node>5__3.Key.IsMinValue || <node>5__3.Key.IsMaxValue)
					{
						break;
					}
					text = (<node>5__3.Key.IsString ? <node>5__3.Key.AsString : (<node>5__3.Key.IsNull ? "" : <node>5__3.Key.ToString()));
					if (!(indexLike._equals ? text.Equals(indexLike._pattern, StringComparison.OrdinalIgnoreCase) : text.StartsWith(indexLike._startsWith, StringComparison.OrdinalIgnoreCase)))
					{
						break;
					}
					if (!<node>5__3.DataBlock.IsEmpty && (!indexLike._testSqlLike || (indexLike._testSqlLike && text.SqlLike(indexLike._pattern, indexer.Collation))))
					{
						<>2__current = <node>5__3;
						<>1__state = 2;
						return true;
					}
					goto IL_02a1;
					IL_0172:
					if (<node>5__3 != null && !<node>5__3.Key.IsMinValue && !<node>5__3.Key.IsMaxValue)
					{
						string text2 = (<node>5__3.Key.IsString ? <node>5__3.Key.AsString : (<node>5__3.Key.IsNull ? "" : <node>5__3.Key.ToString()));
						if (indexLike._equals ? text2.Equals(indexLike._startsWith, StringComparison.OrdinalIgnoreCase) : text2.StartsWith(indexLike._startsWith, StringComparison.OrdinalIgnoreCase))
						{
							if (!indexLike._testSqlLike || (indexLike._testSqlLike && text2.SqlLike(indexLike._pattern, indexer.Collation)))
							{
								<>2__current = <node>5__3;
								<>1__state = 1;
								return true;
							}
							goto IL_014e;
						}
					}
					<node>5__3 = indexer.GetNode(<first>5__2.GetNextPrev(0, indexLike.Order));
					goto IL_02c4;
					IL_02a1:
					<node>5__3 = indexer.GetNode(<node>5__3.GetNextPrev(0, indexLike.Order));
					goto IL_02c4;
					IL_014e:
					<node>5__3 = indexer.GetNode(<node>5__3.GetNextPrev(0, -indexLike.Order));
					goto IL_0172;
				}
				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]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<ExecuteStartsWith>d__7 <ExecuteStartsWith>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ExecuteStartsWith>d__ = this;
				}
				else
				{
					<ExecuteStartsWith>d__ = new <ExecuteStartsWith>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<ExecuteStartsWith>d__.indexer = <>3__indexer;
				<ExecuteStartsWith>d__.index = <>3__index;
				return <ExecuteStartsWith>d__;
			}

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

		private readonly string _startsWith;

		private readonly bool _equals;

		private readonly bool _testSqlLike;

		private readonly string _pattern;

		public IndexLike(string name, BsonValue value, int order)
			: base(name, order)
		{
			_pattern = value.AsString;
			_startsWith = _pattern.SqlLikeStartsWith(out _testSqlLike);
			_equals = _pattern == _startsWith;
		}

		public override uint GetCost(CollectionIndex index)
		{
			if (_startsWith.Length > 0)
			{
				return 10u;
			}
			return 100u;
		}

		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			if (_startsWith.Length <= 0)
			{
				return ExecuteLike(indexer, index);
			}
			return ExecuteStartsWith(indexer, index);
		}

		[IteratorStateMachine(typeof(<ExecuteStartsWith>d__7))]
		private IEnumerable<IndexNode> ExecuteStartsWith(IndexService indexer, CollectionIndex index)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ExecuteStartsWith>d__7(-2)
			{
				<>4__this = this,
				<>3__indexer = indexer,
				<>3__index = index
			};
		}

		private IEnumerable<IndexNode> ExecuteLike(IndexService indexer, CollectionIndex index)
		{
			return from x in indexer.FindAll(index, base.Order)
				where x.Key.IsString && x.Key.AsString.SqlLike(_pattern, indexer.Collation)
				select x;
		}

		public override string ToString()
		{
			return string.Format("{0}({1} LIKE \"{2}\")", (_startsWith.Length > 0) ? "INDEX SEEK (+RANGE SCAN)" : "FULL INDEX SCAN", base.Name, _pattern);
		}
	}
	internal class IndexRange : Index
	{
		[CompilerGenerated]
		private sealed class <Execute>d__6 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			public IndexRange <>4__this;

			private IndexService indexer;

			public IndexService <>3__indexer;

			private CollectionIndex index;

			public CollectionIndex <>3__index;

			private BsonValue <start>5__2;

			private BsonValue <end>5__3;

			private bool <startEquals>5__4;

			private bool <endEquals>5__5;

			private IndexNode <first>5__6;

			private IndexNode <node>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<start>5__2 = null;
				<end>5__3 = null;
				<first>5__6 = null;
				<node>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				IndexRange indexRange = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<start>5__2 = ((indexRange.Order == 1) ? indexRange._start : indexRange._end);
					<end>5__3 = ((indexRange.Order == 1) ? indexRange._end : indexRange._start);
					<startEquals>5__4 = ((indexRange.Order == 1) ? indexRange._startEquals : indexRange._endEquals);
					<endEquals>5__5 = ((indexRange.Order == 1) ? indexRange._endEquals : indexRange._startEquals);
					<first>5__6 = ((<start>5__2.Type == BsonType.MinValue) ? indexer.GetNode(index.Head) : ((<start>5__2.Type == BsonType.MaxValue) ? indexer.GetNode(index.Tail) : indexer.Find(index, <start>5__2, sibling: true, indexRange.Order)));
					<node>5__7 = <first>5__6;
					if (<startEquals>5__4 && <node>5__7 != null)
					{
						goto IL_017c;
					}
					goto IL_0277;
				case 1:
					<>1__state = -1;
					goto IL_017c;
				case 2:
					<>1__state = -1;
					goto IL_0254;
				case 3:
					<>1__state = -1;
					goto IL_0343;
				case 4:
					{
						<>1__state = -1;
						goto IL_0343;
					}
					IL_0343:
					<node>5__7 = indexer.GetNode(<node>5__7.GetNextPrev(0, indexRange.Order));
					break;
					IL_0254:
					<node>5__7 = indexer.GetNode(<node>5__7.GetNextPrev(0, indexRange.Order));
					goto IL_0277;
					IL_0277:
					if (<node>5__7 == null || <node>5__7.Key.CompareTo(<start>5__2, indexer.Collation) != 0)
					{
						break;
					}
					if (<startEquals>5__4 && !<node>5__7.Key.IsMinValue && !<node>5__7.Key.IsMaxValue)
					{
						<>2__current = <node>5__7;
						<>1__state = 2;
						return true;
					}
					goto IL_0254;
					IL_017c:
					if (!<node>5__7.GetNextPrev(0, -indexRange.Order).IsEmpty && (<node>5__7 = indexer.GetNode(<node>5__7.GetNextPrev(0, -indexRange.Order))).Key.CompareTo(<start>5__2) == 0 && !<node>5__7.Key.IsMinValue && !<node>5__7.Key.IsMaxValue)
					{
						<>2__current = <node>5__7;
						<>1__state = 1;
						return true;
					}
					<node>5__7 = <first>5__6;
					goto IL_0277;
				}
				if (<node>5__7 != null)
				{
					int num2 = <node>5__7.Key.CompareTo(<end>5__3, indexer.Collation);
					if (<endEquals>5__5 && num2 == 0 && !<node>5__7.Key.IsMinValue && !<node>5__7.Key.IsMaxValue)
					{
						<>2__current = <node>5__7;
						<>1__state = 3;
						return true;
					}
					if (num2 == -indexRange.Order && !<node>5__7.Key.IsMinValue && !<node>5__7.Key.IsMaxValue)
					{
						<>2__current = <node>5__7;
						<>1__state = 4;
						return true;
					}
				}
				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]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<Execute>d__6 <Execute>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Execute>d__ = this;
				}
				else
				{
					<Execute>d__ = new <Execute>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<Execute>d__.indexer = <>3__indexer;
				<Execute>d__.index = <>3__index;
				return <Execute>d__;
			}

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

		private readonly BsonValue _start;

		private readonly BsonValue _end;

		private readonly bool _startEquals;

		private readonly bool _endEquals;

		public IndexRange(string name, BsonValue start, BsonValue end, bool startEquals, bool endEquals, int order)
			: base(name, order)
		{
			_start = start;
			_end = end;
			_startEquals = startEquals;
			_endEquals = endEquals;
		}

		public override uint GetCost(CollectionIndex index)
		{
			return 20u;
		}

		[IteratorStateMachine(typeof(<Execute>d__6))]
		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Execute>d__6(-2)
			{
				<>4__this = this,
				<>3__indexer = indexer,
				<>3__index = index
			};
		}

		public override string ToString()
		{
			if (_start.IsMinValue && !_endEquals)
			{
				return $"INDEX SCAN({base.Name} < {_end})";
			}
			if (_start.IsMinValue && _endEquals)
			{
				return $"INDEX SCAN({base.Name} <= {_end})";
			}
			if (_end.IsMaxValue && !_startEquals)
			{
				return $"INDEX SCAN({base.Name} > {_start})";
			}
			if (_end.IsMaxValue && _startEquals)
			{
				return $"INDEX SCAN({base.Name} >= {_start})";
			}
			return $"INDEX RANGE SCAN({base.Name} BETWEEN {_start} AND {_end})";
		}
	}
	internal class IndexScan : Index
	{
		private readonly Func<BsonValue, bool> _func;

		public IndexScan(string name, Func<BsonValue, bool> func, int order)
			: base(name, order)
		{
			_func = func;
		}

		public override uint GetCost(CollectionIndex index)
		{
			return 80u;
		}

		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			return from i in indexer.FindAll(index, base.Order)
				where _func(i.Key)
				select i;
		}

		public override string ToString()
		{
			return $"FULL INDEX SCAN({base.Name})";
		}
	}
	internal class IndexVirtual : Index, IDocumentLookup
	{
		[CompilerGenerated]
		private sealed class <Run>d__5 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			public IndexVirtual <>4__this;

			private uint <rawId>5__2;

			private IEnumerator<BsonDocument> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <Run>d__5(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();
					}
				}
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					IndexVirtual indexVirtual = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<rawId>5__2 = 0u;
						<>7__wrap2 = indexVirtual._source.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap2.MoveNext())
					{
						BsonDocument current = <>7__wrap2.Current;
						<rawId>5__2++;
						current.RawId = new PageAddress(<rawId>5__2, 0);
						if (indexVirtual._cache != null)
						{
							indexVirtual._cache[<rawId>5__2] = current;
							if (indexVirtual._cache.Count > 2000)
							{
								indexVirtual._cache = null;
							}
						}
						<>2__current = new IndexNode(current);
						<>1__state = 1;
						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<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<Run>d__5 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <Run>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private readonly IEnumerable<BsonDocument> _source;

		private Dictionary<uint, BsonDocument> _cache = new Dictionary<uint, BsonDocument>();

		public IndexVirtual(IEnumerable<BsonDocument> source)
			: base(null, 0)
		{
			_source = source;
		}

		public override uint GetCost(CollectionIndex index)
		{
			return 100u;
		}

		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			throw new NotImplementedException();
		}

		[IteratorStateMachine(typeof(<Run>d__5))]
		public override IEnumerable<IndexNode> Run(CollectionPage col, IndexService indexer)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Run>d__5(-2)
			{
				<>4__this = this
			};
		}

		public BsonDocument Load(IndexNode node)
		{
			return node.Key as BsonDocument;
		}

		public BsonDocument Load(PageAddress rawId)
		{
			if (_cache == null)
			{
				throw new LiteException(0, $"OrderBy/GroupBy operation are supported only in virtual collection with less than {2000} documents");
			}
			return _cache[rawId.PageID];
		}

		public override string ToString()
		{
			return $"FULL COLLECTION SCAN";
		}
	}
	internal sealed class VectorIndexQuery : Index, IDocumentLookup
	{
		[CompilerGenerated]
		private sealed class <Run>d__13 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			public VectorIndexQuery <>4__this;

			private (BsonDocument Document, double Distance)[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				VectorIndexQuery vectorIndexQuery = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00cc;
				}
				<>1__state = -1;
				vectorIndexQuery._cache.Clear();
				(BsonDocument, double)[] array = new VectorIndexService(vectorIndexQuery._snapshot, vectorIndexQuery._collation).Search(vectorIndexQuery._metadata, vectorIndexQuery._target, vectorIndexQuery._maxDistance, vectorIndexQuery._limit).ToArray();
				<>7__wrap1 = array;
				<>7__wrap2 = 0;
				goto IL_00da;
				IL_00cc:
				<>7__wrap2++;
				goto IL_00da;
				IL_00da:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					(BsonDocument, double) tuple = <>7__wrap1[<>7__wrap2];
					PageAddress rawId = tuple.Item1.RawId;
					if (!rawId.IsEmpty)
					{
						vectorIndexQuery._cache[rawId] = tuple.Item1;
						<>2__current = new IndexNode(tuple.Item1);
						<>1__state = 1;
						return true;
					}
					goto IL_00cc;
				}
				<>7__wrap1 = null;
				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]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<Run>d__13 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <Run>d__13(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private readonly Snapshot _snapshot;

		private readonly CollectionIndex _index;

		private readonly VectorIndexMetadata _metadata;

		private readonly float[] _target;

		private readonly double _maxDistance;

		private readonly int? _limit;

		private readonly Collation _collation;

		private readonly Dictionary<PageAddress, BsonDocument> _cache = new Dictionary<PageAddress, BsonDocument>();

		public string Expression => _index.Expression;

		public VectorIndexQuery(string name, Snapshot snapshot, CollectionIndex index, VectorIndexMetadata metadata, float[] target, double maxDistance, int? limit, Collation collation)
			: base(name, 1)
		{
			_snapshot = snapshot;
			_index = index;
			_metadata = metadata;
			_target = target;
			_maxDistance = maxDistance;
			_limit = limit;
			_collation = collation;
		}

		public override uint GetCost(CollectionIndex index)
		{
			return 1u;
		}

		public override IEnumerable<IndexNode> Execute(IndexService indexer, CollectionIndex index)
		{
			throw new NotSupportedException();
		}

		[IteratorStateMachine(typeof(<Run>d__13))]
		public override IEnumerable<IndexNode> Run(CollectionPage col, IndexService indexer)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Run>d__13(-2)
			{
				<>4__this = this
			};
		}

		public BsonDocument Load(IndexNode node)
		{
			return node.Key as BsonDocument;
		}

		public BsonDocument Load(PageAddress rawId)
		{
			if (!_cache.TryGetValue(rawId, out var value))
			{
				return null;
			}
			return value;
		}

		public override string ToString()
		{
			return "VECTOR INDEX SEARCH";
		}
	}
	internal class DatafileLookup : IDocumentLookup
	{
		protected readonly DataService _data;

		protected readonly bool _utcDate;

		protected readonly HashSet<string> _fields;

		public DatafileLookup(DataService data, bool utcDate, HashSet<string> fields)
		{
			_data = data;
			_utcDate = utcDate;
			_fields = fields;
		}

		public virtual BsonDocument Load(IndexNode node)
		{
			Constants.ENSURE(node.DataBlock != PageAddress.Empty, "data block must be a valid block address");
			return Load(node.DataBlock);
		}

		public virtual BsonDocument Load(PageAddress rawId)
		{
			using BufferReader bufferReader = new BufferReader(_data.Read(rawId), _utcDate);
			BsonDocument value = bufferReader.ReadDocument(_fields).GetValue();
			value.RawId = rawId;
			return value;
		}
	}
	internal interface IDocumentLookup
	{
		BsonDocument Load(IndexNode node);

		BsonDocument Load(PageAddress rawId);
	}
	internal class IndexLookup : IDocumentLookup
	{
		private readonly IndexService _indexer;

		private readonly string _name;

		public IndexLookup(IndexService indexer, string name)
		{
			_indexer = indexer;
			_name = name;
		}

		public BsonDocument Load(IndexNode node)
		{
			Constants.ENSURE(!node.DataBlock.IsEmpty, "Never should be empty rawid");
			return new BsonDocument
			{
				[_name] = node.Key,
				RawId = node.DataBlock
			};
		}

		public BsonDocument Load(PageAddress rawId)
		{
			IndexNode node = _indexer.GetNode(rawId);
			return Load(node);
		}
	}
	internal abstract class BasePipe
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public BasePipe <>4__this;

			public IReadOnlyList<OrderByItem> segments;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_1
		{
			public OrderByItem segment;

			public <>c__DisplayClass10_0 CS$<>8__locals1;

			internal KeyValuePair<BsonValue, PageAddress> <OrderBy>b__0(BsonDocument doc)
			{
				return new KeyValuePair<BsonValue, PageAddress>(segment.Expression.ExecuteScalar(doc, CS$<>8__locals1.<>4__this._pragmas.Collation), doc.RawId);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_2
		{
			public int[] orders;

			public <>c__DisplayClass10_0 CS$<>8__locals2;

			internal KeyValuePair<BsonValue, PageAddress> <OrderBy>b__2(BsonDocument doc)
			{
				BsonValue[] array = new BsonValue[CS$<>8__locals2.segments.Count];
				for (int i = 0; i < CS$<>8__locals2.segments.Count; i++)
				{
					array[i] = CS$<>8__locals2.segments[i].Expression.ExecuteScalar(doc, CS$<>8__locals2.<>4__this._pragmas.Collation);
				}
				return new KeyValuePair<BsonValue, PageAddress>(SortKey.FromValues(array, orders), doc.RawId);
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass8_0
		{
			public string last;

			public Snapshot snapshot;

			public BasePipe <>4__this;

			public IndexService indexer;

			public DataService data;

			public IDocumentLookup lookup;

			public CollectionIndex index;
		}

		[CompilerGenerated]
		private sealed class <Filter>d__9 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			private BsonExpression expr;

			public BsonExpression <>3__expr;

			public BasePipe <>4__this;

			private IEnumerator<BsonDocument> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <Filter>d__9(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BasePipe basePipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = source.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						BsonDocument current = <>7__wrap1.Current;
						BsonValue bsonValue = expr.ExecuteScalar(current, basePipe._pragmas.Collation);
						if (bsonValue.IsBoolean && bsonValue.AsBoolean)
						{
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Filter>d__9 <Filter>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Filter>d__ = this;
				}
				else
				{
					<Filter>d__ = new <Filter>d__9(0)
					{
						<>4__this = <>4__this
					};
				}
				<Filter>d__.source = <>3__source;
				<Filter>d__.expr = <>3__expr;
				return <Filter>d__;
			}

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

		[CompilerGenerated]
		private sealed class <Include>d__8 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public BasePipe <>4__this;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			private BsonExpression path;

			public BsonExpression <>3__path;

			private <>c__DisplayClass8_0 <>8__1;

			private IEnumerator<BsonDocument> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <Include>d__8(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 = default(<>c__DisplayClass8_0);
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BasePipe basePipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1.<>4__this = <>4__this;
						<>8__1.last = null;
						<>8__1.snapshot = null;
						<>8__1.indexer = null;
						<>8__1.data = null;
						<>8__1.index = null;
						<>8__1.lookup = null;
						<>7__wrap1 = source.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						BsonDocument current = <>7__wrap1.Current;
						foreach (BsonValue item in (from x in path.Execute(current, basePipe._pragmas.Collation)
							where x.IsDocument || x.IsArray
							select x).ToList())
						{
							if (item.IsDocument)
							{
								basePipe.<Include>g__DoInclude|8_0(item.AsDocument, ref <>8__1);
								continue;
							}
							foreach (BsonDocument item2 in from x in item.AsArray
								where x.IsDocument
								select x.AsDocument)
							{
								basePipe.<Include>g__DoInclude|8_0(item2, ref <>8__1);
							}
						}
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Include>d__8 <Include>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Include>d__ = this;
				}
				else
				{
					<Include>d__ = new <Include>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				<Include>d__.source = <>3__source;
				<Include>d__.path = <>3__path;
				return <Include>d__;
			}

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

		[CompilerGenerated]
		private sealed class <LoadDocument>d__7 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<IndexNode> nodes;

			public IEnumerable<IndexNode> <>3__nodes;

			public BasePipe <>4__this;

			private IEnumerator<IndexNode> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <LoadDocument>d__7(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();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BasePipe basePipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = nodes.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						basePipe._transaction.Safepoint();
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						IndexNode current = <>7__wrap1.Current;
						<>2__current = basePipe._lookup.Load(current);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<LoadDocument>d__7 <LoadDocument>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<LoadDocument>d__ = this;
				}
				else
				{
					<LoadDocument>d__ = new <LoadDocument>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<LoadDocument>d__.nodes = <>3__nodes;
				return <LoadDocument>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OrderBy>d__10 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public BasePipe <>4__this;

			private OrderBy orderBy;

			public OrderBy <>3__orderBy;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			private int offset;

			public int <>3__offset;

			private int limit;

			public int <>3__limit;

			private SortService <sorter>5__2;

			private IEnumerator<KeyValuePair<BsonValue, PageAddress>> <>7__wrap2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				switch (num)
				{
				case -4:
				case -3:
				case 1:
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -6:
				case -5:
				case 2:
					try
					{
						if (num == -6 || num == 2)
						{
							try
							{
							}
							finally
							{
								<>m__Finally4();
							}
						}
					}
					finally
					{
						<>m__Finally3();
					}
					break;
				}
				<sorter>5__2 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					BasePipe basePipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<>c__DisplayClass10_0 <>c__DisplayClass10_ = new <>c__DisplayClass10_0
						{
							<>4__this = <>4__this,
							segments = orderBy.Segments
						};
						if (<>c__DisplayClass10_.segments.Count == 1)
						{
							<>c__DisplayClass10_1 CS$<>8__locals0 = new <>c__DisplayClass10_1();
							CS$<>8__locals0.CS$<>8__locals1 = <>c__DisplayClass10_;
							CS$<>8__locals0.segment = CS$<>8__locals0.CS$<>8__locals1.segments[0];
							IEnumerable<KeyValuePair<BsonValue, PageAddress>> items = source.Select((BsonDocument doc) => new KeyValuePair<BsonValue, PageAddress>(CS$<>8__locals0.segment.Expression.ExecuteScalar(doc, CS$<>8__locals0.CS$<>8__locals1.<>4__this._pragmas.Collation), doc.RawId));
							<sorter>5__2 = new SortService(basePipe._tempDisk, new int[1] { CS$<>8__locals0.segment.Order }, basePipe._pragmas);
							<>1__state = -3;
							<sorter>5__2.Insert(items);
							IEnumerable<KeyValuePair<BsonValue, PageAddress>> enumerable = <sorter>5__2.Sort().Skip(offset).Take(limit);
							<>7__wrap2 = enumerable.GetEnumerator();
							<>1__state = -4;
							goto IL_015e;
						}
						<>c__DisplayClass10_2 CS$<>8__locals1 = new <>c__DisplayClass10_2();
						CS$<>8__locals1.CS$<>8__locals2 = <>c__DisplayClass10_;
						CS$<>8__locals1.orders = CS$<>8__locals1.CS$<>8__locals2.segments.Select((OrderByItem x) => x.Order).ToArray();
						IEnumerable<KeyValuePair<BsonValue, PageAddress>> items2 = source.Select(delegate(BsonDocument doc)
						{
							BsonValue[] array = new BsonValue[CS$<>8__locals1.CS$<>8__locals2.segments.Count];
							for (int i = 0; i < CS$<>8__locals1.CS$<>8__locals2.segments.Count; i++)
							{
								array[i] = CS$<>8__locals1.CS$<>8__locals2.segments[i].Expression.ExecuteScalar(doc, CS$<>8__locals1.CS$<>8__locals2.<>4__this._pragmas.Collation);
							}
							return new KeyValuePair<BsonValue, PageAddress>(SortKey.FromValues(array, CS$<>8__locals1.orders), doc.RawId);
						});
						<sorter>5__2 = new SortService(basePipe._tempDisk, CS$<>8__locals1.orders, basePipe._pragmas);
						<>1__state = -5;
						<sorter>5__2.Insert(items2);
						IEnumerable<KeyValuePair<BsonValue, PageAddress>> enumerable2 = <sorter>5__2.Sort().Skip(offset).Take(limit);
						<>7__wrap2 = enumerable2.GetEnumerator();
						<>1__state = -6;
						goto IL_0298;
					}
					case 1:
						<>1__state = -4;
						goto IL_015e;
					case 2:
						{
							<>1__state = -6;
							goto IL_0298;
						}
						IL_015e:
						if (<>7__wrap2.MoveNext())
						{
							KeyValuePair<BsonValue, PageAddress> current = <>7__wrap2.Current;
							BsonDocument bsonDocument = basePipe._lookup.Load(current.Value);
							<>2__current = bsonDocument;
							<>1__state = 1;
							return true;
						}
						<>m__Finally2();
						<>7__wrap2 = null;
						<>m__Finally1();
						<sorter>5__2 = null;
						break;
						IL_0298:
						if (<>7__wrap2.MoveNext())
						{
							KeyValuePair<BsonValue, PageAddress> current2 = <>7__wrap2.Current;
							BsonDocument bsonDocument2 = basePipe._lookup.Load(current2.Value);
							<>2__current = bsonDocument2;
							<>1__state = 2;
							return true;
						}
						<>m__Finally4();
						<>7__wrap2 = null;
						<>m__Finally3();
						<sorter>5__2 = null;
						break;
					}
					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 (<sorter>5__2 != null)
				{
					((IDisposable)<sorter>5__2).Dispose();
				}
			}

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

			private void <>m__Finally3()
			{
				<>1__state = -1;
				if (<sorter>5__2 != null)
				{
					((IDisposable)<sorter>5__2).Dispose();
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<OrderBy>d__10 <OrderBy>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OrderBy>d__ = this;
				}
				else
				{
					<OrderBy>d__ = new <OrderBy>d__10(0)
					{
						<>4__this = <>4__this
					};
				}
				<OrderBy>d__.source = <>3__source;
				<OrderBy>d__.orderBy = <>3__orderBy;
				<OrderBy>d__.offset = <>3__offset;
				<OrderBy>d__.limit = <>3__limit;
				return <OrderBy>d__;
			}

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

		protected readonly TransactionService _transaction;

		protected readonly IDocumentLookup _lookup;

		protected readonly SortDisk _tempDisk;

		protected readonly EnginePragmas _pragmas;

		protected readonly uint _maxItemsCount;

		public BasePipe(TransactionService transaction, IDocumentLookup lookup, SortDisk tempDisk, EnginePragmas pragmas, uint maxItemsCount)
		{
			_transaction = transaction;
			_lookup = lookup;
			_tempDisk = tempDisk;
			_pragmas = pragmas;
			_maxItemsCount = maxItemsCount;
		}

		public abstract IEnumerable<BsonDocument> Pipe(IEnumerable<IndexNode> nodes, QueryPlan query);

		[IteratorStateMachine(typeof(<LoadDocument>d__7))]
		protected IEnumerable<BsonDocument> LoadDocument(IEnumerable<IndexNode> nodes)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadDocument>d__7(-2)
			{
				<>4__this = this,
				<>3__nodes = nodes
			};
		}

		[IteratorStateMachine(typeof(<Include>d__8))]
		protected IEnumerable<BsonDocument> Include(IEnumerable<BsonDocument> source, BsonExpression path)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Include>d__8(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__path = path
			};
		}

		[IteratorStateMachine(typeof(<Filter>d__9))]
		protected IEnumerable<BsonDocument> Filter(IEnumerable<BsonDocument> source, BsonExpression expr)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Filter>d__9(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__expr = expr
			};
		}

		[IteratorStateMachine(typeof(<OrderBy>d__10))]
		protected IEnumerable<BsonDocument> OrderBy(IEnumerable<BsonDocument> source, OrderBy orderBy, int offset, int limit)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OrderBy>d__10(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__orderBy = orderBy,
				<>3__offset = offset,
				<>3__limit = limit
			};
		}

		[CompilerGenerated]
		private void <Include>g__DoInclude|8_0(BsonDocument value, ref <>c__DisplayClass8_0 P_1)
		{
			BsonValue bsonValue = value["$id"];
			BsonValue bsonValue2 = value["$ref"];
			if (bsonValue.IsNull || !bsonValue2.IsString)
			{
				return;
			}
			if (P_1.last != bsonValue2.AsString)
			{
				P_1.last = bsonValue2.AsString;
				P_1.snapshot = _transaction.CreateSnapshot(LockMode.Read, P_1.last, addIfNotExists: false);
				P_1.indexer = new IndexService(P_1.snapshot, _pragmas.Collation, _maxItemsCount);
				P_1.data = new DataService(P_1.snapshot, _maxItemsCount);
				P_1.lookup = new DatafileLookup(P_1.data, _pragmas.UtcDate, null);
				P_1.index = P_1.snapshot.CollectionPage?.PK;
			}
			if (P_1.index == null)
			{
				return;
			}
			IndexNode indexNode = P_1.indexer.Find(P_1.index, bsonValue, sibling: false, 1);
			if (indexNode != null)
			{
				BsonDocument source = P_1.lookup.Load(indexNode);
				value.Remove("$ref");
				{
					foreach (KeyValuePair<string, BsonValue> item in source.Where((KeyValuePair<string, BsonValue> x) => x.Key != "_id"))
					{
						value[item.Key] = item.Value;
					}
					return;
				}
			}
			value["$missing"] = true;
		}
	}
	internal class DocumentCacheEnumerable : IEnumerable<BsonDocument>, IEnumerable, IDisposable
	{
		[CompilerGenerated]
		private sealed class <GetEnumerator>d__5 : IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			public DocumentCacheEnumerable <>4__this;

			private int <index>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				DocumentCacheEnumerable documentCacheEnumerable = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<index>5__2 = 0;
					goto IL_007a;
				case 1:
					<>1__state = -1;
					<index>5__2++;
					goto IL_007a;
				case 2:
					<>1__state = -1;
					<index>5__2++;
					goto IL_00f3;
				case 3:
					{
						<>1__state = -1;
						<index>5__2++;
						break;
					}
					IL_007a:
					if (<index>5__2 < documentCacheEnumerable._cache.Count)
					{
						PageAddress rawId = documentCacheEnumerable._cache[<index>5__2];
						<>2__current = documentCacheEnumerable._lookup.Load(rawId);
						<>1__state = 1;
						return true;
					}
					goto IL_00f3;
					IL_00f3:
					if (documentCacheEnumerable._enumerator != null && documentCacheEnumerable._enumerator.MoveNext())
					{
						BsonDocument current = documentCacheEnumerable._enumerator.Current;
						Constants.ENSURE(!current.RawId.IsEmpty, "rawId must have a valid value");
						documentCacheEnumerable._cache.Add(current.RawId);
						<>2__current = current;
						<>1__state = 2;
						return true;
					}
					if (documentCacheEnumerable._enumerator != null)
					{
						documentCacheEnumerable._enumerator.Dispose();
						documentCacheEnumerable._enumerator = null;
					}
					break;
				}
				if (<index>5__2 < documentCacheEnumerable._cache.Count)
				{
					PageAddress rawId2 = documentCacheEnumerable._cache[<index>5__2];
					<>2__current = documentCacheEnumerable._lookup.Load(rawId2);
					<>1__state = 3;
					return true;
				}
				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();
			}
		}

		private IEnumerator<BsonDocument> _enumerator;

		private readonly List<PageAddress> _cache = new List<PageAddress>();

		private readonly IDocumentLookup _lookup;

		public DocumentCacheEnumerable(IEnumerable<BsonDocument> source, IDocumentLookup lookup)
		{
			_enumerator = source.GetEnumerator();
			_lookup = lookup;
		}

		public void Dispose()
		{
			if (_enumerator != null)
			{
				while (_enumerator.MoveNext())
				{
				}
				_enumerator.Dispose();
				_enumerator = null;
			}
		}

		[IteratorStateMachine(typeof(<GetEnumerator>d__5))]
		public IEnumerator<BsonDocument> GetEnumerator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetEnumerator>d__5(0)
			{
				<>4__this = this
			};
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal class GroupByPipe : BasePipe
	{
		private readonly struct GroupSource
		{
			public BsonValue Key { get; }

			public DocumentCacheEnumerable Documents { get; }

			public GroupSource(BsonValue key, DocumentCacheEnumerable documents)
			{
				Key = key;
				Documents = documents;
			}
		}

		private readonly struct GroupedResult
		{
			public BsonValue Key { get; }

			public BsonDocument Document { get; }

			public BsonValue[] OrderValues { get; }

			public GroupedResult(BsonValue key, BsonDocument document, BsonValue[] orderValues)
			{
				Key = key;
				Document = document;
				OrderValues = orderValues;
			}
		}

		[CompilerGenerated]
		private sealed class <GroupBy>d__3 : IEnumerable<GroupSource>, IEnumerable, IEnumerator<GroupSource>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private GroupSource <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			private GroupBy groupBy;

			public GroupBy <>3__groupBy;

			public GroupByPipe <>4__this;

			private IEnumerator<BsonDocument> <enumerator>5__2;

			private Done <done>5__3;

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

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

			[DebuggerHidden]
			public <GroupBy>d__3(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();
					}
				}
				<enumerator>5__2 = null;
				<done>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					GroupByPipe groupByPipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<enumerator>5__2 = source.GetEnumerator();
						<>1__state = -3;
						<done>5__3 = new Done
						{
							Running = <enumerator>5__2.MoveNext()
						};
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<done>5__3.Running)
					{
						BsonValue key = groupBy.Expression.ExecuteScalar(<enumerator>5__2.Current, groupByPipe._pragmas.Collation);
						IEnumerable<BsonDocument> enumerable = groupByPipe.YieldDocuments(key, <enumerator>5__2, groupBy, <done>5__3);
						<>2__current = new GroupSource(key, new DocumentCacheEnumerable(enumerable, groupByPipe._lookup));
						<>1__state = 1;
						return true;
					}
					<done>5__3 = null;
					<>m__Finally1();
					<enumerator>5__2 = 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 (<enumerator>5__2 != null)
				{
					<enumerator>5__2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<GroupSource> IEnumerable<GroupSource>.GetEnumerator()
			{
				<GroupBy>d__3 <GroupBy>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GroupBy>d__ = this;
				}
				else
				{
					<GroupBy>d__ = new <GroupBy>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<GroupBy>d__.source = <>3__source;
				<GroupBy>d__.groupBy = <>3__groupBy;
				return <GroupBy>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OrderGroupedResult>d__8 : IEnumerable<GroupedResult>, IEnumerable, IEnumerator<GroupedResult>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private GroupedResult <>2__current;

			private int <>l__initialThreadId;

			private OrderBy orderBy;

			public OrderBy <>3__orderBy;

			private IEnumerable<GroupedResult> source;

			public IEnumerable<GroupedResult> <>3__source;

			public GroupByPipe <>4__this;

			private int offset;

			public int <>3__offset;

			private int limit;

			public int <>3__limit;

			private int <skipped>5__2;

			private int <returned>5__3;

			private List<(SortKey Key, GroupedResult Result)>.Enumerator <>7__wrap3;

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

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

			[DebuggerHidden]
			public <OrderGroupedResult>d__8(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();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					int num = <>1__state;
					GroupByPipe CS$<>8__locals0 = <>4__this;
					switch (num)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						IReadOnlyList<OrderByItem> segments = orderBy.Segments;
						int[] orders = segments.Select((OrderByItem x) => x.Order).ToArray();
						List<(SortKey, GroupedResult)> list = new List<(SortKey, GroupedResult)>();
						foreach (GroupedResult item2 in source)
						{
							BsonValue[] array = item2.OrderValues ?? new BsonValue[segments.Count];
							if (item2.OrderValues == null)
							{
								for (int i = 0; i < segments.Count; i++)
								{
									BsonExpression expression = segments[i].Expression;
									SetKeyParameter(expression, item2.Key);
									array[i] = expression.ExecuteScalar(item2.Document, CS$<>8__locals0._pragmas.Collation);
								}
							}
							SortKey item = SortKey.FromValues(array, orders);
							list.Add((item, item2));
						}
						list.Sort(((SortKey Key, GroupedResult Result) left, (SortKey Key, GroupedResult Result) right) => left.Key.CompareTo(right.Key, CS$<>8__locals0._pragmas.Collation));
						<skipped>5__2 = 0;
						<returned>5__3 = 0;
						<>7__wrap3 = list.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						<returned>5__3++;
						if (limit == int.MaxValue || <returned>5__3 < limit)
						{
							break;
						}
						result = false;
						<>m__Finally1();
						goto end_IL_0000;
					}
					while (true)
					{
						if (<>7__wrap3.MoveNext())
						{
							(SortKey, GroupedResult) current2 = <>7__wrap3.Current;
							if (<skipped>5__2 < offset)
							{
								<skipped>5__2++;
								continue;
							}
							<>2__current = current2.Item2;
							<>1__state = 1;
							result = true;
							break;
						}
						<>m__Finally1();
						result = false;
						break;
					}
					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__wrap3).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<GroupedResult> IEnumerable<GroupedResult>.GetEnumerator()
			{
				<OrderGroupedResult>d__8 <OrderGroupedResult>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OrderGroupedResult>d__ = this;
				}
				else
				{
					<OrderGroupedResult>d__ = new <OrderGroupedResult>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				<OrderGroupedResult>d__.source = <>3__source;
				<OrderGroupedResult>d__.orderBy = <>3__orderBy;
				<OrderGroupedResult>d__.offset = <>3__offset;
				<OrderGroupedResult>d__.limit = <>3__limit;
				return <OrderGroupedResult>d__;
			}

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

		[CompilerGenerated]
		private sealed class <SelectGroupBy>d__7 : IEnumerable<GroupedResult>, IEnumerable, IEnumerator<GroupedResult>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private GroupedResult <>2__current;

			private int <>l__initialThreadId;

			private GroupBy groupBy;

			public GroupBy <>3__groupBy;

			private IEnumerable<GroupSource> groups;

			public IEnumerable<GroupSource> <>3__groups;

			public GroupByPipe <>4__this;

			private OrderBy resultOrderBy;

			public OrderBy <>3__resultOrderBy;

			private string <defaultName>5__2;

			private IEnumerator<GroupSource> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <SelectGroupBy>d__7(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();
					}
				}
				<defaultName>5__2 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					GroupByPipe groupByPipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<defaultName>5__2 = groupBy.Select.DefaultFieldName();
						<>7__wrap2 = groups.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap2.MoveNext())
					{
						GroupSource current = <>7__wrap2.Current;
						BsonValue key = current.Key;
						DocumentCacheEnumerable documents = current.Documents;
						SetKeyParameter(groupBy.Select, key);
						SetKeyParameter(groupBy.Having, key);
						BsonDocument bsonDocument = null;
						BsonValue[] array = null;
						try
						{
							if (groupBy.Having == null)
							{
								goto IL_00e7;
							}
							BsonValue bsonValue = groupBy.Having.ExecuteScalar(documents, null, null, groupByPipe._pragmas.Collation);
							if (bsonValue.IsBoolean && bsonValue.AsBoolean)
							{
								goto IL_00e7;
							}
							goto end_IL_00a2;
							IL_00e7:
							BsonValue bsonValue2;
							if (groupBy.Select == BsonExpression.Root)
							{
								BsonArray bsonArray = new BsonArray();
								foreach (BsonDocument item in documents)
								{
									bsonArray.Add(item);
								}
								bsonValue2 = new BsonDocument
								{
									["key"] = key,
									["items"] = bsonArray
								};
							}
							else
							{
								bsonValue2 = groupBy.Select.ExecuteScalar(documents, null, null, groupByPipe._pragmas.Collation);
							}
							bsonDocument = ((!bsonValue2.IsDocument) ? new BsonDocument { [<defaultName>5__2] = bsonValue2 } : bsonValue2.AsDocument);
							if (resultOrderBy != null)
							{
								IReadOnlyList<OrderByItem> segments = resultOrderBy.Segments;
								array = new BsonValue[segments.Count];
								for (int i = 0; i < segments.Count; i++)
								{
									BsonExpression expression = segments[i].Expression;
									SetKeyParameter(expression, key);
									array[i] = expression.ExecuteScalar(documents, bsonDocument, null, groupByPipe._pragmas.Collation);
								}
							}
							goto IL_021d;
							end_IL_00a2:;
						}
						finally
						{
							documents.Dispose();
						}
						continue;
						IL_021d:
						<>2__current = new GroupedResult(key, bsonDocument, array);
						<>1__state = 1;
						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<GroupedResult> IEnumerable<GroupedResult>.GetEnumerator()
			{
				<SelectGroupBy>d__7 <SelectGroupBy>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SelectGroupBy>d__ = this;
				}
				else
				{
					<SelectGroupBy>d__ = new <SelectGroupBy>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<SelectGroupBy>d__.groups = <>3__groups;
				<SelectGroupBy>d__.groupBy = <>3__groupBy;
				<SelectGroupBy>d__.resultOrderBy = <>3__resultOrderBy;
				return <SelectGroupBy>d__;
			}

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

		[CompilerGenerated]
		private sealed class <YieldDocuments>d__4 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<BsonDocument> enumerator;

			public IEnumerator<BsonDocument> <>3__enumerator;

			private GroupBy groupBy;

			public GroupBy <>3__groupBy;

			public GroupByPipe <>4__this;

			private BsonValue key;

			public BsonValue <>3__key;

			private Done done;

			public Done <>3__done;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				GroupByPipe groupByPipe = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = enumerator.Current;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (done.Running = enumerator.MoveNext())
				{
					BsonValue y = groupBy.Expression.ExecuteScalar(enumerator.Current, groupByPipe._pragmas.Collation);
					if (groupByPipe._pragmas.Collation.Equals(key, y))
					{
						<>2__current = enumerator.Current;
						<>1__state = 2;
						return true;
					}
					return false;
				}
				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]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<YieldDocuments>d__4 <YieldDocuments>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<YieldDocuments>d__ = this;
				}
				else
				{
					<YieldDocuments>d__ = new <YieldDocuments>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<YieldDocuments>d__.key = <>3__key;
				<YieldDocuments>d__.enumerator = <>3__enumerator;
				<YieldDocuments>d__.groupBy = <>3__groupBy;
				<YieldDocuments>d__.done = <>3__done;
				return <YieldDocuments>d__;
			}

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

		public GroupByPipe(TransactionService transaction, IDocumentLookup loader, SortDisk tempDisk, EnginePragmas pragmas, uint maxItemsCount)
			: base(transaction, loader, tempDisk, pragmas, maxItemsCount)
		{
		}

		public override IEnumerable<BsonDocument> Pipe(IEnumerable<IndexNode> nodes, QueryPlan query)
		{
			IEnumerable<BsonDocument> source = LoadDocument(nodes);
			foreach (BsonExpression filter in query.Filters)
			{
				source = Filter(source, filter);
			}
			if (query.GroupBy.OrderBy != null)
			{
				source = OrderBy(source, query.GroupBy.OrderBy, 0, int.MaxValue);
			}
			IEnumerable<GroupSource> groups = GroupBy(source, query.GroupBy);
			IEnumerable<GroupedResult> source2 = SelectGroupBy(groups, query.GroupBy, query.OrderBy);
			if (query.OrderBy != null)
			{
				return from x in OrderGroupedResult(source2, query.OrderBy, query.Offset, query.Limit)
					select x.Document;
			}
			if (query.Offset > 0)
			{
				source2 = source2.Skip(query.Offset);
			}
			if (query.Limit < int.MaxValue)
			{
				source2 = source2.Take(query.Limit);
			}
			return source2.Select((GroupedResult x) => x.Document);
		}

		[IteratorStateMachine(typeof(<GroupBy>d__3))]
		private IEnumerable<GroupSource> GroupBy(IEnumerable<BsonDocument> source, GroupBy groupBy)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GroupBy>d__3(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__groupBy = groupBy
			};
		}

		[IteratorStateMachine(typeof(<YieldDocuments>d__4))]
		private IEnumerable<BsonDocument> YieldDocuments(BsonValue key, IEnumerator<BsonDocument> enumerator, GroupBy groupBy, Done done)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <YieldDocuments>d__4(-2)
			{
				<>4__this = this,
				<>3__key = key,
				<>3__enumerator = enumerator,
				<>3__groupBy = groupBy,
				<>3__done = done
			};
		}

		private static void SetKeyParameter(BsonExpression expression, BsonValue key)
		{
			if (expression?.Parameters != null)
			{
				expression.Parameters["key"] = key;
			}
		}

		[IteratorStateMachine(typeof(<SelectGroupBy>d__7))]
		private IEnumerable<GroupedResult> SelectGroupBy(IEnumerable<GroupSource> groups, GroupBy groupBy, OrderBy resultOrderBy)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SelectGroupBy>d__7(-2)
			{
				<>4__this = this,
				<>3__groups = groups,
				<>3__groupBy = groupBy,
				<>3__resultOrderBy = resultOrderBy
			};
		}

		[IteratorStateMachine(typeof(<OrderGroupedResult>d__8))]
		private IEnumerable<GroupedResult> OrderGroupedResult(IEnumerable<GroupedResult> source, OrderBy orderBy, int offset, int limit)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OrderGroupedResult>d__8(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__orderBy = orderBy,
				<>3__offset = offset,
				<>3__limit = limit
			};
		}
	}
	internal class QueryPipe : BasePipe
	{
		[CompilerGenerated]
		private sealed class <Select>d__2 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private BsonExpression select;

			public BsonExpression <>3__select;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			public QueryPipe <>4__this;

			private string <defaultName>5__2;

			private IEnumerator<BsonDocument> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <Select>d__2(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();
					}
				}
				<defaultName>5__2 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					QueryPipe queryPipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<defaultName>5__2 = select.DefaultFieldName();
						<>7__wrap2 = source.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					case 2:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap2.MoveNext())
					{
						BsonDocument current = <>7__wrap2.Current;
						BsonValue bsonValue = select.ExecuteScalar(current, queryPipe._pragmas.Collation);
						if (bsonValue.IsDocument)
						{
							<>2__current = bsonValue.AsDocument;
							<>1__state = 1;
							return true;
						}
						<>2__current = new BsonDocument { [<defaultName>5__2] = bsonValue };
						<>1__state = 2;
						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<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Select>d__2 <Select>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Select>d__ = this;
				}
				else
				{
					<Select>d__ = new <Select>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Select>d__.source = <>3__source;
				<Select>d__.select = <>3__select;
				return <Select>d__;
			}

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

		[CompilerGenerated]
		private sealed class <SelectAll>d__3 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<BsonDocument> source;

			public IEnumerable<BsonDocument> <>3__source;

			public QueryPipe <>4__this;

			private BsonExpression select;

			public BsonExpression <>3__select;

			private string <defaultName>5__2;

			private IEnumerator<BsonValue> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <SelectAll>d__3(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();
					}
				}
				<defaultName>5__2 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					QueryPipe queryPipe = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						DocumentCacheEnumerable documentCacheEnumerable = new DocumentCacheEnumerable(source, queryPipe._lookup);
						<defaultName>5__2 = select.DefaultFieldName();
						IEnumerable<BsonValue> enumerable = select.Execute(documentCacheEnumerable, queryPipe._pragmas.Collation);
						<>7__wrap2 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					case 2:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap2.MoveNext())
					{
						BsonValue current = <>7__wrap2.Current;
						if (current.IsDocument)
						{
							<>2__current = current.AsDocument;
							<>1__state = 1;
							return true;
						}
						<>2__current = new BsonDocument { [<defaultName>5__2] = current };
						<>1__state = 2;
						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<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<SelectAll>d__3 <SelectAll>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SelectAll>d__ = this;
				}
				else
				{
					<SelectAll>d__ = new <SelectAll>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<SelectAll>d__.source = <>3__source;
				<SelectAll>d__.select = <>3__select;
				return <SelectAll>d__;
			}

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

		public QueryPipe(TransactionService transaction, IDocumentLookup loader, SortDisk tempDisk, EnginePragmas pragmas, uint maxItemsCount)
			: base(transaction, loader, tempDisk, pragmas, maxItemsCount)
		{
		}

		public override IEnumerable<BsonDocument> Pipe(IEnumerable<IndexNode> nodes, QueryPlan query)
		{
			IEnumerable<BsonDocument> source = LoadDocument(nodes);
			foreach (BsonExpression item in query.IncludeBefore)
			{
				source = Include(source, item);
			}
			foreach (BsonExpression filter in query.Filters)
			{
				source = Filter(source, filter);
			}
			if (query.OrderBy != null)
			{
				source = OrderBy(source, query.OrderBy, query.Offset, query.Limit);
			}
			else
			{
				if (query.Offset > 0)
				{
					source = source.Skip(query.Offset);
				}
				if (query.Limit < int.MaxValue)
				{
					source = source.Take(query.Limit);
				}
			}
			foreach (BsonExpression item2 in query.IncludeAfter)
			{
				source = Include(source, item2);
			}
			if (query.Select.All)
			{
				return SelectAll(source, query.Select.Expression);
			}
			return Select(source, query.Select.Expression);
		}

		[IteratorStateMachine(typeof(<Select>d__2))]
		private IEnumerable<BsonDocument> Select(IEnumerable<BsonDocument> source, BsonExpression select)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Select>d__2(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__select = select
			};
		}

		[IteratorStateMachine(typeof(<SelectAll>d__3))]
		private IEnumerable<BsonDocument> SelectAll(IEnumerable<BsonDocument> source, BsonExpression select)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SelectAll>d__3(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__select = select
			};
		}
	}
	internal class QueryExecutor
	{
		[CompilerGenerated]
		private sealed class <<ExecuteQueryInto>g__GetResultset|13_0>d : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public QueryExecutor <>4__this;

			private BsonDataReader <reader>5__2;

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

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

			[DebuggerHidden]
			public <<ExecuteQueryInto>g__GetResultset|13_0>d(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();
					}
				}
				<reader>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					QueryExecutor queryExecutor = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<reader>5__2 = queryExecutor.ExecuteQuery(executionPlan: false);
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<reader>5__2.Read())
					{
						<>2__current = <reader>5__2.Current.AsDocument;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<reader>5__2 = 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 (<reader>5__2 != null)
				{
					((IDisposable)<reader>5__2).Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<<ExecuteQueryInto>g__GetResultset|13_0>d result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <<ExecuteQueryInto>g__GetResultset|13_0>d(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0
		{
			public TransactionService transaction;

			public QueryExecutor <>4__this;

			public bool executionPlan;

			internal void <ExecuteQuery>b__0()
			{
				transaction.OpenCursors.Remove(<>4__this._cursor);
			}

			internal void <ExecuteQuery>b__1()
			{
				<>4__this._monitor.ReleaseTransaction(transaction);
			}
		}

		private readonly LiteEngine _engine;

		private readonly EngineState _state;

		private readonly TransactionMonitor _monitor;

		private readonly SortDisk _sortDisk;

		private readonly DiskService _disk;

		private readonly EnginePragmas _pragmas;

		private readonly CursorInfo _cursor;

		private readonly string _collection;

		private readonly Query _query;

		private readonly IEnumerable<BsonDocument> _source;

		public QueryExecutor(LiteEngine engine, EngineState state, TransactionMonitor monitor, SortDisk sortDisk, DiskService disk, EnginePragmas pragmas, string collection, Query query, IEnumerable<BsonDocument> source)
		{
			_engine = engine;
			_state = state;
			_monitor = monitor;
			_sortDisk = sortDisk;
			_disk = disk;
			_pragmas = pragmas;
			_collection = collection;
			_query = query;
			_cursor = new CursorInfo(collection, query);
			_source = source;
		}

		public BsonDataReader ExecuteQuery()
		{
			if (_query.Into == null)
			{
				return ExecuteQuery(_query.ExplainPlan);
			}
			return ExecuteQueryInto(_query.Into, _query.IntoAutoId);
		}

		internal BsonDataReader ExecuteQuery(bool executionPlan)
		{
			<>c__DisplayClass12_0 CS$<>8__locals0 = new <>c__DisplayClass12_0();
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.executionPlan = executionPlan;
			CS$<>8__locals0.transaction = _monitor.GetTransaction(create: true, queryOnly: true, out var isNew);
			CS$<>8__locals0.transaction.OpenCursors.Add(_cursor);
			IEnumerable<BsonDocument> source = RunQuery();
			source = source.OnDispose(delegate
			{
				CS$<>8__locals0.transaction.OpenCursors.Remove(CS$<>8__locals0.<>4__this._cursor);
			});
			if (isNew)
			{
				source = source.OnDispose(delegate
				{
					CS$<>8__locals0.<>4__this._monitor.ReleaseTransaction(CS$<>8__locals0.transaction);
				});
			}
			return new BsonDataReader(source, _collection, _state);
			[IteratorStateMachine(typeof(<>c__DisplayClass12_0.<<ExecuteQuery>g__RunQuery|2>d))]
			IEnumerable<BsonDocument> RunQuery()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass12_0.<<ExecuteQuery>g__RunQuery|2>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		internal BsonDataReader ExecuteQueryInto(string into, BsonAutoId autoId)
		{
			int num;
			if (into.StartsWith("$"))
			{
				SqlParser.ParseCollection(new Tokenizer(into), out var name, out var options);
				num = _engine.GetSystemCollection(name).Output(GetResultset(), options);
			}
			else
			{
				num = _engine.Insert(into, GetResultset(), autoId);
			}
			return new BsonDataReader(num);
			[IteratorStateMachine(typeof(<<ExecuteQueryInto>g__GetResultset|13_0>d))]
			IEnumerable<BsonDocument> GetResultset()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<ExecuteQueryInto>g__GetResultset|13_0>d(-2)
				{
					<>4__this = this
				};
			}
		}
	}
	internal class QueryOptimization
	{
		private readonly Snapshot _snapshot;

		private readonly Query _query;

		private readonly Collation _collation;

		private readonly QueryPlan _queryPlan;

		private readonly List<BsonExpression> _terms = new List<BsonExpression>();

		private bool _vectorOrderConsumed;

		public QueryOptimization(Snapshot snapshot, Query query, IEnumerable<BsonDocument> source, Collation collation)
		{
			if (query.Select == null)
			{
				throw new ArgumentNullException("Select");
			}
			_snapshot = snapshot;
			_query = query;
			_collation = collation;
			_queryPlan = new QueryPlan(snapshot.CollectionName)
			{
				Index = ((source != null) ? new IndexVirtual(source) : null),
				Select = new Select(_query.Select, _query.Select.UseSource),
				ForUpdate = query.ForUpdate,
				Limit = query.Limit,
				Offset = query.Offset
			};
		}

		public QueryPlan ProcessQuery()
		{
			SplitWherePredicateInTerms();
			OptimizeTerms();
			DefineQueryFields();
			DefineIndex();
			DefineOrderBy();
			DefineGroupBy();
			DefineIncludes();
			return _queryPlan;
		}

		private void SplitWherePredicateInTerms()
		{
			foreach (BsonExpression item in _query.Where)
			{
				add(item);
			}
			void add(BsonExpression predicate)
			{
				if (predicate.UseSource)
				{
					throw new LiteException(0, "WHERE filter can not use `*` expression in `" + predicate.Source);
				}
				if (predicate.IsPredicate || predicate.Type == BsonExpressionType.Or)
				{
					_terms.Add(predicate);
				}
				else
				{
					if (predicate.Type != BsonExpressionType.And)
					{
						throw LiteException.InvalidExpressionTypePredicate(predicate);
					}
					BsonExpression left = predicate.Left;
					BsonExpression right = predicate.Right;
					add(left);
					add(right);
				}
			}
		}

		private void OptimizeTerms()
		{
			for (int i = 0; i < _terms.Count; i++)
			{
				BsonExpression bsonExpression = _terms[i];
				BsonExpression left = bsonExpression.Left;
				if (left != null && !left.IsScalar && bsonExpression.IsANY && bsonExpression.Type == BsonExpressionType.Equal)
				{
					BsonExpression right = bsonExpression.Right;
					if (right != null && right.Type == BsonExpressionType.Path)
					{
						_terms[i] = BsonExpression.Create(bsonExpression.Right.Source + " IN ARRAY(" + bsonExpression.Left.Source + ")", bsonExpression.Parameters);
					}
				}
			}
		}

		private void DefineQueryFields()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			hashSet.AddRange(_query.Select.Fields);
			hashSet.AddRange(_terms.SelectMany((BsonExpression x) => x.Fields));
			hashSet.AddRange(_query.Includes.SelectMany((BsonExpression x) => x.Fields));
			hashSet.AddRange(_query.GroupBy?.Fields);
			hashSet.AddRange(_query.Having?.Fields);
			if (_query.OrderBy.Count > 0)
			{
				hashSet.AddRange(_query.OrderBy.SelectMany((QueryOrder x) => x.Expression.Fields));
			}
			if (hashSet.Contains("$"))
			{
				hashSet.Clear();
			}
			_queryPlan.Fields = hashSet;
		}

		private void DefineIndex()
		{
			BsonExpression selected = null;
			if (_queryPlan.Index == null)
			{
				if (TrySelectVectorIndex(out var index, out selected))
				{
					_queryPlan.Index = index;
					_queryPlan.IndexCost = index.GetCost(null);
					_queryPlan.IndexExpression = index.Expression;
				}
				else
				{
					IndexCost indexCost = ChooseIndex(_queryPlan.Fields);
					if (indexCost != null)
					{
						_queryPlan.Index = indexCost.Index;
						_queryPlan.IndexCost = indexCost.Cost;
						_queryPlan.IndexExpression = indexCost.IndexExpression;
					}
					else
					{
						CollectionIndex pK = _snapshot.CollectionPage.PK;
						_queryPlan.Index = new IndexAll("_id", 1);
						_queryPlan.IndexCost = _queryPlan.Index.GetCost(pK);
						_queryPlan.IndexExpression = "$._id";
					}
					selected = indexCost?.Expression;
				}
			}
			else
			{
				Constants.ENSURE(_queryPlan.Index is IndexVirtual, "pre-defined index must be only for virtual collections");
				_queryPlan.IndexCost = 0u;
			}
			if (_queryPlan.Fields.Count == 1 && _queryPlan.IndexExpression == "$." + _queryPlan.Fields.First())
			{
				_queryPlan.IsIndexKeyOnly = true;
			}
			_queryPlan.Filters.AddRange(_terms.Where((BsonExpression x) => x != selected));
		}

		private IndexCost ChooseIndex(HashSet<string> fields)
		{
			CollectionIndex[] source = _snapshot.CollectionPage.GetCollectionIndexes().ToArray();
			string preferred = ((fields.Count == 1) ? ("$." + fields.First()) : null);
			IndexCost indexCost = null;
			foreach (BsonExpression expr in _terms.Where((BsonExpression x) => x.IsPredicate))
			{
				Constants.ENSURE(expr.Left != null && expr.Right != null, "predicate expression must has left/right expressions");
				Tuple<CollectionIndex, BsonExpression> tuple = null;
				if (!expr.Left.IsScalar && expr.Right.IsScalar)
				{
					if (expr.IsANY)
					{
						tuple = (from x in source
							where x.Expression == expr.Left.Source && expr.Right.IsValue
							select Tuple.Create(x, expr.Right)).FirstOrDefault();
					}
				}
				else
				{
					tuple = (from x in source
						where x.Expression == expr.Left.Source && expr.Right.IsValue
						select Tuple.Create(x, expr.Right)).Union(from x in source
						where x.Expression == expr.Right.Source && expr.Left.IsValue
						select Tuple.Create(x, expr.Left)).FirstOrDefault();
				}
				if (tuple != null)
				{
					IndexCost indexCost2 = new IndexCost(tuple.Item1, expr, tuple.Item2, _collation);
					if (indexCost == null || indexCost2.Cost < indexCost.Cost)
					{
						indexCost = indexCost2;
					}
				}
			}
			if (indexCost == null && (_query.OrderBy.Count > 0 || _query.GroupBy != null || preferred != null))
			{
				string orderByExpr = ((_query.OrderBy.Count > 0) ? _query.OrderBy[0].Expression.Source : null);
				CollectionIndex collectionIndex = source.FirstOrDefault((CollectionIndex x) => x.Expression == _query.GroupBy?.Source) ?? source.FirstOrDefault((CollectionIndex x) => x.Expression == orderByExpr) ?? source.FirstOrDefault((CollectionIndex x) => x.Expression == preferred);
				if (collectionIndex != null)
				{
					indexCost = new IndexCost(collectionIndex);
				}
			}
			return indexCost;
		}

		private bool TrySelectVectorIndex(out VectorIndexQuery index, out BsonExpression consumedTerm)
		{
			index = null;
			consumedTerm = null;
			string expression = null;
			float[] target = null;
			double maxDistance = double.MaxValue;
			bool flag = false;
			foreach (BsonExpression term in _terms)
			{
				if (TryParseVectorPredicate(term, out expression, out target, out maxDistance))
				{
					consumedTerm = term;
					break;
				}
			}
			if (expression == null && _query.OrderBy.Count > 0)
			{
				foreach (QueryOrder item in _query.OrderBy)
				{
					if (TryParseVectorExpression(item.Expression, out expression, out target))
					{
						flag = true;
						maxDistance = double.MaxValue;
						break;
					}
				}
			}
			if (expression == null && _query.VectorTarget != null && _query.VectorField != null)
			{
				expression = NormalizeVectorField(_query.VectorField);
				target = _query.VectorTarget?.ToArray();
				maxDistance = _query.VectorMaxDistance;
				flag = flag || _query.OrderBy.Any(delegate(QueryOrder order)
				{
					BsonExpression expression2 = order.Expression;
					return expression2 != null && expression2.Type == BsonExpressionType.VectorSim;
				});
			}
			if (expression == null || target == null)
			{
				return false;
			}
			int? limit = ((_query.Limit != int.MaxValue) ? new int?(_query.Limit) : null);
			foreach (var (collectionIndex, vectorIndexMetadata) in _snapshot.CollectionPage.GetVectorIndexes())
			{
				if (string.Equals(collectionIndex.Expression, expression, StringComparison.OrdinalIgnoreCase) && vectorIndexMetadata.Dimensions == target.Length)
				{
					index = new VectorIndexQuery(collectionIndex.Name, _snapshot, collectionIndex, vectorIndexMetadata, target, maxDistance, limit, _collation);
					if (flag)
					{
						_vectorOrderConsumed = true;
					}
					return true;
				}
			}
			return false;
		}

		private bool TryParseVectorPredicate(BsonExpression predicate, out string expression, out float[] target, out double maxDistance)
		{
			expression = null;
			target = null;
			maxDistance = double.NaN;
			if (predicate == null)
			{
				return false;
			}
			if ((predicate.Type == BsonExpressionType.LessThan || predicate.Type == BsonExpressionType.LessThanOrEqual) && TryParseVectorExpression(predicate.Left, out expression, out target) && TryConvertToDouble(predicate.Right?.ExecuteScalar(_collation), out maxDistance))
			{
				return true;
			}
			if ((predicate.Type == BsonExpressionType.GreaterThan || predicate.Type == BsonExpressionType.GreaterThanOrEqual) && TryParseVectorExpression(predicate.Right, out expression, out target) && TryConvertToDouble(predicate.Left?.ExecuteScalar(_collation), out maxDistance))
			{
				return true;
			}
			expression = null;
			target = null;
			maxDistance = double.NaN;
			return false;
		}

		private bool TryParseVectorExpression(BsonExpression expression, out string fieldExpression, out float[] target)
		{
			fieldExpression = null;
			target = null;
			if (expression == null || expression.Type != BsonExpressionType.VectorSim)
			{
				return false;
			}
			BsonExpression left = expression.Left;
			if (left == null || string.IsNullOrEmpty(left.Source))
			{
				return false;
			}
			if (!TryConvertToVector(expression.Right?.ExecuteScalar(_collation), out target))
			{
				return false;
			}
			fieldExpression = left.Source;
			return true;
		}

		private static bool TryConvertToVector(BsonValue value, out float[] vector)
		{
			vector = null;
			if (value == null || value.IsNull)
			{
				return false;
			}
			if (value.Type == BsonType.Vector)
			{
				vector = value.AsVector.ToArray();
				return true;
			}
			if (!value.IsArray)
			{
				return false;
			}
			BsonArray asArray = value.AsArray;
			float[] array = new float[asArray.Count];
			for (int i = 0; i < asArray.Count; i++)
			{
				BsonValue bsonValue = asArray[i];
				if (bsonValue.IsNull)
				{
					return false;
				}
				try
				{
					array[i] = (float)bsonValue.AsDouble;
				}
				catch
				{
					return false;
				}
			}
			vector = array;
			return true;
		}

		private static bool TryConvertToDouble(BsonValue value, out double number)
		{
			number = double.NaN;
			if (value == null || value.IsNull || !value.IsNumber)
			{
				return false;
			}
			number = value.AsDouble;
			return !double.IsNaN(number);
		}

		private static string NormalizeVectorField(string field)
		{
			if (string.IsNullOrWhiteSpace(field))
			{
				return field;
			}
			field = field.Trim();
			if (field.StartsWith("$", StringComparison.Ordinal))
			{
				return field;
			}
			if (field.StartsWith(".", StringComparison.Ordinal))
			{
				field = field.Substring(1);
			}
			return "$." + field;
		}

		private void DefineOrderBy()
		{
			if (_query.OrderBy.Count == 0)
			{
				return;
			}
			if (_vectorOrderConsumed)
			{
				_queryPlan.OrderBy = null;
				return;
			}
			OrderBy orderBy = new OrderBy(_query.OrderBy.Select((QueryOrder x) => new OrderByItem(x.Expression, x.Order)));
			if (orderBy.PrimaryExpression.Source == _queryPlan.IndexExpression)
			{
				_queryPlan.Index.Order = orderBy.PrimaryOrder;
				if (orderBy.Segments.Count == 1)
				{
					orderBy = null;
				}
			}
			_queryPlan.OrderBy = orderBy;
		}

		private void DefineGroupBy()
		{
			if (_query.GroupBy != null)
			{
				if (_query.Includes.Count > 0)
				{
					throw new NotSupportedException("GROUP BY expression do not support INCLUDE");
				}
				BsonExpression groupBy = _query.GroupBy;
				BsonExpression expression = _queryPlan.Select.Expression;
				BsonExpression having = _query.Having;
				OrderBy orderBy = null;
				if (!(groupBy.Source == _queryPlan.IndexExpression))
				{
					orderBy = new OrderBy(new OrderByItem[1]
					{
						new OrderByItem(groupBy, 1)
					});
				}
				_queryPlan.GroupBy = new GroupBy(groupBy, expression, having, orderBy);
			}
		}

		private void DefineIncludes()
		{
			foreach (BsonExpression include in _query.Includes)
			{
				string field = include.Fields.Single();
				int num;
				if (!_queryPlan.Filters.Any((BsonExpression x) => x.Fields.Contains(field)))
				{
					OrderBy orderBy = _queryPlan.OrderBy;
					if (orderBy == null)
					{
						num = 0;
					}
					else
					{
						num = (orderBy.ContainsField(field) ? 1 : 0);
						if (num != 0)
						{
							goto IL_0076;
						}
					}
					goto IL_0087;
				}
				num = 1;
				goto IL_0076;
				IL_0076:
				_queryPlan.IncludeBefore.Add(include);
				goto IL_0087;
				IL_0087:
				if (num == 0 || _queryPlan.OrderBy != null)
				{
					_queryPlan.IncludeAfter.Add(include);
				}
			}
		}
	}
	internal class GroupBy
	{
		public BsonExpression Expression { get; }

		public BsonExpression Select { get; }

		public BsonExpression Having { get; }

		public OrderBy OrderBy { get; }

		public GroupBy(BsonExpression expression, BsonExpression select, BsonExpression having, OrderBy orderBy)
		{
			Expression = expression;
			Select = select;
			Having = having;
			OrderBy = orderBy;
		}
	}
	internal class IndexCost
	{
		public uint Cost { get; }

		public BsonExpression Expression { get; }

		public string IndexExpression { get; }

		public Index Index { get; }

		public IndexCost(CollectionIndex index, BsonExpression expr, BsonExpression value, Collation collation)
		{
			IndexCost indexCost = this;
			IndexExpression = index.Expression;
			Expression = expr;
			BsonExpressionType exprType = expr.Type;
			if (expr.Left.IsValue)
			{
				switch (expr.Type)
				{
				case BsonExpressionType.GreaterThan:
					exprType = BsonExpressionType.LessThan;
					break;
				case BsonExpressionType.GreaterThanOrEqual:
					exprType = BsonExpressionType.LessThanOrEqual;
					break;
				case BsonExpressionType.LessThan:
					exprType = BsonExpressionType.GreaterThan;
					break;
				case BsonExpressionType.LessThanOrEqual:
					exprType = BsonExpressionType.GreaterThanOrEqual;
					break;
				}
			}
			Index = (from x in value.Execute(collation)
				select indexCost.CreateIndex(exprType, index.Name, x)).FirstOrDefault();
			Constants.ENSURE(Index != null, "index must be not null");
			Cost = Index.GetCost(index);
		}

		public IndexCost(CollectionIndex index)
		{
			Expression = BsonExpression.Create(index.Expression);
			Index = new IndexAll(index.Name, 1);
			Cost = Index.GetCost(index);
			IndexExpression = index.Expression;
		}

		private Index CreateIndex(BsonExpressionType type, string name, BsonValue value)
		{
			switch (type)
			{
			case BsonExpressionType.Equal:
				return new IndexEquals(name, value);
			case BsonExpressionType.Between:
				return new IndexRange(name, value.AsArray[0], value.AsArray[1], startEquals: true, endEquals: true, 1);
			case BsonExpressionType.Like:
				return new IndexLike(name, value.AsString, 1);
			case BsonExpressionType.GreaterThan:
				return new IndexRange(name, value, BsonValue.MaxValue, startEquals: false, endEquals: true, 1);
			case BsonExpressionType.GreaterThanOrEqual:
				return new IndexRange(name, value, BsonValue.MaxValue, startEquals: true, endEquals: true, 1);
			case BsonExpressionType.LessThan:
				return new IndexRange(name, BsonValue.MinValue, value, startEquals: true, endEquals: false, 1);
			case BsonExpressionType.LessThanOrEqual:
				return new IndexRange(name, BsonValue.MinValue, value, startEquals: true, endEquals: true, 1);
			case BsonExpressionType.NotEqual:
				return new IndexScan(name, (BsonValue x) => x.CompareTo(value) != 0, 1);
			case BsonExpressionType.In:
				if (!value.IsArray)
				{
					return new IndexEquals(name, value);
				}
				return new IndexIn(name, value.AsArray, 1);
			default:
				return null;
			}
		}
	}
	internal class OrderBy
	{
		private readonly List<OrderByItem> _segments;

		public IReadOnlyList<OrderByItem> Segments => _segments;

		public BsonExpression PrimaryExpression => _segments[0].Expression;

		public int PrimaryOrder => _segments[0].Order;

		public OrderBy(IEnumerable<OrderByItem> segments)
		{
			if (segments == null)
			{
				throw new ArgumentNullException("segments");
			}
			_segments = segments.ToList();
			if (_segments.Count == 0)
			{
				throw new ArgumentException("OrderBy requires at least one segment", "segments");
			}
		}

		public bool ContainsField(string field)
		{
			return _segments.Any((OrderByItem x) => x.Expression.Fields.Contains(field));
		}
	}
	internal class OrderByItem
	{
		public BsonExpression Expression { get; }

		public int Order { get; }

		public OrderByItem(BsonExpression expression, int order)
		{
			Expression = expression ?? throw new ArgumentNullException("expression");
			Order = order;
		}
	}
	internal class QueryPlan
	{
		public string Collection { get; set; }

		public Index Index { get; set; }

		public string IndexExpression { get; set; }

		public uint IndexCost { get; internal set; }

		public bool IsIndexKeyOnly { get; set; }

		public List<BsonExpression> Filters { get; set; } = new List<BsonExpression>();


		public List<BsonExpression> IncludeBefore { get; set; } = new List<BsonExpression>();


		public List<BsonExpression> IncludeAfter { get; set; } = new List<BsonExpression>();


		public OrderBy OrderBy { get; set; }

		public GroupBy GroupBy { get; set; }

		public Select Select { get; set; }

		public HashSet<string> Fields { get; set; }

		public int Limit { get; set; } = int.MaxValue;


		public int Offset { get; set; }

		public bool ForUpdate { get; set; }

		public QueryPlan(string collection)
		{
			Collection = collection;
		}

		public BasePipe GetPipe(TransactionService transaction, Snapshot snapshot, SortDisk tempDisk, EnginePragmas pragmas, uint maxItemsCount)
		{
			if (GroupBy == null)
			{
				return new QueryPipe(transaction, GetLookup(snapshot, pragmas, maxItemsCount), tempDisk, pragmas, maxItemsCount);
			}
			return new GroupByPipe(transaction, GetLookup(snapshot, pragmas, maxItemsCount), tempDisk, pragmas, maxItemsCount);
		}

		public IDocumentLookup GetLookup(Snapshot snapshot, EnginePragmas pragmas, uint maxItemsCount)
		{
			DataService data = new DataService(snapshot, maxItemsCount);
			IndexService indexer = new IndexService(snapshot, pragmas.Collation, maxItemsCount);
			IDocumentLookup documentLookup = Index as IDocumentLookup;
			if (documentLookup == null)
			{
				documentLookup = ((!IsIndexKeyOnly) ? ((IDocumentLookup)new DatafileLookup(data, pragmas.UtcDate, Fields)) : ((IDocumentLookup)new IndexLookup(indexer, Fields.Single())));
			}
			return documentLookup;
		}

		public BsonDocument GetExecutionPlan()
		{
			BsonDocument bsonDocument = new BsonDocument
			{
				["collection"] = Collection,
				["snaphost"] = (ForUpdate ? "write" : "read"),
				["pipe"] = ((GroupBy == null) ? "queryPipe" : "groupByPipe")
			};
			bsonDocument["index"] = new BsonDocument
			{
				["name"] = Index.Name,
				["expr"] = IndexExpression,
				["order"] = Index.Order,
				["mode"] = Index.ToString(),
				["cost"] = (int)IndexCost
			};
			bsonDocument["lookup"] = new BsonDocument
			{
				["loader"] = ((Index is IndexVirtual) ? "virtual" : (IsIndexKeyOnly ? "index" : "document")),
				["fields"] = ((Fields.Count == 0) ? new BsonValue("$") : new BsonArray(Fields.Select((string x) => new BsonValue(x))))
			};
			if (IncludeBefore.Count > 0)
			{
				bsonDocument["includeBefore"] = new BsonArray(IncludeBefore.Select((BsonExpression x) => new BsonValue(x.Source)));
			}
			if (Filters.Count > 0)
			{
				bsonDocument["filters"] = new BsonArray(Filters.Select((BsonExpression x) => new BsonValue(x.Source)));
			}
			if (OrderBy != null)
			{
				bsonDocument["orderBy"] = new BsonArray(OrderBy.Segments.Select((OrderByItem x) => new BsonDocument
				{
					["expr"] = x.Expression.Source,
					["order"] = x.Order
				}));
			}
			if (Limit != int.MaxValue)
			{
				bsonDocument["limit"] = Limit;
			}
			if (Offset != 0)
			{
				bsonDocument["offset"] = Offset;
			}
			if (IncludeAfter.Count > 0)
			{
				bsonDocument["includeAfter"] = new BsonArray(IncludeAfter.Select((BsonExpression x) => new BsonValue(x.Source)));
			}
			if (GroupBy != null)
			{
				BsonDocument bsonDocument2 = new BsonDocument
				{
					["expr"] = GroupBy.Expression.Source,
					["having"] = GroupBy.Having?.Source,
					["select"] = GroupBy.Select?.Source
				};
				if (GroupBy.OrderBy != null)
				{
					bsonDocument2["orderBy"] = new BsonArray(GroupBy.OrderBy.Segments.Select((OrderByItem x) => new BsonDocument
					{
						["expr"] = x.Expression.Source,
						["order"] = x.Order
					}));
				}
				bsonDocument["groupBy"] = bsonDocument2;
			}
			else
			{
				bsonDocument["select"] = new BsonDocument
				{
					["expr"] = Select.Expression.Source,
					["all"] = Select.All
				};
			}
			return bsonDocument;
		}
	}
	internal class Select
	{
		public BsonExpression Expression { get; }

		public bool All { get; }

		public Select(BsonExpression expression, bool all)
		{
			Expression = expression;
			All = all;
		}
	}
	internal class CollectionService
	{
		private readonly HeaderPage _header;

		private readonly DiskService _disk;

		private readonly Snapshot _snapshot;

		private readonly TransactionPages _transPages;

		public CollectionService(HeaderPage header, DiskService disk, Snapshot snapshot, TransactionPages transPages)
		{
			_header = header;
			_disk = disk;
			_snapshot = snapshot;
			_transPages = transPages;
		}

		public static void CheckName(string name, HeaderPage header)
		{
			if (Encoding.UTF8.GetByteCount(name) > header.GetAvailableCollectionSpace())
			{
				throw LiteException.InvalidCollectionName(name, "There is no space in header this collection name");
			}
			if (!name.IsWord())
			{
				throw LiteException.InvalidCollectionName(name, "Use only [a-Z$_]");
			}
			if (name.StartsWith("$"))
			{
				throw LiteException.InvalidCollectionName(name, "Collection can't starts with `$` (reserved for system collections)");
			}
		}

		public bool Get(string name, bool addIfNotExists, ref CollectionPage collectionPage)
		{
			uint collectionPageID = _header.GetCollectionPageID(name);
			if (collectionPageID != uint.MaxValue)
			{
				collectionPage = _snapshot.GetPage<CollectionPage>(collectionPageID);
				return false;
			}
			if (addIfNotExists)
			{
				Add(name, ref collectionPage);
				return true;
			}
			return false;
		}

		private void Add(string name, ref CollectionPage collectionPage)
		{
			CheckName(name, _header);
			collectionPage = _snapshot.NewPage<CollectionPage>();
			uint pageID = collectionPage.PageID;
			_transPages.Commit += delegate(HeaderPage h)
			{
				h.InsertCollection(name, pageID);
			};
			new IndexService(_snapshot, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT).CreateIndex("_id", "$._id", unique: true);
		}
	}
	internal class DataService
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass4_0
		{
			public int bytesLeft;

			public DataService <>4__this;

			public PageAddress firstBlock;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public PageAddress updateAddress;

			public DataService <>4__this;

			public int bytesLeft;

			public DataBlock lastBlock;
		}

		[CompilerGenerated]
		private sealed class <Read>d__6 : IEnumerable<BufferSlice>, IEnumerable, IEnumerator<BufferSlice>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BufferSlice <>2__current;

			private int <>l__initialThreadId;

			public DataService <>4__this;

			private PageAddress address;

			public PageAddress <>3__address;

			private uint <counter>5__2;

			private DataBlock <block>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				DataService dataService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<counter>5__2 = 0u;
					break;
				case 1:
					<>1__state = -1;
					address = <block>5__3.NextBlock;
					<block>5__3 = null;
					break;
				}
				if (address != PageAddress.Empty)
				{
					Constants.ENSURE(<counter>5__2++ < dataService._maxItemsCount, "Detected loop in data Read({0})", address);
					DataPage page = dataService._snapshot.GetPage<DataPage>(address.PageID);
					<block>5__3 = page.GetBlock(address.Index);
					<>2__current = <block>5__3.Buffer;
					<>1__state = 1;
					return true;
				}
				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]
			IEnumerator<BufferSlice> IEnumerable<BufferSlice>.GetEnumerator()
			{
				<Read>d__6 <Read>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Read>d__ = this;
				}
				else
				{
					<Read>d__ = new <Read>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<Read>d__.address = <>3__address;
				return <Read>d__;
			}

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

		public const int MAX_DATA_BYTES_PER_PAGE = 8150;

		private readonly Snapshot _snapshot;

		private readonly uint _maxItemsCount;

		public DataService(Snapshot snapshot, uint maxItemsCount)
		{
			_snapshot = snapshot;
			_maxItemsCount = maxItemsCount;
		}

		public PageAddress Insert(BsonDocument doc)
		{
			<>c__DisplayClass4_0 CS$<>8__locals0 = new <>c__DisplayClass4_0();
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.bytesLeft = doc.GetBytesCount(recalc: true);
			if (CS$<>8__locals0.bytesLeft > 16683050)
			{
				throw new LiteException(0, "Document size exceed {0} limit", 16683050);
			}
			CS$<>8__locals0.firstBlock = PageAddress.Empty;
			using (BufferWriter bufferWriter = new BufferWriter(source()))
			{
				bufferWriter.WriteDocument(doc, recalc: false);
				bufferWriter.Consume();
			}
			return CS$<>8__locals0.firstBlock;
			[IteratorStateMachine(typeof(<>c__DisplayClass4_0.<<Insert>g__source|0>d))]
			IEnumerable<BufferSlice> source()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass4_0.<<Insert>g__source|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		public void Update(CollectionPage col, PageAddress blockAddress, BsonDocument doc)
		{
			<>c__DisplayClass5_0 CS$<>8__locals0 = new <>c__DisplayClass5_0();
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.bytesLeft = doc.GetBytesCount(recalc: true);
			if (CS$<>8__locals0.bytesLeft > 16683050)
			{
				throw new LiteException(0, "Document size exceed {0} limit", 16683050);
			}
			CS$<>8__locals0.lastBlock = null;
			CS$<>8__locals0.updateAddress = blockAddress;
			using (BufferWriter bufferWriter = new BufferWriter(source()))
			{
				bufferWriter.WriteDocument(doc, recalc: false);
				bufferWriter.Consume();
			}
			[IteratorStateMachine(typeof(<>c__DisplayClass5_0.<<Update>g__source|0>d))]
			IEnumerable<BufferSlice> source()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass5_0.<<Update>g__source|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		[IteratorStateMachine(typeof(<Read>d__6))]
		public IEnumerable<BufferSlice> Read(PageAddress address)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Read>d__6(-2)
			{
				<>4__this = this,
				<>3__address = address
			};
		}

		public void Delete(PageAddress blockAddress)
		{
			while (blockAddress != PageAddress.Empty)
			{
				DataPage page = _snapshot.GetPage<DataPage>(blockAddress.PageID);
				DataBlock block = page.GetBlock(blockAddress.Index);
				page.DeleteBlock(blockAddress.Index);
				_snapshot.AddOrRemoveFreeDataList(page);
				blockAddress = block.NextBlock;
			}
		}
	}
	internal class IndexService
	{
		[CompilerGenerated]
		private sealed class <FindAll>d__16 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			private int order;

			public int <>3__order;

			public IndexService <>4__this;

			private CollectionIndex index;

			public CollectionIndex <>3__index;

			private IndexNode <cur>5__2;

			private uint <counter>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				IndexService indexService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<cur>5__2 = ((order == 1) ? indexService.GetNode(index.Head) : indexService.GetNode(index.Tail));
					<counter>5__3 = 0u;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!<cur>5__2.GetNextPrev(0, order).IsEmpty)
				{
					Constants.ENSURE(<counter>5__3++ < indexService._maxItemsCount, "Detected loop in FindAll({0})", index.Name);
					<cur>5__2 = indexService.GetNode(<cur>5__2.GetNextPrev(0, order));
					if (<cur>5__2.Key.IsMinValue || <cur>5__2.Key.IsMaxValue)
					{
						return false;
					}
					<>2__current = <cur>5__2;
					<>1__state = 1;
					return true;
				}
				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]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<FindAll>d__16 <FindAll>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindAll>d__ = this;
				}
				else
				{
					<FindAll>d__ = new <FindAll>d__16(0)
					{
						<>4__this = <>4__this
					};
				}
				<FindAll>d__.index = <>3__index;
				<FindAll>d__.order = <>3__order;
				return <FindAll>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetNodeList>d__11 : IEnumerable<IndexNode>, IEnumerable, IEnumerator<IndexNode>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IndexNode <>2__current;

			private int <>l__initialThreadId;

			public IndexService <>4__this;

			private PageAddress nodeAddress;

			public PageAddress <>3__nodeAddress;

			private IndexNode <node>5__2;

			private uint <counter>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				IndexService indexService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<node>5__2 = indexService.GetNode(nodeAddress);
					<counter>5__3 = 0u;
					break;
				case 1:
					<>1__state = -1;
					<node>5__2 = indexService.GetNode(<node>5__2.NextNode);
					break;
				}
				if (<node>5__2 != null)
				{
					Constants.ENSURE(<counter>5__3++ < indexService._maxItemsCount, "Detected loop in GetNodeList({0})", nodeAddress);
					<>2__current = <node>5__2;
					<>1__state = 1;
					return true;
				}
				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]
			IEnumerator<IndexNode> IEnumerable<IndexNode>.GetEnumerator()
			{
				<GetNodeList>d__11 <GetNodeList>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetNodeList>d__ = this;
				}
				else
				{
					<GetNodeList>d__ = new <GetNodeList>d__11(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetNodeList>d__.nodeAddress = <>3__nodeAddress;
				return <GetNodeList>d__;
			}

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

		private readonly Snapshot _snapshot;

		private readonly Collation _collation;

		private readonly uint _maxItemsCount;

		public Collation Collation => _collation;

		public IndexService(Snapshot snapshot, Collation collation, uint maxItemsCount)
		{
			_snapshot = snapshot;
			_collation = collation;
			_maxItemsCount = maxItemsCount;
		}

		public CollectionIndex CreateIndex(string name, string expr, bool unique)
		{
			int keyLength;
			int nodeLength = IndexNode.GetNodeLength(32, BsonValue.MinValue, out keyLength);
			IndexPage indexPage = _snapshot.NewPage<IndexPage>();
			CollectionIndex collectionIndex = _snapshot.CollectionPage.InsertCollectionIndex(name, expr, unique);
			IndexNode indexNode = indexPage.InsertIndexNode(collectionIndex.Slot, 32, BsonValue.MinValue, PageAddress.Empty, nodeLength);
			IndexNode indexNode2 = indexPage.InsertIndexNode(collectionIndex.Slot, 32, BsonValue.MaxValue, PageAddress.Empty, nodeLength);
			indexNode.SetNext(0, indexNode2.Position);
			indexNode2.SetPrev(0, indexNode.Position);
			collectionIndex.FreeIndexPageList = indexPage.PageID;
			indexPage.PageListSlot = 0;
			collectionIndex.Head = indexNode.Position;
			collectionIndex.Tail = indexNode2.Position;
			return collectionIndex;
		}

		public IndexNode AddNode(CollectionIndex index, BsonValue key, PageAddress dataBlock, IndexNode last)
		{
			if (key.IsMaxValue || key.IsMinValue)
			{
				throw LiteException.InvalidIndexKey("BsonValue MaxValue/MinValue are not supported as index key");
			}
			byte insertLevels = Flip();
			return AddNode(index, key, dataBlock, insertLevels, last);
		}

		private IndexNode AddNode(CollectionIndex index, BsonValue key, PageAddress dataBlock, byte insertLevels, IndexNode last)
		{
			int keyLength;
			int nodeLength = IndexNode.GetNodeLength(insertLevels, key, out keyLength);
			if (keyLength > 1023)
			{
				throw LiteException.InvalidIndexKey($"Index key must be less than {1023} bytes.");
			}
			IndexNode indexNode = _snapshot.GetFreeIndexPage(nodeLength, ref index.FreeIndexPageList).InsertIndexNode(index.Slot, insertLevels, key, dataBlock, nodeLength);
			IndexNode indexNode2 = GetNode(index.Head);
			uint num = 0u;
			for (int num2 = 31; num2 >= 0; num2--)
			{
				PageAddress pageAddress = indexNode2.Next[num2];
				while (!pageAddress.IsEmpty && pageAddress != index.Tail)
				{
					Constants.ENSURE(num++ < _maxItemsCount, "Detected loop in AddNode({0})", indexNode.Position);
					IndexNode node = GetNode(pageAddress);
					int num3 = node.Key.CompareTo(key, _collation);
					if (num3 == 0 && index.Unique)
					{
						throw LiteException.IndexDuplicateKey(index.Name, key);
					}
					if (num3 == 1)
					{
						break;
					}
					indexNode2 = node;
					pageAddress = node.Next[num2];
				}
				if (num2 <= insertLevels - 1)
				{
					PageAddress position = indexNode2.Position;
					PageAddress value = indexNode2.Next[num2];
					if (value.IsEmpty)
					{
						value = index.Tail;
					}
					indexNode.SetNext((byte)num2, value);
					indexNode.SetPrev((byte)num2, position);
					indexNode2.SetNext((byte)num2, indexNode.Position);
					pageAddress = indexNode.Next[num2];
					GetNode(pageAddress).SetPrev((byte)num2, indexNode.Position);
				}
			}
			if (last != null)
			{
				Constants.ENSURE(last.NextNode == PageAddress.Empty, "last index node must point to null");
				last = GetNode(last.Position);
				last.SetNextNode(indexNode.Position);
			}
			_snapshot.AddOrRemoveFreeIndexList(indexNode.Page, ref index.FreeIndexPageList);
			return indexNode;
		}

		public byte Flip()
		{
			byte b = 1;
			int num = Randomizer.Next();
			while ((num & 1) == 1)
			{
				b++;
				if (b == 32)
				{
					break;
				}
				num >>= 1;
			}
			return b;
		}

		public IndexNode GetNode(PageAddress address)
		{
			if (address.PageID == uint.MaxValue)
			{
				return null;
			}
			return _snapshot.GetPage<IndexPage>(address.PageID).GetIndexNode(address.Index);
		}

		[IteratorStateMachine(typeof(<GetNodeList>d__11))]
		public IEnumerable<IndexNode> GetNodeList(PageAddress nodeAddress)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetNodeList>d__11(-2)
			{
				<>4__this = this,
				<>3__nodeAddress = nodeAddress
			};
		}

		public void DeleteAll(PageAddress pkAddress)
		{
			IndexNode node = GetNode(pkAddress);
			CollectionIndex[] collectionIndexesSlots = _snapshot.CollectionPage.GetCollectionIndexesSlots();
			uint num = 0u;
			while (node != null)
			{
				Constants.ENSURE(num++ < _maxItemsCount, "Detected loop in DeleteAll({0})", pkAddress);
				DeleteSingleNode(node, collectionIndexesSlots[node.Slot]);
				node = GetNode(node.NextNode);
			}
		}

		public IndexNode DeleteList(PageAddress pkAddress, HashSet<PageAddress> toDelete)
		{
			IndexNode indexNode = GetNode(pkAddress);
			IndexNode node = GetNode(indexNode.NextNode);
			CollectionIndex[] collectionIndexesSlots = _snapshot.CollectionPage.GetCollectionIndexesSlots();
			uint num = 0u;
			while (node != null)
			{
				Constants.ENSURE(num++ < _maxItemsCount, "Detected loop in DeleteList({0})", pkAddress);
				if (toDelete.Contains(node.Position))
				{
					DeleteSingleNode(node, collectionIndexesSlots[node.Slot]);
					indexNode.SetNextNode(node.NextNode);
				}
				else
				{
					indexNode = node;
				}
				node = GetNode(node.NextNode);
			}
			return indexNode;
		}

		private void DeleteSingleNode(IndexNode node, CollectionIndex index)
		{
			for (int num = node.Levels - 1; num >= 0; num--)
			{
				IndexNode node2 = GetNode(node.Prev[num]);
				IndexNode node3 = GetNode(node.Next[num]);
				node2?.SetNext((byte)num, node.Next[num]);
				node3?.SetPrev((byte)num, node.Prev[num]);
			}
			node.Page.DeleteIndexNode(node.Position.Index);
			_snapshot.AddOrRemoveFreeIndexList(node.Page, ref index.FreeIndexPageList);
		}

		public void DropIndex(CollectionIndex index)
		{
			byte slot = index.Slot;
			CollectionIndex pK = _snapshot.CollectionPage.PK;
			foreach (IndexNode item in FindAll(pK, 1))
			{
				PageAddress nextNode = item.NextNode;
				IndexNode indexNode = item;
				while (nextNode != PageAddress.Empty)
				{
					IndexNode node = GetNode(nextNode);
					if (node.Slot == slot)
					{
						node.Page.DeleteIndexNode(node.Position.Index);
						indexNode.SetNextNode(node.NextNode);
					}
					else
					{
						indexNode = node;
					}
					nextNode = node.NextNode;
				}
			}
			GetNode(index.Head).Page.DeleteIndexNode(index.Head.Index);
			GetNode(index.Tail).Page.DeleteIndexNode(index.Tail.Index);
		}

		[IteratorStateMachine(typeof(<FindAll>d__16))]
		public IEnumerable<IndexNode> FindAll(CollectionIndex index, int order)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindAll>d__16(-2)
			{
				<>4__this = this,
				<>3__index = index,
				<>3__order = order
			};
		}

		public IndexNode Find(CollectionIndex index, BsonValue value, bool sibling, int order)
		{
			IndexNode indexNode = ((order == 1) ? GetNode(index.Head) : GetNode(index.Tail));
			uint num = 0u;
			for (int num2 = 31; num2 >= 0; num2--)
			{
				PageAddress nextPrev = indexNode.GetNextPrev((byte)num2, order);
				while (!nextPrev.IsEmpty)
				{
					Constants.ENSURE(num++ < _maxItemsCount, "Detected loop in Find({0}, {1})", index.Name, value);
					IndexNode node = GetNode(nextPrev);
					int num3 = node.Key.CompareTo(value, _collation);
					if (num3 == order && (num2 > 0 || !sibling))
					{
						break;
					}
					if (num3 == order && num2 == 0 && sibling)
					{
						if (!node.Key.IsMinValue && !node.Key.IsMaxValue)
						{
							return node;
						}
						return null;
					}
					if (num3 == 0)
					{
						return node;
					}
					indexNode = node;
					nextPrev = node.GetNextPrev((byte)num2, order);
				}
			}
			return null;
		}
	}
	internal class LockService : IDisposable
	{
		private readonly EnginePragmas _pragmas;

		private readonly ReaderWriterLockSlim _transaction = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);

		private readonly ConcurrentDictionary<string, object> _collections = new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase);

		public bool IsInTransaction
		{
			get
			{
				if (!_transaction.IsReadLockHeld)
				{
					return _transaction.IsWriteLockHeld;
				}
				return true;
			}
		}

		public int TransactionsCount => _transaction.CurrentReadCount;

		internal LockService(EnginePragmas pragmas)
		{
			_pragmas = pragmas;
		}

		public void EnterTransaction()
		{
			if (_transaction.IsWriteLockHeld || _transaction.TryEnterReadLock(_pragmas.Timeout))
			{
				return;
			}
			throw LiteException.LockTimeout("transaction", _pragmas.Timeout);
		}

		public void ExitTransaction()
		{
			if (_transaction.IsWriteLockHeld || !_transaction.IsReadLockHeld)
			{
				return;
			}
			try
			{
				_transaction.ExitReadLock();
			}
			catch
			{
			}
		}

		public void EnterLock(string collectionName)
		{
			Constants.ENSURE(_transaction.IsReadLockHeld || _transaction.IsWriteLockHeld, "Use EnterTransaction() before EnterLock(name)");
			if (!Monitor.TryEnter(_collections.GetOrAdd(collectionName, (string s) => new object()), _pragmas.Timeout))
			{
				throw LiteException.LockTimeout("write", collectionName, _pragmas.Timeout);
			}
		}

		public void ExitLock(string collectionName)
		{
			if (!_collections.TryGetValue(collectionName, out var value))
			{
				throw LiteException.CollectionLockerNotFound(collectionName);
			}
			Monitor.Exit(value);
		}

		public bool EnterExclusive()
		{
			if (_transaction.IsWriteLockHeld)
			{
				return false;
			}
			if (!_transaction.TryEnterWriteLock(_pragmas.Timeout))
			{
				throw LiteException.LockTimeout("exclusive", _pragmas.Timeout);
			}
			return true;
		}

		public bool TryEnterExclusive(out bool mustExit)
		{
			if (_transaction.IsWriteLockHeld)
			{
				mustExit = false;
				return true;
			}
			if (_transaction.IsReadLockHeld || _transaction.CurrentReadCount > 0)
			{
				mustExit = false;
				return false;
			}
			if (!_transaction.TryEnterWriteLock(10))
			{
				mustExit = false;
				return false;
			}
			Constants.ENSURE(_transaction.RecursiveReadCount == 0, "must have no other transaction here");
			mustExit = true;
			return true;
		}

		public void ExitExclusive()
		{
			_transaction.ExitWriteLock();
		}

		public void Dispose()
		{
			try
			{
				_transaction.Dispose();
			}
			catch (SynchronizationLockException)
			{
			}
		}
	}
	internal class RebuildService
	{
		private readonly EngineSettings _settings;

		private readonly int _fileVersion;

		public RebuildService(EngineSettings settings)
		{
			_settings = settings;
			if (FileReaderV7.IsVersion(ReadFirstBytes(useAesStream: false)))
			{
				_fileVersion = 7;
				return;
			}
			byte[] buffer = ReadFirstBytes();
			if (!FileReaderV8.IsVersion(buffer))
			{
				throw LiteException.InvalidDatabase();
			}
			_fileVersion = 8;
		}

		public long Rebuild(RebuildOptions options)
		{
			string backupFilename = FileHelper.GetSuffixFile(_settings.Filename, "-backup");
			string suffixFile = FileHelper.GetSuffixFile(FileHelper.GetLogFile(_settings.Filename), "-backup");
			string suffixFile2 = FileHelper.GetSuffixFile(_settings.Filename);
			IFileReader fileReader2;
			if (_fileVersion != 7)
			{
				IFileReader fileReader = new FileReaderV8(_settings, options.Errors);
				fileReader2 = fileReader;
			}
			else
			{
				IFileReader fileReader = new FileReaderV7(_settings);
				fileReader2 = fileReader;
			}
			using (IFileReader fileReader3 = fileReader2)
			{
				fileReader3.Open();
				using LiteEngine liteEngine = new LiteEngine(new EngineSettings
				{
					Filename = suffixFile2,
					Collation = options.Collation,
					Password = options.Password
				});
				liteEngine.Pragma("CHECKPOINT", 0);
				liteEngine.RebuildContent(fileReader3);
				if (options.IncludeErrorReport && options.Errors.Count > 0)
				{
					IEnumerable<BsonDocument> errorReport = options.GetErrorReport();
					liteEngine.Insert("_rebuild_errors", errorReport, BsonAutoId.Int32);
				}
				IDictionary<string, BsonValue> pragmas = fileReader3.GetPragmas();
				liteEngine.Pragma("CHECKPOINT", pragmas["CHECKPOINT"]);
				liteEngine.Pragma("TIMEOUT", pragmas["TIMEOUT"]);
				liteEngine.Pragma("LIMIT_SIZE", pragmas["LIMIT_SIZE"]);
				liteEngine.Pragma("UTC_DATE", pragmas["UTC_DATE"]);
				liteEngine.Pragma("USER_VERSION", pragmas["USER_VERSION"]);
				liteEngine.Checkpoint();
			}
			string logFile = FileHelper.GetLogFile(_settings.Filename);
			if (File.Exists(logFile))
			{
				File.Move(logFile, suffixFile);
			}
			FileHelper.Exec(5, delegate
			{
				File.Move(_settings.Filename, backupFilename);
			});
			File.Move(suffixFile2, _settings.Filename);
			return new FileInfo(backupFilename).Length - new FileInfo(_settings.Filename).Length;
		}

		private byte[] ReadFirstBytes(bool useAesStream = true)
		{
			byte[] array = new byte[16384];
			using Stream stream = _settings.CreateDataFactory(useAesStream).GetStream(canWrite: false, sequencial: true);
			stream.Position = 0L;
			stream.Read(array, 0, array.Length);
			return array;
		}
	}
	internal class Snapshot : IDisposable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass24_0
		{
			public bool dirty;

			public Func<BasePage, bool> <>9__0;

			internal bool <GetWritablePages>b__0(BasePage x)
			{
				return x.IsDirty == dirty;
			}
		}

		[CompilerGenerated]
		private sealed class <GetWritablePages>d__24 : IEnumerable<BasePage>, IEnumerable, IEnumerator<BasePage>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BasePage <>2__current;

			private int <>l__initialThreadId;

			private bool dirty;

			public bool <>3__dirty;

			public Snapshot <>4__this;

			private bool includeCollectionPage;

			public bool <>3__includeCollectionPage;

			private <>c__DisplayClass24_0 <>8__1;

			private IEnumerator<BasePage> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <GetWritablePages>d__24(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;
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					Snapshot snapshot = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass24_0();
						<>8__1.dirty = dirty;
						Constants.ENSURE(!snapshot._disposed, "the snapshot is disposed");
						if (snapshot._mode == LockMode.Read)
						{
							return false;
						}
						<>7__wrap1 = snapshot._localPages.Values.Where((BasePage x) => x.IsDirty == <>8__1.dirty).GetEnumerator();
						<>1__state = -3;
						goto IL_010b;
					case 1:
						<>1__state = -3;
						goto IL_010b;
					case 2:
						{
							<>1__state = -1;
							break;
						}
						IL_010b:
						if (<>7__wrap1.MoveNext())
						{
							BasePage current = <>7__wrap1.Current;
							Constants.ENSURE(current.PageType != PageType.Header && current.PageType != PageType.Collection, "local cache cann't contains this page type");
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						if (includeCollectionPage && snapshot._collectionPage != null && snapshot._collectionPage.IsDirty == <>8__1.dirty)
						{
							<>2__current = snapshot._collectionPage;
							<>1__state = 2;
							return true;
						}
						break;
					}
					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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BasePage> IEnumerable<BasePage>.GetEnumerator()
			{
				<GetWritablePages>d__24 <GetWritablePages>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetWritablePages>d__ = this;
				}
				else
				{
					<GetWritablePages>d__ = new <GetWritablePages>d__24(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetWritablePages>d__.dirty = <>3__dirty;
				<GetWritablePages>d__.includeCollectionPage = <>3__includeCollectionPage;
				return <GetWritablePages>d__;
			}

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

		private readonly HeaderPage _header;

		private readonly LockService _locker;

		private readonly DiskReader _reader;

		private readonly DiskService _disk;

		private readonly WalIndexService _walIndex;

		private readonly uint _transactionID;

		private readonly TransactionPages _transPages;

		private readonly int _readVersion;

		private readonly LockMode _mode;

		private readonly string _collectionName;

		private readonly CollectionPage _collectionPage;

		private readonly Dictionary<uint, BasePage> _localPages = new Dictionary<uint, BasePage>();

		private bool _disposed;

		public LockMode Mode => _mode;

		public string CollectionName => _collectionName;

		public CollectionPage CollectionPage => _collectionPage;

		public ICollection<BasePage> LocalPages => _localPages.Values;

		public int ReadVersion => _readVersion;

		public Snapshot(LockMode mode, string collectionName, HeaderPage header, uint transactionID, TransactionPages transPages, LockService locker, WalIndexService walIndex, DiskReader reader, DiskService disk, bool addIfNotExists)
		{
			_mode = mode;
			_collectionName = collectionName;
			_header = header;
			_transactionID = transactionID;
			_transPages = transPages;
			_locker = locker;
			_walIndex = walIndex;
			_reader = reader;
			_disk = disk;
			if (mode == LockMode.Write)
			{
				_locker.EnterLock(_collectionName);
			}
			_readVersion = _walIndex.CurrentReadVersion;
			new CollectionService(_header, _disk, this, _transPages).Get(_collectionName, addIfNotExists, ref _collectionPage);
			if (_collectionPage != null)
			{
				_localPages.Remove(_collectionPage.PageID);
			}
		}

		[IteratorStateMachine(typeof(<GetWritablePages>d__24))]
		public IEnumerable<BasePage> GetWritablePages(bool dirty, bool includeCollectionPage)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetWritablePages>d__24(-2)
			{
				<>4__this = this,
				<>3__dirty = dirty,
				<>3__includeCollectionPage = includeCollectionPage
			};
		}

		public void Clear()
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			if (_mode == LockMode.Read)
			{
				foreach (BasePage value in _localPages.Values)
				{
					value.Buffer.Release();
				}
			}
			_localPages.Clear();
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				Clear();
				_disposed = true;
				if (_mode == LockMode.Read && _collectionPage != null)
				{
					_collectionPage.Buffer.Release();
				}
				if (_mode == LockMode.Write)
				{
					_locker.ExitLock(_collectionName);
				}
			}
		}

		public T GetPage<T>(uint pageID, bool useLatestVersion = false) where T : BasePage
		{
			FileOrigin origin;
			long position;
			int walVersion;
			return GetPage<T>(pageID, out origin, out position, out walVersion, useLatestVersion);
		}

		public T GetPage<T>(uint pageID, out FileOrigin origin, out long position, out int walVersion, bool useLatestVersion = false) where T : BasePage
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			Constants.ENSURE(pageID <= _header.LastPageID, "request page must be less or equals lastest page in data file");
			if (pageID == 0)
			{
				origin = FileOrigin.None;
				position = 0L;
				walVersion = 0;
				return (T)(BasePage)_header;
			}
			if (_localPages.TryGetValue(pageID, out var value))
			{
				origin = FileOrigin.None;
				position = 0L;
				walVersion = 0;
				return (T)value;
			}
			value = ReadPage<T>(pageID, out origin, out position, out walVersion, useLatestVersion);
			_localPages[pageID] = value;
			_transPages.TransactionSize++;
			return (T)value;
		}

		private T ReadPage<T>(uint pageID, out FileOrigin origin, out long position, out int walVersion, bool useLatestVersion = false) where T : BasePage
		{
			if (_transPages.DirtyPages.TryGetValue(pageID, out var value))
			{
				T val = BasePage.ReadPage<T>(_reader.ReadPage(value.Position, _mode == LockMode.Write, FileOrigin.Log));
				origin = FileOrigin.Log;
				position = value.Position;
				walVersion = _readVersion;
				Constants.ENSURE(val.TransactionID == _transactionID, "this page must came from same transaction");
				return val;
			}
			long pageIndex = _walIndex.GetPageIndex(pageID, useLatestVersion ? int.MaxValue : _readVersion, out walVersion);
			if (pageIndex != long.MaxValue)
			{
				T val2 = BasePage.ReadPage<T>(_reader.ReadPage(pageIndex, _mode == LockMode.Write, FileOrigin.Log));
				val2.TransactionID = 0u;
				val2.IsConfirmed = false;
				origin = FileOrigin.Log;
				position = pageIndex;
				return val2;
			}
			long pagePosition = BasePage.GetPagePosition(pageID);
			T val3 = BasePage.ReadPage<T>(_reader.ReadPage(pagePosition, _mode == LockMode.Write, FileOrigin.Data));
			origin = FileOrigin.Data;
			position = pagePosition;
			Constants.ENSURE(!val3.IsConfirmed || val3.TransactionID != 0, "page are not header-clear in data file");
			return val3;
		}

		public DataPage GetFreeDataPage(int bytesLength)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			int num = bytesLength + 4;
			for (int num2 = DataPage.GetMinimumIndexSlot(num); num2 >= 0; num2--)
			{
				uint num3 = _collectionPage.FreeDataPageList[num2];
				if (num3 != uint.MaxValue)
				{
					DataPage page = GetPage<DataPage>(num3);
					Constants.ENSURE(page.PageListSlot == num2, "stored slot must be same as called");
					Constants.ENSURE(page.FreeBytes >= num, "ensure selected page has space enough for this content");
					page.IsDirty = true;
					return page;
				}
			}
			return NewPage<DataPage>();
		}

		public IndexPage GetFreeIndexPage(int bytesLength, ref uint freeIndexPageList)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			IndexPage indexPage;
			if (freeIndexPageList == uint.MaxValue)
			{
				indexPage = NewPage<IndexPage>();
			}
			else
			{
				indexPage = GetPage<IndexPage>(freeIndexPageList);
				Constants.ENSURE(indexPage.FreeBytes > bytesLength, "this page shout be space enouth for this new node");
				Constants.ENSURE(indexPage.PageListSlot == 0, "this page should be in slot #0");
			}
			return indexPage;
		}

		public VectorIndexPage GetFreeVectorPage(int bytesLength, ref uint freeVectorPageList)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			VectorIndexPage vectorIndexPage;
			if (freeVectorPageList == uint.MaxValue)
			{
				vectorIndexPage = NewPage<VectorIndexPage>();
			}
			else
			{
				vectorIndexPage = GetPage<VectorIndexPage>(freeVectorPageList);
				Constants.ENSURE(vectorIndexPage.FreeBytes > bytesLength, "this page shout be space enouth for this new vector node");
				Constants.ENSURE(vectorIndexPage.PageListSlot == 0, "this page should be in slot #0");
			}
			return vectorIndexPage;
		}

		public T NewPage<T>() where T : BasePage
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			Constants.ENSURE(_collectionPage == null, typeof(T) == typeof(CollectionPage), "if no collection page defined yet, must be first request");
			Constants.ENSURE(typeof(T) == typeof(CollectionPage), _collectionPage == null, "there is no new collection page if page already exists");
			uint num = 0u;
			PageBuffer buffer;
			lock (_header)
			{
				if (_header.FreeEmptyPageList != uint.MaxValue)
				{
					BasePage page = GetPage<BasePage>(_header.FreeEmptyPageList, useLatestVersion: true);
					Constants.ENSURE(page.PageType == PageType.Empty, "empty page must be defined as empty type");
					_header.FreeEmptyPageList = page.NextPageID;
					page.NextPageID = uint.MaxValue;
					num = page.PageID;
					buffer = page.Buffer;
				}
				else
				{
					if ((_header.LastPageID + 1) * 8192 > _header.Pragmas.LimitSize)
					{
						throw new LiteException(0, "Maximum data file size has been reached: " + FileHelper.FormatFileSize(_header.Pragmas.LimitSize));
					}
					PageBuffer savepoint = _header.Savepoint();
					try
					{
						num = ++_header.LastPageID;
						buffer = _reader.NewPage();
					}
					catch
					{
						_header.Restore(savepoint);
						throw;
					}
				}
				_transPages.NewPages.Add(num);
			}
			T val = BasePage.CreatePage<T>(buffer, num);
			if (val.PageType != PageType.Collection)
			{
				_localPages[num] = val;
			}
			val.ColID = _collectionPage?.PageID ?? val.PageID;
			val.IsDirty = true;
			_transPages.TransactionSize++;
			return val;
		}

		public void AddOrRemoveFreeDataList(DataPage page)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			byte b = DataPage.FreeIndexSlot(page.FreeBytes);
			byte pageListSlot = page.PageListSlot;
			if (b != pageListSlot || page.ItemsCount <= 0)
			{
				if (pageListSlot != byte.MaxValue)
				{
					RemoveFreeList(page, ref _collectionPage.FreeDataPageList[pageListSlot]);
				}
				if (page.ItemsCount == 0)
				{
					DeletePage(page);
					return;
				}
				AddFreeList(page, ref _collectionPage.FreeDataPageList[b]);
				page.PageListSlot = b;
			}
		}

		public void AddOrRemoveFreeIndexList(IndexPage page, ref uint startPageID)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			byte b = IndexPage.FreeIndexSlot(page.FreeBytes);
			bool flag = page.PageListSlot == 0;
			bool flag2 = b == 0;
			if (page.ItemsCount == 0)
			{
				if (flag)
				{
					RemoveFreeList(page, ref startPageID);
				}
				DeletePage(page);
				return;
			}
			if (flag && !flag2)
			{
				RemoveFreeList(page, ref startPageID);
			}
			else if (!flag && flag2)
			{
				AddFreeList(page, ref startPageID);
			}
			page.PageListSlot = b;
			page.IsDirty = true;
		}

		public void AddOrRemoveFreeVectorList(VectorIndexPage page, ref uint startPageID)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			byte b = VectorIndexPage.FreeListSlot(page.FreeBytes);
			bool flag = page.PageListSlot == 0;
			bool flag2 = b == 0;
			if (page.ItemsCount == 0)
			{
				if (flag)
				{
					RemoveFreeList(page, ref startPageID);
				}
				DeletePage(page);
				return;
			}
			if (flag && !flag2)
			{
				RemoveFreeList(page, ref startPageID);
			}
			else if (!flag && flag2)
			{
				AddFreeList(page, ref startPageID);
			}
			page.PageListSlot = b;
			page.IsDirty = true;
		}

		private void AddFreeList<T>(T page, ref uint startPageID) where T : BasePage
		{
			Constants.ENSURE(page.PrevPageID == uint.MaxValue && page.NextPageID == uint.MaxValue, "only non-linked page can be added in linked list");
			if (startPageID != uint.MaxValue)
			{
				T page2 = GetPage<T>(startPageID);
				page2.PrevPageID = page.PageID;
				page2.IsDirty = true;
			}
			page.PrevPageID = uint.MaxValue;
			page.NextPageID = startPageID;
			page.IsDirty = true;
			Constants.ENSURE(page.PageType == PageType.Data || page.PageType == PageType.Index || page.PageType == PageType.VectorIndex, "only data/index pages must be first on free stack");
			startPageID = page.PageID;
			_collectionPage.IsDirty = true;
		}

		private void RemoveFreeList<T>(T page, ref uint startPageID) where T : BasePage
		{
			if (page.PrevPageID != uint.MaxValue)
			{
				T page2 = GetPage<T>(page.PrevPageID);
				page2.NextPageID = page.NextPageID;
				page2.IsDirty = true;
			}
			if (page.NextPageID != uint.MaxValue)
			{
				T page3 = GetPage<T>(page.NextPageID);
				page3.PrevPageID = page.PrevPageID;
				page3.IsDirty = true;
			}
			if (startPageID == page.PageID)
			{
				startPageID = page.NextPageID;
				Constants.ENSURE(page.NextPageID == uint.MaxValue || GetPage<BasePage>(page.NextPageID).PageType != PageType.Empty, "first page on free stack must be non empty page");
				_collectionPage.IsDirty = true;
			}
			uint prevPageID = (page.NextPageID = uint.MaxValue);
			page.PrevPageID = prevPageID;
			page.IsDirty = true;
		}

		private void DeletePage<T>(T page) where T : BasePage
		{
			Constants.ENSURE(page.PrevPageID == uint.MaxValue && page.NextPageID == uint.MaxValue, "before delete a page, no linked list with any another page");
			Constants.ENSURE(page.ItemsCount == 0 && page.UsedBytes == 0 && page.HighestIndex == byte.MaxValue && page.FragmentedBytes == 0, "no items on page when delete this page");
			Constants.ENSURE(page.PageType == PageType.Data || page.PageType == PageType.Index || page.PageType == PageType.VectorIndex, "only data/index page can be deleted");
			page.MarkAsEmtpy();
			if (_transPages.FirstDeletedPageID == uint.MaxValue)
			{
				Constants.ENSURE(_transPages.DeletedPages == 0, "if has no firstDeletedPageID must has deleted pages");
				_transPages.FirstDeletedPageID = page.PageID;
				_transPages.LastDeletedPageID = page.PageID;
			}
			else
			{
				Constants.ENSURE(_transPages.DeletedPages > 0, "must have at least 1 deleted page");
				page.NextPageID = _transPages.FirstDeletedPageID;
				_transPages.FirstDeletedPageID = page.PageID;
			}
			_transPages.DeletedPages++;
		}

		public void DropCollection(Action safePoint)
		{
			Constants.ENSURE(!_disposed, "the snapshot is disposed");
			IndexService indexService = new IndexService(this, _header.Pragmas.Collation, _disk.MAX_ITEMS_COUNT);
			VectorIndexService vectorIndexService = null;
			_transPages.FirstDeletedPageID = _collectionPage.PageID;
			_transPages.LastDeletedPageID = _collectionPage.PageID;
			_collectionPage.MarkAsEmtpy();
			_transPages.DeletedPages = 1;
			HashSet<uint> hashSet = new HashSet<uint>();
			foreach (CollectionIndex collectionIndex in _collectionPage.GetCollectionIndexes())
			{
				if (collectionIndex.IndexType == 1)
				{
					continue;
				}
				hashSet.Add(collectionIndex.Head.PageID);
				foreach (IndexNode item2 in indexService.FindAll(collectionIndex, 1))
				{
					hashSet.Add(item2.Page.PageID);
					safePoint();
				}
			}
			foreach (var vectorIndex in _collectionPage.GetVectorIndexes())
			{
				VectorIndexMetadata item = vectorIndex.Metadata;
				if (vectorIndexService == null)
				{
					vectorIndexService = new VectorIndexService(this, _header.Pragmas.Collation);
				}
				vectorIndexService.Drop(item);
				safePoint();
			}
			foreach (uint item3 in hashSet)
			{
				IndexPage page = GetPage<IndexPage>(item3);
				page.MarkAsEmtpy();
				page.NextPageID = _transPages.FirstDeletedPageID;
				_transPages.FirstDeletedPageID = page.PageID;
				_transPages.DeletedPages++;
				safePoint();
			}
			uint[] freeDataPageList = _collectionPage.FreeDataPageList;
			for (int i = 0; i < freeDataPageList.Length; i++)
			{
				uint num = freeDataPageList[i];
				while (num != uint.MaxValue)
				{
					DataPage page2 = GetPage<DataPage>(num);
					num = page2.NextPageID;
					page2.MarkAsEmtpy();
					page2.NextPageID = _transPages.FirstDeletedPageID;
					_transPages.FirstDeletedPageID = page2.PageID;
					_transPages.DeletedPages++;
					safePoint();
				}
			}
			_transPages.Commit += delegate(HeaderPage h)
			{
				h.DeleteCollection(_collectionName);
			};
		}

		public override string ToString()
		{
			return $"{_collectionName} (pages: {_localPages.Count})";
		}
	}
	internal class TransactionMonitor : IDisposable
	{
		private readonly Dictionary<uint, TransactionService> _transactions = new Dictionary<uint, TransactionService>();

		private readonly ThreadLocal<TransactionService> _slot = new ThreadLocal<TransactionService>();

		private readonly HeaderPage _header;

		private readonly LockService _locker;

		private readonly DiskService _disk;

		private readonly WalIndexService _walIndex;

		private int _freePages;

		private readonly int _initialSize;

		public ICollection<TransactionService> Transactions => _transactions.Values;

		public int FreePages => _freePages;

		public int InitialSize => _initialSize;

		public TransactionMonitor(HeaderPage header, LockService locker, DiskService disk, WalIndexService walIndex)
		{
			_header = header;
			_locker = locker;
			_disk = disk;
			_walIndex = walIndex;
			_freePages = 100000;
			_initialSize = 1000;
		}

		public TransactionService GetTransaction(bool create, bool queryOnly, out bool isNew)
		{
			TransactionService transactionService = _slot.Value;
			if (create && transactionService == null)
			{
				isNew = true;
				bool flag;
				lock (_transactions)
				{
					if (_transactions.Count >= 100)
					{
						throw new LiteException(0, "Maximum number of transactions reached");
					}
					int initialSize = GetInitialSize();
					flag = _transactions.Values.Any((TransactionService x) => x.ThreadID == Environment.CurrentManagedThreadId);
					transactionService = new TransactionService(_header, _locker, _disk, _walIndex, initialSize, this, queryOnly);
					_transactions[transactionService.TransactionID] = transactionService;
				}
				if (!flag)
				{
					try
					{
						_locker.EnterTransaction();
					}
					catch
					{
						transactionService.Dispose();
						lock (_transactions)
						{
							_freePages += transactionService.MaxTransactionSize;
							_transactions.Remove(transactionService.TransactionID);
						}
						throw;
					}
				}
				if (!queryOnly)
				{
					_slot.Value = transactionService;
				}
			}
			else
			{
				isNew = false;
			}
			return transactionService;
		}

		public bool RemoveTransaction(TransactionService transaction)
		{
			transaction.Dispose();
			lock (_transactions)
			{
				_transactions.Remove(transaction.TransactionID);
				_freePages += transaction.MaxTransactionSize;
				return _transactions.Values.Any((TransactionService x) => x.ThreadID == Environment.CurrentManagedThreadId);
			}
		}

		public void ReleaseTransaction(TransactionService transaction)
		{
			if (!RemoveTransaction(transaction))
			{
				_locker.ExitTransaction();
			}
			if (!transaction.QueryOnly)
			{
				Constants.ENSURE(_slot.Value == transaction, "current thread must contains transaction parameter");
				_slot.Value = null;
			}
		}

		public TransactionService GetThreadTransaction()
		{
			lock (_transactions)
			{
				return _slot.Value ?? _transactions.Values.FirstOrDefault((TransactionService x) => x.ThreadID == Environment.CurrentManagedThreadId);
			}
		}

		private int GetInitialSize()
		{
			if (_freePages >= _initialSize)
			{
				_freePages -= _initialSize;
				return _initialSize;
			}
			int num = 0;
			foreach (TransactionService value in _transactions.Values)
			{
				int num2 = value.MaxTransactionSize / _initialSize;
				value.MaxTransactionSize -= num2;
				num += num2;
			}
			return num;
		}

		private bool TryExtend(TransactionService trans)
		{
			lock (_transactions)
			{
				if (_freePages >= _initialSize)
				{
					trans.MaxTransactionSize += _initialSize;
					_freePages -= _initialSize;
					return true;
				}
				return false;
			}
		}

		public bool CheckSafepoint(TransactionService trans)
		{
			if (trans.Pages.TransactionSize >= trans.MaxTransactionSize)
			{
				return !TryExtend(trans);
			}
			return false;
		}

		public void Dispose()
		{
			if (_transactions.Count <= 0)
			{
				return;
			}
			foreach (TransactionService value in _transactions.Values)
			{
				value.Dispose();
			}
			_transactions.Clear();
		}
	}
	internal class TransactionService : IDisposable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass45_0
		{
			public TransactionService <>4__this;

			public bool commit;

			public int dirty;

			internal IEnumerable<BasePage> <PersistDirtyPages>b__5(Snapshot x)
			{
				return x.GetWritablePages(dirty: true, commit);
			}

			internal IEnumerable<BasePage> <PersistDirtyPages>b__2(Snapshot x)
			{
				return x.GetWritablePages(dirty: false, commit);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass48_0
		{
			public TransactionService <>4__this;

			public uint transactionID;

			public Dictionary<uint, PagePosition> pagePositions;
		}

		private readonly HeaderPage _header;

		private readonly LockService _locker;

		private readonly DiskService _disk;

		private readonly DiskReader _reader;

		private readonly WalIndexService _walIndex;

		private readonly TransactionMonitor _monitor;

		private readonly Dictionary<string, Snapshot> _snapshots = new Dictionary<string, Snapshot>(StringComparer.OrdinalIgnoreCase);

		private readonly TransactionPages _transPages = new TransactionPages();

		private readonly int _threadID = Environment.CurrentManagedThreadId;

		private readonly uint _transactionID;

		private readonly DateTime _startTime;

		private LockMode _mode;

		private TransactionState _state;

		public int ThreadID => _threadID;

		public uint TransactionID => _transactionID;

		public TransactionState State => _state;

		public LockMode Mode => _mode;

		public TransactionPages Pages => _transPages;

		public DateTime StartTime => _startTime;

		public IEnumerable<Snapshot> Snapshots => _snapshots.Values;

		public bool QueryOnly { get; }

		public int MaxTransactionSize { get; set; }

		public List<CursorInfo> OpenCursors { get; } = new List<CursorInfo>();


		public bool ExplicitTransaction { get; set; }

		public TransactionService(HeaderPage header, LockService locker, DiskService disk, WalIndexService walIndex, int maxTransactionSize, TransactionMonitor monitor, bool queryOnly)
		{
			_header = header;
			_locker = locker;
			_disk = disk;
			_walIndex = walIndex;
			_monitor = monitor;
			QueryOnly = queryOnly;
			MaxTransactionSize = maxTransactionSize;
			_transactionID = walIndex.NextTransactionID();
			_startTime = DateTime.UtcNow;
			_reader = _disk.GetReader();
		}

		~TransactionService()
		{
			Dispose(dispose: false);
		}

		public Snapshot CreateSnapshot(LockMode mode, string collection, bool addIfNotExists)
		{
			Constants.ENSURE(_state == TransactionState.Active, "transaction must be active to create new snapshot");
			if (!_snapshots.TryGetValue(collection, out var value))
			{
				value = (_snapshots[collection] = create());
			}
			else if ((mode == LockMode.Write && value.Mode == LockMode.Read) || (addIfNotExists && value.CollectionPage == null))
			{
				value.Dispose();
				_snapshots.Remove(collection);
				value = (_snapshots[collection] = create());
			}
			if (mode == LockMode.Write)
			{
				_mode = LockMode.Write;
			}
			return value;
			Snapshot create()
			{
				return new Snapshot(mode, collection, _header, _transactionID, _transPages, _locker, _walIndex, _reader, _disk, addIfNotExists);
			}
		}

		public void Safepoint()
		{
			if (_state != 0)
			{
				throw new LiteException(0, "This transaction are invalid state");
			}
			if (!_monitor.CheckSafepoint(this))
			{
				return;
			}
			if (_mode == LockMode.Write)
			{
				PersistDirtyPages(commit: false);
			}
			foreach (Snapshot value in _snapshots.Values)
			{
				value.Clear();
			}
			_transPages.TransactionSize = 0;
		}

		private int PersistDirtyPages(bool commit)
		{
			<>c__DisplayClass45_0 CS$<>8__locals0 = new <>c__DisplayClass45_0();
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.commit = commit;
			CS$<>8__locals0.dirty = 0;
			int result = _disk.WriteLogDisk(source());
			_disk.DiscardCleanPages(from x in _snapshots.Values.Where((Snapshot x) => x.Mode == LockMode.Write).SelectMany((Snapshot x) => x.GetWritablePages(dirty: false, CS$<>8__locals0.commit))
				select x.Buffer);
			return result;
			[IteratorStateMachine(typeof(<>c__DisplayClass45_0.<<PersistDirtyPages>g__source|0>d))]
			IEnumerable<PageBuffer> source()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass45_0.<<PersistDirtyPages>g__source|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		public void Commit()
		{
			Constants.ENSURE(_state == TransactionState.Active, "transaction must be active to commit (current state: {0})", _state);
			if (_mode == LockMode.Write || _transPages.HeaderChanged)
			{
				lock (_header)
				{
					if (PersistDirtyPages(commit: true) > 0)
					{
						_walIndex.ConfirmTransaction(_transactionID, _transPages.DirtyPages.Values);
					}
				}
			}
			foreach (Snapshot value in _snapshots.Values)
			{
				value.Dispose();
			}
			_state = TransactionState.Committed;
		}

		public void Rollback()
		{
			Constants.ENSURE(_state == TransactionState.Active, "transaction must be active to rollback (current state: {0})", _state);
			if (_transPages.NewPages.Count > 0)
			{
				ReturnNewPages();
			}
			foreach (Snapshot value in _snapshots.Values)
			{
				if (value.Mode == LockMode.Write)
				{
					_disk.DiscardDirtyPages(from x in value.GetWritablePages(dirty: true, includeCollectionPage: true)
						select x.Buffer into x
						where x.ShareCounter == Constants.BUFFER_WRITABLE
						select x);
					_disk.DiscardCleanPages(from x in value.GetWritablePages(dirty: false, includeCollectionPage: true)
						select x.Buffer into x
						where x.ShareCounter == Constants.BUFFER_WRITABLE
						select x);
				}
				value.Dispose();
			}
			_state = TransactionState.Aborted;
		}

		private void ReturnNewPages()
		{
			<>c__DisplayClass48_0 CS$<>8__locals0 = new <>c__DisplayClass48_0();
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.transactionID = _walIndex.NextTransactionID();
			lock (_header)
			{
				CS$<>8__locals0.pagePositions = new Dictionary<uint, PagePosition>();
				PageBuffer savepoint = _header.Savepoint();
				try
				{
					_disk.WriteLogDisk(source());
				}
				catch
				{
					_header.Restore(savepoint);
					throw;
				}
				_walIndex.ConfirmTransaction(CS$<>8__locals0.transactionID, CS$<>8__locals0.pagePositions.Values);
			}
			[IteratorStateMachine(typeof(<>c__DisplayClass48_0.<<ReturnNewPages>g__source|0>d))]
			IEnumerable<PageBuffer> source()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass48_0.<<ReturnNewPages>g__source|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		public void Dispose()
		{
			Dispose(dispose: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool dispose)
		{
			if (_state == TransactionState.Disposed)
			{
				return;
			}
			Constants.ENSURE(_state != TransactionState.Disposed, "transaction must be active before call Done");
			if (_state == TransactionState.Active && _snapshots.Count > 0)
			{
				foreach (Snapshot item in _snapshots.Values.Where((Snapshot x) => x.Mode == LockMode.Write))
				{
					_disk.DiscardDirtyPages(from x in item.GetWritablePages(dirty: true, includeCollectionPage: true)
						select x.Buffer into x
						where x.ShareCounter == Constants.BUFFER_WRITABLE
						select x);
					_disk.DiscardCleanPages(from x in item.GetWritablePages(dirty: false, includeCollectionPage: true)
						select x.Buffer into x
						where x.ShareCounter == Constants.BUFFER_WRITABLE
						select x);
				}
				foreach (Snapshot item2 in _snapshots.Values.Where((Snapshot x) => x.Mode == LockMode.Read))
				{
					foreach (BasePage localPage in item2.LocalPages)
					{
						localPage.Buffer.Release();
					}
					item2.CollectionPage?.Buffer.Release();
				}
			}
			_reader.Dispose();
			_state = TransactionState.Disposed;
			if (!dispose)
			{
				_monitor.RemoveTransaction(this);
			}
		}
	}
	internal sealed class VectorIndexService
	{
		private readonly struct NodeDistance
		{
			public PageAddress Address { get; }

			public double Distance { get; }

			public double Similarity { get; }

			public NodeDistance(PageAddress address, double distance, double similarity)
			{
				Address = address;
				Distance = (double.IsNaN(distance) ? double.PositiveInfinity : distance);
				Similarity = similarity;
			}
		}

		private const int EfConstruction = 24;

		private const int DefaultEfSearch = 32;

		private readonly Snapshot _snapshot;

		private readonly Collation _collation;

		private readonly Random _random = new Random();

		private DataService _vectorData;

		public int LastVisitedCount { get; private set; }

		public VectorIndexService(Snapshot snapshot, Collation collation)
		{
			_snapshot = snapshot;
			_collation = collation;
		}

		public void Upsert(CollectionIndex index, VectorIndexMetadata metadata, BsonDocument document, PageAddress dataBlock)
		{
			if (!TryExtractVector(index.BsonExpr.ExecuteScalar(document, _collation), metadata.Dimensions, out var vector))
			{
				Delete(metadata, dataBlock);
				return;
			}
			Delete(metadata, dataBlock);
			Insert(metadata, dataBlock, vector);
		}

		public void Delete(VectorIndexMetadata metadata, PageAddress dataBlock)
		{
			if (TryFindNode(metadata, dataBlock, out var address, out var node))
			{
				RemoveNode(metadata, address, node);
			}
		}

		public IEnumerable<(BsonDocument Document, double Distance)> Search(VectorIndexMetadata metadata, float[] target, double maxDistance, int? limit)
		{
			if (metadata.Root.IsEmpty)
			{
				LastVisitedCount = 0;
				return Enumerable.Empty<(BsonDocument, double)>();
			}
			DataService dataService = new DataService(_snapshot, uint.MaxValue);
			Dictionary<PageAddress, float[]> vectorCache = new Dictionary<PageAddress, float[]>();
			HashSet<PageAddress> globalVisited = new HashSet<PageAddress>();
			LastVisitedCount = 0;
			PageAddress root = metadata.Root;
			int num = GetNode(root).LevelCount - 1;
			PageAddress pageAddress = root;
			for (int num2 = num; num2 > 0; num2--)
			{
				pageAddress = GreedySearch(metadata, target, pageAddress, num2, vectorCache, globalVisited);
			}
			int num3 = ((limit.HasValue && limit.Value > 0) ? Math.Max(limit.Value * 4, 32) : 32);
			List<NodeDistance> list = SearchLayer(metadata, target, pageAddress, 0, num3, num3, globalVisited, vectorCache);
			List<(BsonDocument, double, double)> list2 = new List<(BsonDocument, double, double)>();
			double num4 = ((metadata.Metric == VectorDistanceMetric.DotProduct) ? double.PositiveInfinity : maxDistance);
			double num5 = ((metadata.Metric == VectorDistanceMetric.DotProduct && !double.IsPositiveInfinity(maxDistance) && maxDistance < double.MaxValue) ? maxDistance : double.NegativeInfinity);
			double num6 = num5;
			foreach (NodeDistance item in list)
			{
				double distance = item.Distance;
				bool num7;
				if (metadata.Metric != VectorDistanceMetric.DotProduct)
				{
					if (double.IsNaN(distance))
					{
						continue;
					}
					num7 = distance <= num4;
				}
				else
				{
					if (double.IsNaN(item.Similarity))
					{
						continue;
					}
					num7 = item.Similarity >= num6;
				}
				if (num7)
				{
					VectorIndexNode node = GetNode(item.Address);
					using BufferReader bufferReader = new BufferReader(dataService.Read(node.DataBlock));
					BsonDocument value = bufferReader.ReadDocument().GetValue();
					value.RawId = node.DataBlock;
					list2.Add((value, item.Distance, item.Similarity));
				}
			}
			if (metadata.Metric == VectorDistanceMetric.DotProduct)
			{
				list2 = list2.OrderByDescending<(BsonDocument, double, double), double>(((BsonDocument Document, double Distance, double Similarity) x) => x.Similarity).ToList();
				if (limit.HasValue)
				{
					list2 = list2.Take(limit.Value).ToList();
					if (list2.Count == limit.Value)
					{
						num6 = Math.Max(num5, list2.Min<(BsonDocument, double, double)>(((BsonDocument Document, double Distance, double Similarity) x) => x.Similarity));
					}
				}
				return list2.Select<(BsonDocument, double, double), (BsonDocument, double)>(((BsonDocument Document, double Distance, double Similarity) x) => (x.Document, x.Similarity));
			}
			list2 = list2.OrderBy<(BsonDocument, double, double), double>(((BsonDocument Document, double Distance, double Similarity) x) => x.Distance).ToList();
			if (limit.HasValue)
			{
				list2 = list2.Take(limit.Value).ToList();
				if (list2.Count == limit.Value)
				{
					num4 = Math.Min(num4, list2.Max<(BsonDocument, double, double)>(((BsonDocument Document, double Distance, double Similarity) x) => x.Distance));
				}
			}
			return list2.Select<(BsonDocument, double, double), (BsonDocument, double)>(((BsonDocument Document, double Distance, double Similarity) x) => (x.Document, x.Distance));
		}

		public void Drop(VectorIndexMetadata metadata)
		{
			ClearTree(metadata);
			metadata.Root = PageAddress.Empty;
			metadata.Reserved = uint.MaxValue;
			_snapshot.CollectionPage.IsDirty = true;
		}

		public static double ComputeDistance(float[] candidate, float[] target, VectorDistanceMetric metric, out double similarity)
		{
			similarity = double.NaN;
			if (candidate.Length != target.Length)
			{
				return double.NaN;
			}
			switch (metric)
			{
			case VectorDistanceMetric.Cosine:
				return ComputeCosineDistance(candidate, target);
			case VectorDistanceMetric.Euclidean:
				return ComputeEuclideanDistance(candidate, target);
			case VectorDistanceMetric.DotProduct:
				similarity = ComputeDotProduct(candidate, target);
				return 0.0 - similarity;
			default:
				throw new ArgumentOutOfRangeException("metric");
			}
		}

		private void Insert(VectorIndexMetadata metadata, PageAddress dataBlock, float[] vector)
		{
			byte b = SampleLevel();
			bool storesInline;
			int length = VectorIndexNode.GetLength(vector.Length, out storesInline);
			uint freeVectorPageList = metadata.Reserved;
			VectorIndexPage freeVectorPage = _snapshot.GetFreeVectorPage(length, ref freeVectorPageList);
			metadata.Reserved = freeVectorPageList;
			PageAddress pageAddress = PageAddress.Empty;
			VectorIndexNode vectorIndexNode;
			try
			{
				if (!storesInline)
				{
					pageAddress = StoreVector(vector);
				}
				vectorIndexNode = freeVectorPage.InsertNode(dataBlock, vector, length, b, pageAddress);
				freeVectorPageList = metadata.Reserved;
				metadata.Reserved = uint.MaxValue;
				_snapshot.AddOrRemoveFreeVectorList(freeVectorPage, ref freeVectorPageList);
				metadata.Reserved = freeVectorPageList;
			}
			catch
			{
				if (!storesInline && !pageAddress.IsEmpty)
				{
					ReleaseVectorData(pageAddress);
				}
				metadata.Reserved = freeVectorPageList;
				throw;
			}
			_snapshot.CollectionPage.IsDirty = true;
			PageAddress newAddress = vectorIndexNode.Position;
			if (metadata.Root.IsEmpty)
			{
				metadata.Root = newAddress;
				_snapshot.CollectionPage.IsDirty = true;
				return;
			}
			Dictionary<PageAddress, float[]> vectorCache = new Dictionary<PageAddress, float[]> { [newAddress] = vector };
			PageAddress root = metadata.Root;
			VectorIndexNode node = GetNode(root);
			int num = node.LevelCount - 1;
			int num2 = b - 1;
			if (num2 > num)
			{
				metadata.Root = newAddress;
				_snapshot.CollectionPage.IsDirty = true;
				num = num2;
			}
			PageAddress pageAddress2 = root;
			for (int num3 = num; num3 > num2; num3--)
			{
				pageAddress2 = GreedySearch(metadata, vector, pageAddress2, num3, vectorCache, null);
			}
			for (int num4 = Math.Min(node.LevelCount - 1, num2); num4 >= 0; num4--)
			{
				List<NodeDistance> source = SearchLayer(metadata, vector, pageAddress2, num4, 8, 24, null, vectorCache);
				List<NodeDistance> list = SelectNeighbors(source.Where((NodeDistance x) => x.Address != newAddress).ToList(), 8);
				List<PageAddress> list2 = list.Select((NodeDistance x) => x.Address).ToList();
				vectorIndexNode.SetNeighbors(num4, list2);
				foreach (PageAddress item in list2)
				{
					if (!EnsureBidirectional(metadata, item, newAddress, num4, vectorCache))
					{
						vectorIndexNode.RemoveNeighbor(num4, item);
					}
				}
				if (list.Count > 0)
				{
					pageAddress2 = list[0].Address;
				}
			}
		}

		private PageAddress GreedySearch(VectorIndexMetadata metadata, float[] target, PageAddress start, int level, Dictionary<PageAddress, float[]> vectorCache, HashSet<PageAddress> globalVisited)
		{
			PageAddress pageAddress = start;
			RegisterVisit(globalVisited, pageAddress);
			double similarity;
			double num = NormalizeDistance(ComputeDistance(GetVector(metadata, pageAddress, vectorCache), target, metadata.Metric, out similarity));
			bool flag = true;
			while (flag)
			{
				flag = false;
				foreach (PageAddress neighbor in GetNode(pageAddress).GetNeighbors(level))
				{
					if (!neighbor.IsEmpty)
					{
						RegisterVisit(globalVisited, neighbor);
						double num2 = NormalizeDistance(ComputeDistance(GetVector(metadata, neighbor, vectorCache), target, metadata.Metric, out similarity));
						if (num2 < num)
						{
							pageAddress = neighbor;
							num = num2;
							flag = true;
						}
					}
				}
			}
			return pageAddress;
		}

		private List<NodeDistance> SearchLayer(VectorIndexMetadata metadata, float[] target, PageAddress entryPoint, int level, int maxResults, int explorationFactor, HashSet<PageAddress> globalVisited, Dictionary<PageAddress, float[]> vectorCache)
		{
			List<NodeDistance> list = new List<NodeDistance>();
			List<NodeDistance> list2 = new List<NodeDistance>();
			HashSet<PageAddress> hashSet = new HashSet<PageAddress>();
			if (entryPoint.IsEmpty)
			{
				return list;
			}
			double similarity;
			double distance = ComputeDistance(GetVector(metadata, entryPoint, vectorCache), target, metadata.Metric, out similarity);
			NodeDistance item = new NodeDistance(entryPoint, distance, similarity);
			InsertOrdered(list, item, Math.Max(1, explorationFactor));
			list2.Add(item);
			hashSet.Add(entryPoint);
			RegisterVisit(globalVisited, entryPoint);
			while (list2.Count > 0)
			{
				int minimumIndex = GetMinimumIndex(list2);
				NodeDistance nodeDistance = list2[minimumIndex];
				list2.RemoveAt(minimumIndex);
				double num = ((list.Count >= explorationFactor) ? list[list.Count - 1].Distance : double.PositiveInfinity);
				if (nodeDistance.Distance > num)
				{
					continue;
				}
				foreach (PageAddress neighbor in GetNode(nodeDistance.Address).GetNeighbors(level))
				{
					if (!neighbor.IsEmpty && hashSet.Add(neighbor))
					{
						RegisterVisit(globalVisited, neighbor);
						double similarity2;
						double distance2 = ComputeDistance(GetVector(metadata, neighbor, vectorCache), target, metadata.Metric, out similarity2);
						NodeDistance item2 = new NodeDistance(neighbor, distance2, similarity2);
						if (InsertOrdered(list, item2, Math.Max(1, explorationFactor)))
						{
							list2.Add(item2);
						}
					}
				}
			}
			return SelectNeighbors(list, Math.Max(1, maxResults));
		}

		private bool EnsureBidirectional(VectorIndexMetadata metadata, PageAddress source, PageAddress target, int level, Dictionary<PageAddress, float[]> vectorCache)
		{
			VectorIndexNode node = GetNode(source);
			List<PageAddress> list = (from x in node.GetNeighbors(level)
				where !x.IsEmpty
				select x).ToList();
			List<PageAddress> list2 = list.ToList();
			if (!list.Contains(target))
			{
				list.Add(target);
			}
			IReadOnlyList<PageAddress> readOnlyList = PruneNeighbors(metadata, source, list, vectorCache);
			node.SetNeighbors(level, readOnlyList);
			foreach (PageAddress item in list2)
			{
				if (!readOnlyList.Contains(item))
				{
					RemoveBackLink(item, source, level);
				}
			}
			return readOnlyList.Contains(target);
		}

		private void RemoveBackLink(PageAddress source, PageAddress target, int level)
		{
			if (!source.IsEmpty && !target.IsEmpty)
			{
				VectorIndexNode node = GetNode(source);
				if (level >= 0 && level < node.LevelCount)
				{
					node.RemoveNeighbor(level, target);
				}
			}
		}

		private IReadOnlyList<PageAddress> PruneNeighbors(VectorIndexMetadata metadata, PageAddress source, List<PageAddress> neighbors, Dictionary<PageAddress, float[]> vectorCache)
		{
			HashSet<PageAddress> hashSet = new HashSet<PageAddress>(neighbors.Where((PageAddress x) => !x.IsEmpty && x != source));
			if (hashSet.Count == 0)
			{
				return Array.Empty<PageAddress>();
			}
			float[] vector = GetVector(metadata, source, vectorCache);
			List<NodeDistance> list = new List<NodeDistance>();
			foreach (PageAddress item in hashSet)
			{
				float[] vector2 = GetVector(metadata, item, vectorCache);
				double similarity;
				double distance = ComputeDistance(vector, vector2, metadata.Metric, out similarity);
				list.Add(new NodeDistance(item, distance, double.NaN));
			}
			return (from x in SelectNeighbors(list, 8)
				select x.Address).ToList();
		}

		private void RemoveNode(VectorIndexMetadata metadata, PageAddress address, VectorIndexNode node)
		{
			PageAddress start = PageAddress.Empty;
			for (int i = 0; i < node.LevelCount; i++)
			{
				if (!start.IsEmpty)
				{
					break;
				}
				foreach (PageAddress neighbor in node.GetNeighbors(i))
				{
					if (!neighbor.IsEmpty)
					{
						start = neighbor;
						break;
					}
				}
			}
			for (int j = 0; j < node.LevelCount; j++)
			{
				foreach (PageAddress neighbor2 in node.GetNeighbors(j))
				{
					if (!neighbor2.IsEmpty)
					{
						GetNode(neighbor2).RemoveNeighbor(j, address);
					}
				}
			}
			if (metadata.Root == address)
			{
				metadata.Root = SelectNewRoot(metadata, address, start);
				_snapshot.CollectionPage.IsDirty = true;
			}
			ReleaseNode(metadata, node);
		}

		private PageAddress SelectNewRoot(VectorIndexMetadata metadata, PageAddress removed, PageAddress start)
		{
			if (start.IsEmpty)
			{
				return PageAddress.Empty;
			}
			PageAddress result = PageAddress.Empty;
			byte b = 0;
			HashSet<PageAddress> hashSet = new HashSet<PageAddress>();
			Queue<PageAddress> queue = new Queue<PageAddress>();
			queue.Enqueue(start);
			while (queue.Count > 0)
			{
				PageAddress pageAddress = queue.Dequeue();
				if (pageAddress == removed || !hashSet.Add(pageAddress))
				{
					continue;
				}
				VectorIndexNode node = GetNode(pageAddress);
				byte levelCount = node.LevelCount;
				if (result.IsEmpty || levelCount > b)
				{
					result = pageAddress;
					b = levelCount;
				}
				for (int i = 0; i < levelCount; i++)
				{
					foreach (PageAddress neighbor in node.GetNeighbors(i))
					{
						if (!neighbor.IsEmpty && neighbor != removed)
						{
							queue.Enqueue(neighbor);
						}
					}
				}
			}
			return result;
		}

		private bool TryFindNode(VectorIndexMetadata metadata, PageAddress dataBlock, out PageAddress address, out VectorIndexNode node)
		{
			address = PageAddress.Empty;
			node = null;
			if (metadata.Root.IsEmpty)
			{
				return false;
			}
			HashSet<PageAddress> hashSet = new HashSet<PageAddress>();
			Queue<PageAddress> queue = new Queue<PageAddress>();
			queue.Enqueue(metadata.Root);
			while (queue.Count > 0)
			{
				PageAddress pageAddress = queue.Dequeue();
				if (!hashSet.Add(pageAddress))
				{
					continue;
				}
				VectorIndexNode node2 = GetNode(pageAddress);
				if (node2.DataBlock == dataBlock)
				{
					address = pageAddress;
					node = node2;
					return true;
				}
				for (int i = 0; i < node2.LevelCount; i++)
				{
					foreach (PageAddress neighbor in node2.GetNeighbors(i))
					{
						if (!neighbor.IsEmpty)
						{
							queue.Enqueue(neighbor);
						}
					}
				}
			}
			return false;
		}

		private void ClearTree(VectorIndexMetadata metadata)
		{
			if (metadata.Root.IsEmpty)
			{
				return;
			}
			HashSet<PageAddress> hashSet = new HashSet<PageAddress>();
			Stack<PageAddress> stack = new Stack<PageAddress>();
			stack.Push(metadata.Root);
			while (stack.Count > 0)
			{
				PageAddress pageAddress = stack.Pop();
				if (!hashSet.Add(pageAddress))
				{
					continue;
				}
				VectorIndexNode node = GetNode(pageAddress);
				for (int i = 0; i < node.LevelCount; i++)
				{
					foreach (PageAddress neighbor in node.GetNeighbors(i))
					{
						if (!neighbor.IsEmpty && !hashSet.Contains(neighbor))
						{
							stack.Push(neighbor);
						}
					}
				}
				ReleaseNode(metadata, node);
			}
		}

		private void ReleaseNode(VectorIndexMetadata metadata, VectorIndexNode node)
		{
			ReleaseVectorData(node);
			VectorIndexPage page = node.Page;
			page.DeleteNode(node.Position.Index);
			uint startPageID = metadata.Reserved;
			metadata.Reserved = uint.MaxValue;
			_snapshot.AddOrRemoveFreeVectorList(page, ref startPageID);
			metadata.Reserved = startPageID;
		}

		private VectorIndexNode GetNode(PageAddress address)
		{
			return _snapshot.GetPage<VectorIndexPage>(address.PageID).GetNode(address.Index);
		}

		private float[] GetVector(VectorIndexMetadata metadata, PageAddress address, Dictionary<PageAddress, float[]> cache)
		{
			if (!cache.TryGetValue(address, out var value))
			{
				VectorIndexNode node = GetNode(address);
				value = (cache[address] = (node.HasInlineVector ? node.ReadVector() : ReadExternalVector(node, metadata)));
			}
			return value;
		}

		private float[] ReadExternalVector(VectorIndexNode node, VectorIndexMetadata metadata)
		{
			if (node.ExternalVector.IsEmpty)
			{
				return Array.Empty<float>();
			}
			ushort dimensions = metadata.Dimensions;
			if (dimensions == 0)
			{
				return Array.Empty<float>();
			}
			int num = dimensions * 4;
			float[] array = new float[dimensions];
			int num2 = 0;
			foreach (BufferSlice item in GetVectorDataService().Read(node.ExternalVector))
			{
				if (num2 >= num)
				{
					break;
				}
				int num3 = Math.Min(item.Count, num - num2);
				if (((uint)num3 & 3u) != 0)
				{
					throw new LiteException(0, "Vector data block is corrupted.");
				}
				Buffer.BlockCopy(item.Array, item.Offset, array, num2, num3);
				num2 += num3;
			}
			if (num2 != num)
			{
				throw new LiteException(0, "Vector data block is incomplete.");
			}
			return array;
		}

		private PageAddress StoreVector(float[] vector)
		{
			if (vector.Length == 0)
			{
				return PageAddress.Empty;
			}
			int num = vector.Length * 4;
			int i = 0;
			PageAddress result = PageAddress.Empty;
			DataBlock dataBlock = null;
			int num3;
			for (; i < num; i += num3)
			{
				int num2 = num - i;
				num3 = Math.Min(num2, 8150);
				if (((uint)num3 & 3u) != 0)
				{
					num3 -= num3 & 3;
				}
				if (num3 <= 0)
				{
					num3 = num2;
				}
				DataPage freeDataPage = _snapshot.GetFreeDataPage(num3 + 6);
				DataBlock dataBlock2 = freeDataPage.InsertBlock(num3, i > 0);
				if (dataBlock != null)
				{
					dataBlock.SetNextBlock(dataBlock2.Position);
				}
				else
				{
					result = dataBlock2.Position;
				}
				Buffer.BlockCopy(vector, i, dataBlock2.Buffer.Array, dataBlock2.Buffer.Offset, num3);
				_snapshot.AddOrRemoveFreeDataList(freeDataPage);
				dataBlock = dataBlock2;
			}
			return result;
		}

		private void ReleaseVectorData(VectorIndexNode node)
		{
			if (!node.HasInlineVector)
			{
				ReleaseVectorData(node.ExternalVector);
			}
		}

		private void ReleaseVectorData(PageAddress address)
		{
			if (!address.IsEmpty)
			{
				GetVectorDataService().Delete(address);
			}
		}

		private DataService GetVectorDataService()
		{
			return _vectorData ?? (_vectorData = new DataService(_snapshot, uint.MaxValue));
		}

		private byte SampleLevel()
		{
			int i = 1;
			lock (_random)
			{
				for (; i < 4; i++)
				{
					if (!(_random.NextDouble() < 0.5))
					{
						break;
					}
				}
			}
			return (byte)i;
		}

		private void RegisterVisit(HashSet<PageAddress> visited, PageAddress address)
		{
			if (!address.IsEmpty && (visited == null || visited.Add(address)))
			{
				LastVisitedCount++;
			}
		}

		private static int GetMinimumIndex(List<NodeDistance> candidates)
		{
			int result = 0;
			double distance = candidates[0].Distance;
			for (int i = 1; i < candidates.Count; i++)
			{
				if (candidates[i].Distance < distance)
				{
					distance = candidates[i].Distance;
					result = i;
				}
			}
			return result;
		}

		private static bool InsertOrdered(List<NodeDistance> list, NodeDistance item, int maxSize)
		{
			if (maxSize <= 0)
			{
				return false;
			}
			bool result = false;
			int num = list.FindIndex((NodeDistance x) => item.Distance < x.Distance);
			if (num >= 0)
			{
				list.Insert(num, item);
				result = true;
			}
			else if (list.Count < maxSize)
			{
				list.Add(item);
				result = true;
			}
			if (list.Count > maxSize)
			{
				list.RemoveAt(list.Count - 1);
			}
			return result;
		}

		private List<NodeDistance> SelectNeighbors(List<NodeDistance> candidates, int maxNeighbors)
		{
			if (candidates.Count == 0 || maxNeighbors <= 0)
			{
				return new List<NodeDistance>();
			}
			HashSet<PageAddress> seen = new HashSet<PageAddress>();
			return (from x in candidates
				orderby x.Distance
				where seen.Add(x.Address)
				select x).Take(maxNeighbors).ToList();
		}

		private static double NormalizeDistance(double distance)
		{
			if (!double.IsNaN(distance))
			{
				return distance;
			}
			return double.PositiveInfinity;
		}

		private static double ComputeCosineDistance(float[] candidate, float[] target)
		{
			double num = 0.0;
			double num2 = 0.0;
			double num3 = 0.0;
			for (int i = 0; i < candidate.Length; i++)
			{
				float num4 = candidate[i];
				float num5 = target[i];
				num += (double)(num4 * num5);
				num2 += (double)(num4 * num4);
				num3 += (double)(num5 * num5);
			}
			if (num2 == 0.0 || num3 == 0.0)
			{
				return double.NaN;
			}
			double num6 = num / (Math.Sqrt(num2) * Math.Sqrt(num3));
			return 1.0 - num6;
		}

		private static double ComputeEuclideanDistance(float[] candidate, float[] target)
		{
			double num = 0.0;
			for (int i = 0; i < candidate.Length; i++)
			{
				float num2 = candidate[i] - target[i];
				num += (double)(num2 * num2);
			}
			return Math.Sqrt(num);
		}

		private static double ComputeDotProduct(float[] candidate, float[] target)
		{
			double num = 0.0;
			for (int i = 0; i < candidate.Length; i++)
			{
				num += (double)(candidate[i] * target[i]);
			}
			return num;
		}

		private static bool TryExtractVector(BsonValue value, ushort expectedDimensions, out float[] vector)
		{
			vector = null;
			if (value.IsNull)
			{
				return false;
			}
			float[] array;
			if (value.Type == BsonType.Vector)
			{
				array = value.AsVector.ToArray();
			}
			else
			{
				if (!value.IsArray)
				{
					return false;
				}
				array = new float[value.AsArray.Count];
				for (int i = 0; i < array.Length; i++)
				{
					BsonValue bsonValue = value.AsArray[i];
					try
					{
						array[i] = (float)bsonValue.AsDouble;
					}
					catch
					{
						return false;
					}
				}
			}
			if (array.Length != expectedDimensions)
			{
				return false;
			}
			vector = array;
			return true;
		}
	}
	internal class WalIndexService
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_0
		{
			public WalIndexService <>4__this;

			public int counter;
		}

		private readonly DiskService _disk;

		private readonly LockService _locker;

		private readonly Dictionary<uint, List<KeyValuePair<int, long>>> _index = new Dictionary<uint, List<KeyValuePair<int, long>>>();

		private readonly ReaderWriterLockSlim _indexLock = new ReaderWriterLockSlim();

		private readonly HashSet<uint> _confirmTransactions = new HashSet<uint>();

		private int _currentReadVersion;

		private int _lastTransactionID;

		public int CurrentReadVersion
		{
			get
			{
				_indexLock.TryEnterReadLock(-1);
				try
				{
					return _currentReadVersion;
				}
				finally
				{
					_indexLock.ExitReadLock();
				}
			}
		}

		public int LastTransactionID => _lastTransactionID;

		public WalIndexService(DiskService disk, LockService locker)
		{
			_disk = disk;
			_locker = locker;
		}

		public void Clear()
		{
			_indexLock.TryEnterWriteLock(-1);
			try
			{
				_confirmTransactions.Clear();
				_index.Clear();
				_lastTransactionID = 0;
				_currentReadVersion = 0;
				_disk.Cache.Clear();
				_disk.SetLength(0L, FileOrigin.Log);
			}
			finally
			{
				_indexLock.ExitWriteLock();
			}
		}

		public uint NextTransactionID()
		{
			return (uint)Interlocked.Increment(ref _lastTransactionID);
		}

		public long GetPageIndex(uint pageID, int version, out int walVersion)
		{
			if (version == 0)
			{
				walVersion = 0;
				return long.MaxValue;
			}
			_indexLock.TryEnterReadLock(-1);
			try
			{
				if (_index.TryGetValue(pageID, out var value))
				{
					int num = value.Count;
					long result = long.MaxValue;
					walVersion = version;
					while (num > 0)
					{
						num--;
						KeyValuePair<int, long> keyValuePair = value[num];
						if (keyValuePair.Key <= version)
						{
							walVersion = keyValuePair.Key;
							result = keyValuePair.Value;
							break;
						}
					}
					return result;
				}
				walVersion = int.MaxValue;
				return long.MaxValue;
			}
			finally
			{
				_indexLock.ExitReadLock();
			}
		}

		public void ConfirmTransaction(uint transactionID, ICollection<PagePosition> pagePositions)
		{
			_indexLock.TryEnterWriteLock(-1);
			try
			{
				_currentReadVersion++;
				foreach (PagePosition pagePosition in pagePositions)
				{
					if (!_index.TryGetValue(pagePosition.PageID, out var value))
					{
						value = new List<KeyValuePair<int, long>>();
						_index.Add(pagePosition.PageID, value);
					}
					value.Add(new KeyValuePair<int, long>(_currentReadVersion, pagePosition.Position));
				}
				_confirmTransactions.Add(transactionID);
			}
			finally
			{
				_indexLock.ExitWriteLock();
			}
		}

		public void RestoreIndex(ref HeaderPage header)
		{
			Dictionary<long, List<PagePosition>> dictionary = new Dictionary<long, List<PagePosition>>();
			long num = 0L;
			foreach (PageBuffer item2 in _disk.ReadFull(FileOrigin.Log))
			{
				if (item2.IsBlank())
				{
					num += 8192;
					continue;
				}
				uint pageID = item2.ReadUInt32(0);
				bool num2 = item2.ReadBool(18);
				uint num3 = item2.ReadUInt32(14);
				PagePosition item = new PagePosition(pageID, num);
				if (dictionary.TryGetValue(num3, out var value))
				{
					value.Add(item);
				}
				else
				{
					dictionary[num3] = new List<PagePosition> { item };
				}
				if (num2)
				{
					ConfirmTransaction(num3, dictionary[num3]);
					if (item2.ReadByte(4) == 1)
					{
						PageBuffer buffer = header.Buffer;
						Buffer.BlockCopy(item2.Array, item2.Offset, buffer.Array, buffer.Offset, 8192);
						header = new HeaderPage(buffer);
						header.TransactionID = uint.MaxValue;
						header.IsConfirmed = false;
					}
				}
				_lastTransactionID = (int)num3;
				num += 8192;
			}
		}

		public int Checkpoint()
		{
			if (_disk.GetFileLength(FileOrigin.Log) == 0L || _confirmTransactions.Count == 0)
			{
				return 0;
			}
			bool flag = _locker.EnterExclusive();
			try
			{
				return CheckpointInternal();
			}
			finally
			{
				if (flag)
				{
					_locker.ExitExclusive();
				}
			}
		}

		public int TryCheckpoint()
		{
			if (_disk.GetFileLength(FileOrigin.Log) == 0L || _confirmTransactions.Count == 0)
			{
				return 0;
			}
			if (!_locker.TryEnterExclusive(out var mustExit))
			{
				return 0;
			}
			try
			{
				return CheckpointInternal();
			}
			finally
			{
				if (mustExit)
				{
					_locker.ExitExclusive();
				}
			}
		}

		private int CheckpointInternal()
		{
			<>c__DisplayClass19_0 CS$<>8__locals0 = new <>c__DisplayClass19_0();
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.counter = 0;
			_disk.WriteDataDisk(source());
			Clear();
			return CS$<>8__locals0.counter;
			[IteratorStateMachine(typeof(<>c__DisplayClass19_0.<<CheckpointInternal>g__source|0>d))]
			IEnumerable<PageBuffer> source()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass19_0.<<CheckpointInternal>g__source|0>d(-2)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}
	}
	internal enum SharedMutexNameStrategy
	{
		Default,
		UriEscape,
		Sha1Hash
	}
	internal class SortContainer : IDisposable
	{
		[CompilerGenerated]
		private sealed class <GetSourceFromStream>d__22 : IEnumerable<BufferSlice>, IEnumerable, IEnumerator<BufferSlice>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BufferSlice <>2__current;

			private int <>l__initialThreadId;

			private Stream stream;

			public Stream <>3__stream;

			public SortContainer <>4__this;

			private byte[] <bytes>5__2;

			private BufferSlice <buffer>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<bytes>5__2 = null;
				<buffer>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				SortContainer sortContainer = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<bytes>5__2 = _bufferPool.Rent(8192);
					<buffer>5__3 = new BufferSlice(<bytes>5__2, 0, 8192);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (sortContainer._readPosition < sortContainer._size)
				{
					stream.Position = sortContainer.Position + sortContainer._readPosition;
					stream.Read(<bytes>5__2, 0, 8192);
					sortContainer._readPosition += 8192;
					<>2__current = <buffer>5__3;
					<>1__state = 1;
					return true;
				}
				_bufferPool.Return(<bytes>5__2, clearArray: true);
				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]
			IEnumerator<BufferSlice> IEnumerable<BufferSlice>.GetEnumerator()
			{
				<GetSourceFromStream>d__22 <GetSourceFromStream>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetSourceFromStream>d__ = this;
				}
				else
				{
					<GetSourceFromStream>d__ = new <GetSourceFromStream>d__22(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetSourceFromStream>d__.stream = <>3__stream;
				return <GetSourceFromStream>d__;
			}

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

		private readonly Collation _collation;

		private readonly int _size;

		private readonly int[] _orders;

		private int _remaining;

		private int _count;

		private bool _isEOF;

		private int _readPosition;

		private BufferReader _reader;

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		public KeyValuePair<BsonValue, PageAddress> Current;

		public bool IsEOF => _isEOF;

		public long Position { get; set; } = -1L;


		public int Count => _count;

		public SortContainer(Collation collation, int size, IReadOnlyList<int> orders)
		{
			_collation = collation;
			_size = size;
			_orders = (orders as int[]) ?? orders.ToArray();
		}

		public void Insert(IEnumerable<KeyValuePair<BsonValue, PageAddress>> items, int order, BufferSlice buffer)
		{
			IOrderedEnumerable<KeyValuePair<BsonValue, PageAddress>> obj = ((order == 1) ? items.OrderBy((KeyValuePair<BsonValue, PageAddress> x) => x.Key, _collation) : items.OrderByDescending((KeyValuePair<BsonValue, PageAddress> x) => x.Key, _collation));
			int num = 0;
			foreach (KeyValuePair<BsonValue, PageAddress> item in obj)
			{
				buffer.WriteIndexKey(item.Key, num);
				int keyLength = IndexNode.GetKeyLength(item.Key, recalc: false);
				if (keyLength > 1023)
				{
					throw LiteException.InvalidIndexKey($"Sort key must be less than {1023} bytes.");
				}
				num += keyLength;
				buffer.Write(item.Value, num);
				num += 5;
				_remaining++;
			}
			_count = _remaining;
		}

		public void InitializeReader(Stream stream, BufferSlice buffer, bool utcDate)
		{
			if (stream != null)
			{
				_reader = new BufferReader(GetSourceFromStream(stream), utcDate);
			}
			else
			{
				_reader = new BufferReader(buffer, utcDate);
			}
			MoveNext();
		}

		public bool MoveNext()
		{
			if (_remaining == 0)
			{
				_isEOF = true;
				return false;
			}
			BsonValue bsonValue = _reader.ReadIndexKey();
			if (_orders.Length > 1)
			{
				bsonValue = SortKey.FromBsonValue(bsonValue, _orders);
			}
			PageAddress value = _reader.ReadPageAddress();
			Current = new KeyValuePair<BsonValue, PageAddress>(bsonValue, value);
			_remaining--;
			return true;
		}

		[IteratorStateMachine(typeof(<GetSourceFromStream>d__22))]
		private IEnumerable<BufferSlice> GetSourceFromStream(Stream stream)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetSourceFromStream>d__22(-2)
			{
				<>4__this = this,
				<>3__stream = stream
			};
		}

		public void Dispose()
		{
			_reader?.Dispose();
		}
	}
	internal class SortDisk : IDisposable
	{
		private readonly IStreamFactory _factory;

		private readonly StreamPool _pool;

		private readonly ConcurrentBag<long> _freePositions = new ConcurrentBag<long>();

		private long _lastContainerPosition;

		private readonly int _containerSize;

		private readonly EnginePragmas _pragmas;

		public int ContainerSize => _containerSize;

		public SortDisk(IStreamFactory factory, int containerSize, EnginePragmas pragmas)
		{
			Constants.ENSURE(containerSize % 8192 == 0, "size must be PAGE_SIZE multiple");
			_factory = factory;
			_containerSize = containerSize;
			_pragmas = pragmas;
			_lastContainerPosition = -containerSize;
			_pool = new StreamPool(_factory, appendOnly: false);
		}

		public Stream GetReader()
		{
			return _pool.Rent();
		}

		public void Return(Stream stream)
		{
			_pool.Return(stream);
		}

		public void Return(long position)
		{
			_freePositions.Add(position);
		}

		public long GetContainerPosition()
		{
			if (_freePositions.TryTake(out var result))
			{
				return result;
			}
			return Interlocked.Add(ref _lastContainerPosition, _containerSize);
		}

		public void Write(long position, BufferSlice buffer)
		{
			Stream value = _pool.Writer.Value;
			lock (value)
			{
				for (int i = 0; i < _containerSize / 8192; i++)
				{
					value.Position = position + i * 8192;
					value.Write(buffer.Array, buffer.Offset + i * 8192, 8192);
				}
			}
		}

		public void Dispose()
		{
			_pool.Dispose();
			_factory.Delete();
		}
	}
	internal class SortKey : BsonArray
	{
		private readonly int[] _orders;

		private SortKey(IEnumerable<BsonValue> values, IEnumerable<int> orders)
			: base(values?.Select((BsonValue x) => x ?? BsonValue.Null) ?? throw new ArgumentNullException("values"))
		{
			if (orders == null)
			{
				throw new ArgumentNullException("orders");
			}
			_orders = (orders as int[]) ?? orders.ToArray();
			if (_orders.Length != base.Count)
			{
				throw new ArgumentException("Orders length must match values length", "orders");
			}
		}

		private SortKey(BsonArray array, IEnumerable<int> orders)
			: base(array)
		{
			if (orders == null)
			{
				throw new ArgumentNullException("orders");
			}
			_orders = (orders as int[]) ?? orders.ToArray();
			if (_orders.Length != base.Count)
			{
				throw new ArgumentException("Orders length must match values length", "orders");
			}
		}

		public override int CompareTo(BsonValue other)
		{
			return CompareTo(other, Collation.Binary);
		}

		public override int CompareTo(BsonValue other, Collation collation)
		{
			if (other is SortKey sortKey)
			{
				int num = Math.Min(base.Count, sortKey.Count);
				for (int i = 0; i < num; i++)
				{
					int num2 = this[i].CompareTo(sortKey[i], collation);
					if (num2 != 0)
					{
						if (_orders[i] != -1)
						{
							return num2;
						}
						return -num2;
					}
				}
				if (base.Count == sortKey.Count)
				{
					return 0;
				}
				if (base.Count >= sortKey.Count)
				{
					return 1;
				}
				return -1;
			}
			if (other is BsonArray bsonArray)
			{
				return CompareTo(new SortKey(bsonArray, Enumerable.Repeat(1, bsonArray.Count)), collation);
			}
			return base.CompareTo(other, collation);
		}

		public static SortKey FromValues(IReadOnlyList<BsonValue> values, IReadOnlyList<int> orders)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (orders == null)
			{
				throw new ArgumentNullException("orders");
			}
			return new SortKey(values, orders);
		}

		public static SortKey FromBsonValue(BsonValue value, IReadOnlyList<int> orders)
		{
			if (value is SortKey result)
			{
				return result;
			}
			if (value is BsonArray source)
			{
				return new SortKey(source.ToArray(), orders);
			}
			return new SortKey(new BsonValue[1] { value }, orders);
		}
	}
	internal class SortService : IDisposable
	{
		[CompilerGenerated]
		private sealed class <SliptValues>d__17 : IEnumerable<IEnumerable<KeyValuePair<BsonValue, PageAddress>>>, IEnumerable, IEnumerator<IEnumerable<KeyValuePair<BsonValue, PageAddress>>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IEnumerable<KeyValuePair<BsonValue, PageAddress>> <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<KeyValuePair<BsonValue, PageAddress>> source;

			public IEnumerable<KeyValuePair<BsonValue, PageAddress>> <>3__source;

			private Done done;

			public Done <>3__done;

			public SortService <>4__this;

			private IEnumerator<KeyValuePair<BsonValue, PageAddress>> <enumerator>5__2;

			IEnumerable<KeyValuePair<BsonValue, PageAddress>> IEnumerator<IEnumerable<KeyValuePair<BsonValue, PageAddress>>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <SliptValues>d__17(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();
					}
				}
				<enumerator>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					SortService sortService = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
					}
					else
					{
						<>1__state = -1;
						<enumerator>5__2 = source.GetEnumerator();
						<>1__state = -3;
						if (!<enumerator>5__2.MoveNext())
						{
							goto IL_008f;
						}
						done.Count = 1;
					}
					if (done.Running)
					{
						<>2__current = sortService.YieldValues(<enumerator>5__2, done);
						<>1__state = 1;
						return true;
					}
					goto IL_008f;
					IL_008f:
					<>m__Finally1();
					<enumerator>5__2 = 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 (<enumerator>5__2 != null)
				{
					<enumerator>5__2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<IEnumerable<KeyValuePair<BsonValue, PageAddress>>> IEnumerable<IEnumerable<KeyValuePair<BsonValue, PageAddress>>>.GetEnumerator()
			{
				<SliptValues>d__17 <SliptValues>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SliptValues>d__ = this;
				}
				else
				{
					<SliptValues>d__ = new <SliptValues>d__17(0)
					{
						<>4__this = <>4__this
					};
				}
				<SliptValues>d__.source = <>3__source;
				<SliptValues>d__.done = <>3__done;
				return <SliptValues>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<IEnumerable<KeyValuePair<BsonValue, PageAddress>>>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <Sort>d__16 : IEnumerable<KeyValuePair<BsonValue, PageAddress>>, IEnumerable, IEnumerator<KeyValuePair<BsonValue, PageAddress>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<BsonValue, PageAddress> <>2__current;

			private int <>l__initialThreadId;

			public SortService <>4__this;

			private SortContainer <current>5__2;

			private int <diffOrder>5__3;

			private BsonValue <lastKey>5__4;

			KeyValuePair<BsonValue, PageAddress> IEnumerator<KeyValuePair<BsonValue, PageAddress>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SortService sortService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (sortService._containers.Count == 0)
					{
						return false;
					}
					<current>5__2 = sortService._containers[0];
					if (sortService._containers.Count == 1)
					{
						goto IL_005c;
					}
					<diffOrder>5__3 = ((sortService._orders.Length == 1) ? (sortService._orders[0] * -1) : (-1));
					goto IL_0249;
				case 1:
					<>1__state = -1;
					if (!<current>5__2.MoveNext())
					{
						<current>5__2.Dispose();
						break;
					}
					goto IL_005c;
				case 2:
					<>1__state = -1;
					<lastKey>5__4 = <current>5__2.Current.Key;
					if (!<current>5__2.MoveNext())
					{
						<current>5__2 = sortService._containers.FirstOrDefault((SortContainer x) => !x.IsEOF);
					}
					goto IL_021b;
				case 3:
					{
						<>1__state = -1;
						if (!<current>5__2.MoveNext())
						{
							<current>5__2 = sortService._containers.FirstOrDefault((SortContainer x) => !x.IsEOF);
						}
						goto IL_021b;
					}
					IL_021b:
					if (<current>5__2?.Current.Key == <lastKey>5__4)
					{
						<>2__current = <current>5__2.Current;
						<>1__state = 3;
						return true;
					}
					<lastKey>5__4 = null;
					goto IL_0249;
					IL_005c:
					<>2__current = <current>5__2.Current;
					<>1__state = 1;
					return true;
					IL_0249:
					if (!sortService._containers.Any((SortContainer x) => !x.IsEOF))
					{
						break;
					}
					foreach (SortContainer item in sortService._containers.Where((SortContainer x) => !x.IsEOF))
					{
						if (item.Current.Key.CompareTo(<current>5__2.Current.Key, sortService._pragmas.Collation) == <diffOrder>5__3)
						{
							<current>5__2 = item;
						}
					}
					<>2__current = <current>5__2.Current;
					<>1__state = 2;
					return true;
				}
				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]
			IEnumerator<KeyValuePair<BsonValue, PageAddress>> IEnumerable<KeyValuePair<BsonValue, PageAddress>>.GetEnumerator()
			{
				<Sort>d__16 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <Sort>d__16(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<BsonValue, PageAddress>>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <YieldValues>d__18 : IEnumerable<KeyValuePair<BsonValue, PageAddress>>, IEnumerable, IEnumerator<KeyValuePair<BsonValue, PageAddress>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<BsonValue, PageAddress> <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<KeyValuePair<BsonValue, PageAddress>> source;

			public IEnumerator<KeyValuePair<BsonValue, PageAddress>> <>3__source;

			private Done done;

			public Done <>3__done;

			public SortService <>4__this;

			private int <size>5__2;

			KeyValuePair<BsonValue, PageAddress> IEnumerator<KeyValuePair<BsonValue, PageAddress>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SortService sortService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<size>5__2 = IndexNode.GetKeyLength(source.Current.Key, recalc: false) + 5;
					<>2__current = source.Current;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (source.MoveNext())
				{
					int num2 = IndexNode.GetKeyLength(source.Current.Key, recalc: false) + 5;
					done.Count++;
					if (<size>5__2 + num2 > sortService._containerSize)
					{
						return false;
					}
					<size>5__2 += num2;
					<>2__current = source.Current;
					<>1__state = 2;
					return true;
				}
				done.Running = false;
				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]
			IEnumerator<KeyValuePair<BsonValue, PageAddress>> IEnumerable<KeyValuePair<BsonValue, PageAddress>>.GetEnumerator()
			{
				<YieldValues>d__18 <YieldValues>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<YieldValues>d__ = this;
				}
				else
				{
					<YieldValues>d__ = new <YieldValues>d__18(0)
					{
						<>4__this = <>4__this
					};
				}
				<YieldValues>d__.source = <>3__source;
				<YieldValues>d__.done = <>3__done;
				return <YieldValues>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<BsonValue, PageAddress>>)this).GetEnumerator();
			}
		}

		private readonly SortDisk _disk;

		private readonly List<SortContainer> _containers = new List<SortContainer>();

		private readonly int _containerSize;

		private readonly Done _done = new Done
		{
			Running = true
		};

		private readonly int[] _orders;

		private readonly EnginePragmas _pragmas;

		private readonly BufferSlice _buffer;

		private readonly Lazy<Stream> _reader;

		private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;

		public int Count => _done.Count;

		public IReadOnlyCollection<SortContainer> Containers => _containers;

		public SortService(SortDisk disk, IReadOnlyList<int> orders, EnginePragmas pragmas)
		{
			_disk = disk;
			if (orders == null)
			{
				throw new ArgumentNullException("orders");
			}
			if (orders.Count == 0)
			{
				throw new ArgumentException("Orders must contain at least one segment", "orders");
			}
			_orders = (orders as int[]) ?? orders.ToArray();
			_pragmas = pragmas;
			_containerSize = disk.ContainerSize;
			_reader = new Lazy<Stream>(() => _disk.GetReader());
			byte[] array = new byte[disk.ContainerSize];
			_buffer = new BufferSlice(array, 0, _containerSize);
		}

		public void Dispose()
		{
			foreach (SortContainer container in _containers)
			{
				container.Dispose();
				if (container.Position >= 0)
				{
					_disk.Return(container.Position);
				}
			}
			if (_reader.IsValueCreated)
			{
				_disk.Return(_reader.Value);
			}
		}

		public void Insert(IEnumerable<KeyValuePair<BsonValue, PageAddress>> items)
		{
			foreach (IEnumerable<KeyValuePair<BsonValue, PageAddress>> item in SliptValues(items, _done))
			{
				SortContainer sortContainer = new SortContainer(_pragmas.Collation, _containerSize, _orders);
				int order = ((_orders.Length != 1) ? 1 : _orders[0]);
				sortContainer.Insert(item, order, _buffer);
				_containers.Add(sortContainer);
				if (!_done.Running && _containers.Count == 1)
				{
					sortContainer.InitializeReader(null, _buffer, _pragmas.UtcDate);
					continue;
				}
				sortContainer.Position = _disk.GetContainerPosition();
				_disk.Write(sortContainer.Position, _buffer);
				sortContainer.InitializeReader(_reader.Value, null, _pragmas.UtcDate);
			}
		}

		[IteratorStateMachine(typeof(<Sort>d__16))]
		public IEnumerable<KeyValuePair<BsonValue, PageAddress>> Sort()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Sort>d__16(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SliptValues>d__17))]
		private IEnumerable<IEnumerable<KeyValuePair<BsonValue, PageAddress>>> SliptValues(IEnumerable<KeyValuePair<BsonValue, PageAddress>> source, Done done)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SliptValues>d__17(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__done = done
			};
		}

		[IteratorStateMachine(typeof(<YieldValues>d__18))]
		private IEnumerable<KeyValuePair<BsonValue, PageAddress>> YieldValues(IEnumerator<KeyValuePair<BsonValue, PageAddress>> source, Done done)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <YieldValues>d__18(-2)
			{
				<>4__this = this,
				<>3__source = source,
				<>3__done = done
			};
		}
	}
	internal class CollectionIndex
	{
		public uint FreeIndexPageList;

		public byte Slot { get; }

		public byte IndexType { get; }

		public string Name { get; }

		public string Expression { get; }

		public BsonExpression BsonExpr { get; }

		public bool Unique { get; }

		public PageAddress Head { get; set; }

		public PageAddress Tail { get; set; }

		public byte Reserved { get; set; } = 1;


		public bool IsEmpty => string.IsNullOrEmpty(Name);

		public CollectionIndex(byte slot, byte indexType, string name, string expr, bool unique)
		{
			Slot = slot;
			IndexType = indexType;
			Name = name;
			Expression = expr;
			Unique = unique;
			FreeIndexPageList = uint.MaxValue;
			BsonExpr = BsonExpression.Create(expr);
		}

		public CollectionIndex(BufferReader reader)
		{
			Slot = reader.ReadByte();
			IndexType = reader.ReadByte();
			Name = reader.ReadCString();
			Expression = reader.ReadCString();
			Unique = reader.ReadBoolean();
			Head = reader.ReadPageAddress();
			Tail = reader.ReadPageAddress();
			Reserved = reader.ReadByte();
			FreeIndexPageList = reader.ReadUInt32();
			BsonExpr = BsonExpression.Create(Expression);
		}

		public void UpdateBuffer(BufferWriter writer)
		{
			writer.Write(Slot);
			writer.Write(IndexType);
			writer.WriteCString(Name);
			writer.WriteCString(Expression);
			writer.Write(Unique);
			writer.Write(Head);
			writer.Write(Tail);
			writer.Write(Reserved);
			writer.Write(FreeIndexPageList);
		}

		public static int GetLength(CollectionIndex index)
		{
			return GetLength(index.Name, index.Expression);
		}

		public static int GetLength(string name, string expr)
		{
			return 2 + StringEncoding.UTF8.GetByteCount(name) + 1 + StringEncoding.UTF8.GetByteCount(expr) + 1 + 1 + 5 + 5 + 1 + 4;
		}
	}
	internal class CursorInfo
	{
		public string Collection { get; }

		public Query Query { get; set; }

		public int Fetched { get; set; }

		public Stopwatch Elapsed { get; } = new Stopwatch();


		public CursorInfo(string collection, Query query)
		{
			Collection = collection;
			Query = query;
		}
	}
	internal class DataBlock
	{
		public const int DATA_BLOCK_FIXED_SIZE = 6;

		public const int P_EXTEND = 0;

		public const int P_NEXT_BLOCK = 1;

		public const int P_BUFFER = 6;

		private readonly DataPage _page;

		private readonly BufferSlice _segment;

		public PageAddress Position { get; }

		public bool Extend { get; }

		public PageAddress NextBlock { get; private set; }

		public BufferSlice Buffer { get; }

		public DataBlock(DataPage page, byte index, BufferSlice segment)
		{
			_page = page;
			_segment = segment;
			Position = new PageAddress(page.PageID, index);
			Extend = segment.ReadBool(0);
			NextBlock = segment.ReadPageAddress(1);
			Buffer = segment.Slice(6, segment.Count - 6);
		}

		public DataBlock(DataPage page, byte index, BufferSlice segment, bool extend, PageAddress nextBlock)
		{
			_page = page;
			_segment = segment;
			Position = new PageAddress(page.PageID, index);
			NextBlock = nextBlock;
			Extend = extend;
			segment.Write(extend, 0);
			segment.Write(nextBlock, 1);
			Buffer = segment.Slice(6, segment.Count - 6);
			page.IsDirty = true;
		}

		public void SetNextBlock(PageAddress nextBlock)
		{
			NextBlock = nextBlock;
			_segment.Write(nextBlock, 1);
			_page.IsDirty = true;
		}

		public override string ToString()
		{
			return $"Pos: [{Position}] - Ext: [{Extend}] - Next: [{NextBlock}] - Buffer: [{Buffer}]";
		}
	}
	internal class Done
	{
		public bool Running;

		public int Count;
	}
	internal enum FileOrigin : byte
	{
		None,
		Data,
		Log
	}
	internal class IndexNode
	{
		private const int INDEX_NODE_FIXED_SIZE = 12;

		private const int P_SLOT = 0;

		private const int P_LEVELS = 1;

		private const int P_DATA_BLOCK = 2;

		private const int P_NEXT_NODE = 7;

		private const int P_PREV_NEXT = 12;

		private readonly IndexPage _page;

		private readonly BufferSlice _segment;

		private static readonly byte[] arrayByteEmpty = new byte[0];

		private int P_KEY => 12 + Levels * 5 * 2;

		public PageAddress Position { get; }

		public byte Slot { get; }

		public byte Levels { get; }

		public BsonValue Key { get; }

		public PageAddress DataBlock { get; }

		public PageAddress NextNode { get; private set; }

		public PageAddress[] Prev { get; private set; }

		public PageAddress[] Next { get; private set; }

		public IndexPage Page => _page;

		public static int GetNodeLength(byte level, BsonValue key, out int keyLength)
		{
			keyLength = GetKeyLength(key, recalc: true);
			return 12 + level * 2 * 5 + keyLength;
		}

		public static int GetKeyLength(BsonValue key, bool recalc)
		{
			return 1 + ((key.IsString || key.IsBinary) ? 1 : 0) + key.GetBytesCount(recalc);
		}

		public IndexNode(IndexPage page, byte index, BufferSlice segment)
		{
			_page = page;
			_segment = segment;
			Position = new PageAddress(page.PageID, index);
			Slot = segment.ReadByte(0);
			Levels = segment.ReadByte(1);
			DataBlock = segment.ReadPageAddress(2);
			NextNode = segment.ReadPageAddress(7);
			Next = new PageAddress[Levels];
			Prev = new PageAddress[Levels];
			for (int i = 0; i < Levels; i++)
			{
				Prev[i] = segment.ReadPageAddress(12 + i * 5 * 2);
				Next[i] = segment.ReadPageAddress(12 + i * 5 * 2 + 5);
			}
			Key = segment.ReadIndexKey(P_KEY);
		}

		public IndexNode(IndexPage page, byte index, BufferSlice segment, byte slot, byte levels, BsonValue key, PageAddress dataBlock)
		{
			_page = page;
			_segment = segment;
			Position = new PageAddress(page.PageID, index);
			Slot = slot;
			Levels = levels;
			DataBlock = dataBlock;
			NextNode = PageAddress.Empty;
			Next = new PageAddress[levels];
			Prev = new PageAddress[levels];
			Key = key;
			segment.Write(slot, 0);
			segment.Write(levels, 1);
			segment.Write(dataBlock, 2);
			segment.Write(NextNode, 7);
			for (int i = 0; i < levels; i++)
			{
				SetPrev((byte)i, PageAddress.Empty);
				SetNext((byte)i, PageAddress.Empty);
			}
			segment.WriteIndexKey(key, P_KEY);
			page.IsDirty = true;
		}

		public IndexNode(BsonDocument doc)
		{
			_page = null;
			_segment = new BufferSlice(arrayByteEmpty, 0, 0);
			Position = new PageAddress(0u, 0);
			Slot = 0;
			Levels = 0;
			DataBlock = PageAddress.Empty;
			NextNode = PageAddress.Empty;
			Next = new PageAddress[0];
			Prev = new PageAddress[0];
			Key = doc;
		}

		public void SetNextNode(PageAddress value)
		{
			NextNode = value;
			_segment.Write(value, 7);
			_page.IsDirty = true;
		}

		public void SetPrev(byte level, PageAddress value)
		{
			Constants.ENSURE(level <= Levels, "out of index in level");
			Prev[level] = value;
			_segment.Write(value, 12 + level * 5 * 2);
			_page.IsDirty = true;
		}

		public void SetNext(byte level, PageAddress value)
		{
			Constants.ENSURE(level <= Levels, "out of index in level");
			Next[level] = value;
			_segment.Write(value, 12 + level * 5 * 2 + 5);
			_page.IsDirty = true;
		}

		public PageAddress GetNextPrev(byte level, int order)
		{
			if (order != 1)
			{
				return Prev[level];
			}
			return Next[level];
		}

		public override string ToString()
		{
			return $"Pos: [{Position}] - Key: {Key}";
		}
	}
	internal enum LockMode
	{
		Read,
		Write
	}
	[DebuggerStepThrough]
	internal struct PageAddress
	{
		public const int SIZE = 5;

		public static PageAddress Empty = new PageAddress(uint.MaxValue, byte.MaxValue);

		public readonly uint PageID;

		public readonly byte Index;

		public bool IsEmpty
		{
			get
			{
				if (PageID == uint.MaxValue)
				{
					return Index == byte.MaxValue;
				}
				return false;
			}
		}

		public override bool Equals(object obj)
		{
			PageAddress pageAddress = (PageAddress)obj;
			if (PageID == pageAddress.PageID)
			{
				return Index == pageAddress.Index;
			}
			return false;
		}

		public static bool operator ==(PageAddress lhs, PageAddress rhs)
		{
			if (lhs.PageID == rhs.PageID)
			{
				return lhs.Index == rhs.Index;
			}
			return false;
		}

		public static bool operator !=(PageAddress lhs, PageAddress rhs)
		{
			return !(lhs == rhs);
		}

		public override int GetHashCode()
		{
			return (int)((17 * 23 + PageID) * 23 + Index);
		}

		public PageAddress(uint pageID, byte index)
		{
			PageID = pageID;
			Index = index;
		}

		public override string ToString()
		{
			if (!IsEmpty)
			{
				uint pageID = PageID;
				string text = pageID.ToString().PadLeft(4, '0');
				byte index = Index;
				return text + ":" + index.ToString().PadLeft(2, '0');
			}
			return "(empty)";
		}

		public BsonValue ToBsonValue()
		{
			if (IsEmpty)
			{
				return BsonValue.Null;
			}
			return new BsonDocument
			{
				["pageID"] = (int)PageID,
				["index"] = (int)Index
			};
		}
	}
	internal class PageBuffer : BufferSlice
	{
		public readonly int UniqueID;

		public long Position;

		public FileOrigin Origin;

		public int ShareCounter;

		public long Timestamp;

		public PageBuffer(byte[] buffer, int offset, int uniqueID)
			: base(buffer, offset, 8192)
		{
			UniqueID = uniqueID;
			Position = long.MaxValue;
			Origin = FileOrigin.None;
			ShareCounter = 0;
			Timestamp = 0L;
		}

		public void Release()
		{
			Constants.ENSURE(ShareCounter > 0, "share counter must be > 0 in Release()");
			Interlocked.Decrement(ref ShareCounter);
		}

		public override string ToString()
		{
			string text = ((Position == long.MaxValue) ? "<empty>" : Position.ToString());
			string text2 = ((ShareCounter == Constants.BUFFER_WRITABLE) ? "<writable>" : ShareCounter.ToString());
			uint num = this.ReadUInt32(0);
			byte b = base[4];
			return string.Format("ID: {0} - Position: {1}/{2} - Shared: {3} - ({4}) :: Content: [{5}/{6}]", UniqueID, text, Origin, text2, base.ToString(), num.ToString("0:0000"), (PageType)b);
		}

		public unsafe bool IsBlank()
		{
			fixed (byte* ptr = base.Array)
			{
				ulong* ptr2 = (ulong*)(ptr + base.Offset);
				if (*ptr2 == 0L)
				{
					return ptr2[1] == 0;
				}
				return false;
			}
		}
	}
	internal struct PagePosition
	{
		public uint PageID;

		public long Position;

		public static PagePosition Empty => new PagePosition(uint.MaxValue, long.MaxValue);

		public bool IsEmpty
		{
			get
			{
				if (PageID == uint.MaxValue)
				{
					return Position == long.MaxValue;
				}
				return false;
			}
		}

		public override bool Equals(object obj)
		{
			PagePosition pagePosition = (PagePosition)obj;
			if (PageID == pagePosition.PageID)
			{
				return Position == pagePosition.PageID;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (int)((17 * 23 + PageID) * 23) + (int)Position;
		}

		public PagePosition(uint pageID, long position)
		{
			PageID = pageID;
			Position = position;
		}

		public override string ToString()
		{
			if (!IsEmpty)
			{
				return ((PageID == uint.MaxValue) ? "----" : PageID.ToString()) + ":" + Position;
			}
			return "----:----";
		}
	}
	internal class Pragma
	{
		public string Name { get; set; }

		public Func<BsonValue> Get { get; set; }

		public Action<BsonValue> Set { get; set; }

		public Action<BufferSlice> Read { get; set; }

		public Action<BsonValue, HeaderPage> Validate { get; set; }

		public Action<BufferSlice> Write { get; set; }
	}
	internal class RebuildOptions
	{
		private string _buildId = Guid.NewGuid().ToString("d").ToLower()
			.Substring(6);

		public string Password { get; set; }

		public Collation Collation { get; set; }

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


		internal IList<FileReaderError> Errors { get; } = new List<FileReaderError>();


		public IEnumerable<BsonDocument> GetErrorReport()
		{
			return Errors.Select((FileReaderError x) => new BsonDocument
			{
				["buildId"] = _buildId,
				["created"] = x.Created,
				["pageID"] = (int)x.PageID.Value,
				["positionID"] = x.Position,
				["origin"] = x.Origin.ToString(),
				["pageType"] = x.PageType.ToString(),
				["message"] = x.Message,
				["exception"] = new BsonDocument
				{
					["code"] = ((x.Exception is LiteException ex) ? ex.ErrorCode : (-1)),
					["hresult"] = x.Exception.HResult,
					["type"] = x.Exception.GetType().FullName,
					["inner"] = x.Exception.InnerException?.Message,
					["stacktrace"] = x.Exception.StackTrace
				}
			});
		}
	}
	internal class TransactionPages
	{
		public int TransactionSize { get; set; }

		public Dictionary<uint, PagePosition> DirtyPages { get; } = new Dictionary<uint, PagePosition>();


		public List<uint> NewPages { get; } = new List<uint>();


		public uint FirstDeletedPageID { get; set; } = uint.MaxValue;


		public uint LastDeletedPageID { get; set; } = uint.MaxValue;


		public int DeletedPages { get; set; }

		public bool HeaderChanged
		{
			get
			{
				if (NewPages.Count <= 0 && DeletedPages <= 0)
				{
					return this.Commit != null;
				}
				return true;
			}
		}

		public event Action<HeaderPage> Commit;

		public void OnCommit(HeaderPage header)
		{
			this.Commit?.Invoke(header);
		}
	}
	internal enum TransactionState
	{
		Active,
		Committed,
		Aborted,
		Disposed
	}
	internal sealed class VectorIndexMetadata
	{
		public byte Slot { get; }

		public ushort Dimensions { get; }

		public VectorDistanceMetric Metric { get; }

		public PageAddress Root { get; set; }

		public uint Reserved { get; set; }

		public VectorIndexMetadata(byte slot, ushort dimensions, VectorDistanceMetric metric)
		{
			if (dimensions == 0)
			{
				throw new ArgumentOutOfRangeException("dimensions", dimensions, "Dimensions must be greater than zero");
			}
			Slot = slot;
			Dimensions = dimensions;
			Metric = metric;
			Root = PageAddress.Empty;
			Reserved = uint.MaxValue;
		}

		public VectorIndexMetadata(BufferReader reader)
		{
			Slot = reader.ReadByte();
			Dimensions = reader.ReadUInt16();
			Metric = (VectorDistanceMetric)reader.ReadByte();
			Root = reader.ReadPageAddress();
			Reserved = reader.ReadUInt32();
		}

		public void UpdateBuffer(BufferWriter writer)
		{
			writer.Write(Slot);
			writer.Write(Dimensions);
			writer.Write((byte)Metric);
			writer.Write(Root);
			writer.Write(Reserved);
		}

		public static int GetLength()
		{
			return 13;
		}
	}
	internal sealed class VectorIndexNode
	{
		private const int P_DATA_BLOCK = 0;

		private const int P_LEVEL_COUNT = 5;

		private const int P_LEVELS = 6;

		public const int MaxLevels = 4;

		public const int MaxNeighborsPerLevel = 8;

		private const int LEVEL_STRIDE = 41;

		private const int P_VECTOR = 170;

		private const int P_VECTOR_POINTER = 172;

		private readonly VectorIndexPage _page;

		private readonly BufferSlice _segment;

		public PageAddress Position { get; }

		public PageAddress DataBlock { get; private set; }

		public VectorIndexPage Page => _page;

		public byte LevelCount { get; private set; }

		public int Dimensions { get; }

		public bool HasInlineVector { get; }

		public PageAddress ExternalVector { get; }

		public VectorIndexNode(VectorIndexPage page, byte index, BufferSlice segment)
		{
			_page = page;
			_segment = segment;
			Position = new PageAddress(page.PageID, index);
			DataBlock = segment.ReadPageAddress(0);
			LevelCount = segment.ReadByte(5);
			ushort num = segment.ReadUInt16(170);
			if (num == 0)
			{
				HasInlineVector = false;
				ExternalVector = segment.ReadPageAddress(172);
				Dimensions = 0;
			}
			else
			{
				HasInlineVector = true;
				ExternalVector = PageAddress.Empty;
				Dimensions = num;
			}
		}

		public VectorIndexNode(VectorIndexPage page, byte index, BufferSlice segment, PageAddress dataBlock, float[] vector, byte levelCount, PageAddress externalVector)
		{
			if (vector == null)
			{
				throw new ArgumentNullException("vector");
			}
			if (levelCount == 0 || levelCount > 4)
			{
				throw new ArgumentOutOfRangeException("levelCount");
			}
			_page = page;
			_segment = segment;
			Position = new PageAddress(page.PageID, index);
			DataBlock = dataBlock;
			LevelCount = levelCount;
			Dimensions = vector.Length;
			HasInlineVector = externalVector.IsEmpty;
			ExternalVector = externalVector;
			segment.Write(dataBlock, 0);
			segment.Write(levelCount, 5);
			for (int i = 0; i < 4; i++)
			{
				int levelOffset = GetLevelOffset(i);
				segment.Write((byte)0, levelOffset);
				int num = levelOffset + 1;
				for (int j = 0; j < 8; j++)
				{
					segment.Write(PageAddress.Empty, num);
					num += 5;
				}
			}
			if (HasInlineVector)
			{
				segment.Write(vector, 170);
			}
			else
			{
				if (externalVector.IsEmpty)
				{
					throw new ArgumentException("External vector address must be provided when vector is stored out of page.", "externalVector");
				}
				segment.Write((ushort)0, 170);
				segment.Write(externalVector, 172);
			}
			page.IsDirty = true;
		}

		public static int GetLength(int dimensions, out bool storesInline)
		{
			int num = 172 + dimensions * 4;
			int num2 = 8156;
			if (num <= num2)
			{
				storesInline = true;
				return num;
			}
			storesInline = false;
			return 177;
		}

		public IReadOnlyList<PageAddress> GetNeighbors(int level)
		{
			if (level < 0 || level >= 4)
			{
				throw new ArgumentOutOfRangeException("level");
			}
			int levelOffset = GetLevelOffset(level);
			byte b = _segment.ReadByte(levelOffset);
			List<PageAddress> list = new List<PageAddress>(b);
			int num = levelOffset + 1;
			for (int i = 0; i < b; i++)
			{
				list.Add(_segment.ReadPageAddress(num));
				num += 5;
			}
			return list;
		}

		public void SetNeighbors(int level, IReadOnlyList<PageAddress> neighbors)
		{
			if (level < 0 || level >= 4)
			{
				throw new ArgumentOutOfRangeException("level");
			}
			if (neighbors == null)
			{
				throw new ArgumentNullException("neighbors");
			}
			int levelOffset = GetLevelOffset(level);
			int num = Math.Min(neighbors.Count, 8);
			_segment.Write((byte)num, levelOffset);
			int num2 = levelOffset + 1;
			int i;
			for (i = 0; i < num; i++)
			{
				_segment.Write(neighbors[i], num2);
				num2 += 5;
			}
			for (; i < 8; i++)
			{
				_segment.Write(PageAddress.Empty, num2);
				num2 += 5;
			}
			_page.IsDirty = true;
		}

		public bool TryAddNeighbor(int level, PageAddress address)
		{
			if (level < 0 || level >= 4)
			{
				throw new ArgumentOutOfRangeException("level");
			}
			IReadOnlyList<PageAddress> neighbors = GetNeighbors(level);
			if (neighbors.Contains(address))
			{
				return false;
			}
			if (neighbors.Count >= 8)
			{
				return false;
			}
			List<PageAddress> list = new List<PageAddress>(neighbors.Count + 1);
			list.AddRange(neighbors);
			list.Add(address);
			SetNeighbors(level, list);
			return true;
		}

		public bool RemoveNeighbor(int level, PageAddress address)
		{
			if (level < 0 || level >= 4)
			{
				throw new ArgumentOutOfRangeException("level");
			}
			IReadOnlyList<PageAddress> neighbors = GetNeighbors(level);
			if (!neighbors.Contains(address))
			{
				return false;
			}
			List<PageAddress> neighbors2 = neighbors.Where((PageAddress x) => x != address).ToList();
			SetNeighbors(level, neighbors2);
			return true;
		}

		public void SetLevelCount(byte levelCount)
		{
			if (levelCount == 0 || levelCount > 4)
			{
				throw new ArgumentOutOfRangeException("levelCount");
			}
			LevelCount = levelCount;
			_segment.Write(levelCount, 5);
			_page.IsDirty = true;
		}

		private static int GetLevelOffset(int level)
		{
			return 6 + level * 41;
		}

		public void UpdateVector(float[] vector)
		{
			if (vector == null)
			{
				throw new ArgumentNullException("vector");
			}
			if (!HasInlineVector)
			{
				throw new InvalidOperationException("Inline vector update is not supported for externally stored vectors.");
			}
			if (vector.Length != Dimensions)
			{
				throw new ArgumentException("Vector length must match node dimensions.", "vector");
			}
			_segment.Write(vector, 170);
			_page.IsDirty = true;
		}

		public float[] ReadVector()
		{
			if (!HasInlineVector)
			{
				throw new InvalidOperationException("Vector is stored externally and must be loaded from the data pages.");
			}
			return _segment.ReadVector(170);
		}
	}
	internal class SysDump : SystemCollection
	{
		[CompilerGenerated]
		private sealed class <DumpPages>d__4 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public SysDump <>4__this;

			private uint? pageID;

			public uint? <>3__pageID;

			private Dictionary<uint, string> <collections>5__2;

			private TransactionService <transaction>5__3;

			private Snapshot <snapshot>5__4;

			private uint <end>5__5;

			private uint <i>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<collections>5__2 = null;
				<transaction>5__3 = null;
				<snapshot>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				SysDump sysDump = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<collections>5__2 = sysDump._header.GetCollections().ToDictionary((KeyValuePair<string, uint> x) => x.Value, (KeyValuePair<string, uint> x) => x.Key);
					<transaction>5__3 = sysDump._monitor.GetThreadTransaction();
					<snapshot>5__4 = <transaction>5__3.CreateSnapshot(LockMode.Read, "$", addIfNotExists: false);
					uint num2 = (pageID.HasValue ? pageID.Value : 0u);
					<end>5__5 = (pageID.HasValue ? pageID.Value : sysDump._header.LastPageID);
					<i>5__6 = num2;
					break;
				}
				case 1:
					<>1__state = -1;
					<transaction>5__3.Safepoint();
					<i>5__6++;
					break;
				}
				if (<i>5__6 <= Math.Min(<end>5__5, sysDump._header.LastPageID))
				{
					FileOrigin origin;
					long position;
					int walVersion;
					BasePage page = <snapshot>5__4.GetPage<BasePage>(<i>5__6, out origin, out position, out walVersion);
					BsonDocument bsonDocument = new BsonDocument
					{
						["pageID"] = (int)page.PageID,
						["pageType"] = page.PageType.ToString(),
						["_position"] = position,
						["_origin"] = origin.ToString(),
						["_version"] = walVersion,
						["prevPageID"] = (int)page.PrevPageID,
						["nextPageID"] = (int)page.NextPageID,
						["slot"] = (int)page.PageListSlot,
						["collection"] = <collections>5__2.GetOrDefault(page.ColID, "-"),
						["itemsCount"] = (int)page.ItemsCount,
						["freeBytes"] = page.FreeBytes,
						["usedBytes"] = (int)page.UsedBytes,
						["fragmentedBytes"] = (int)page.FragmentedBytes,
						["nextFreePosition"] = (int)page.NextFreePosition,
						["highestIndex"] = (int)page.HighestIndex
					};
					if (page.PageType == PageType.Collection)
					{
						CollectionPage collectionPage = new CollectionPage(page.Buffer);
						bsonDocument["dataPageList"] = new BsonArray(collectionPage.FreeDataPageList.Select((uint x) => new BsonValue((int)x)));
						bsonDocument["indexes"] = new BsonArray(from x in collectionPage.GetCollectionIndexes()
							select new BsonDocument
							{
								["slot"] = (int)x.Slot,
								["empty"] = x.IsEmpty,
								["indexType"] = (int)x.IndexType,
								["name"] = x.Name,
								["expression"] = x.Expression,
								["unique"] = x.Unique,
								["head"] = x.Head.ToBsonValue(),
								["tail"] = x.Tail.ToBsonValue(),
								["freeIndexPageList"] = (int)x.FreeIndexPageList
							});
					}
					if (pageID.HasValue)
					{
						bsonDocument["buffer"] = page.Buffer.ToArray();
					}
					<>2__current = bsonDocument;
					<>1__state = 1;
					return true;
				}
				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]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<DumpPages>d__4 <DumpPages>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<DumpPages>d__ = this;
				}
				else
				{
					<DumpPages>d__ = new <DumpPages>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<DumpPages>d__.pageID = <>3__pageID;
				return <DumpPages>d__;
			}

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

		private readonly HeaderPage _header;

		private readonly TransactionMonitor _monitor;

		public SysDump(HeaderPage header, TransactionMonitor monitor)
			: base("$dump")
		{
			_header = header;
			_monitor = monitor;
		}

		public override IEnumerable<BsonDocument> Input(BsonValue options)
		{
			BsonValue option = SystemCollection.GetOption(options, "pageID");
			return DumpPages((option == null) ? null : new uint?((uint)option.AsInt32));
		}

		[IteratorStateMachine(typeof(<DumpPages>d__4))]
		private IEnumerable<BsonDocument> DumpPages(uint? pageID)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DumpPages>d__4(-2)
			{
				<>4__this = this,
				<>3__pageID = pageID
			};
		}
	}
	internal class SysFile : SystemCollection
	{
		private readonly Dictionary<string, SystemCollection> _formats = new Dictionary<string, SystemCollection>(StringComparer.OrdinalIgnoreCase)
		{
			["json"] = new SysFileJson(),
			["csv"] = new SysFileCsv()
		};

		public SysFile()
			: base("$file")
		{
		}

		public override IEnumerable<BsonDocument> Input(BsonValue options)
		{
			string format = GetFormat(options);
			if (_formats.TryGetValue(format, out var value))
			{
				return value.Input(options);
			}
			throw new LiteException(0, "Unknow file format in $file: `" + format + "`");
		}

		public override int Output(IEnumerable<BsonDocument> source, BsonValue options)
		{
			string format = GetFormat(options);
			if (_formats.TryGetValue(format, out var value))
			{
				return value.Output(source, options);
			}
			throw new LiteException(0, "Unknow file format in $file: `" + format + "`");
		}

		private string GetFormat(BsonValue options)
		{
			string path = SystemCollection.GetOption(options, "filename")?.AsString ?? throw new LiteException(0, "Collection $file requires string as 'filename' or a document field 'filename'");
			string asString = SystemCollection.GetOption(options, "format", Path.GetExtension(path)).AsString;
			if (!asString.StartsWith("."))
			{
				return asString;
			}
			return asString.Substring(1);
		}
	}
	internal class SysFileCsv : SystemCollection
	{
		[CompilerGenerated]
		private sealed class <Input>d__2 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private BsonValue options;

			public BsonValue <>3__options;

			public SysFileCsv <>4__this;

			private char <delimiter>5__2;

			private List<string> <header>5__3;

			private FileStream <fs>5__4;

			private StreamReader <reader>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<header>5__3 = null;
				<fs>5__4 = null;
				<reader>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					int num = <>1__state;
					SysFileCsv sysFileCsv = <>4__this;
					int num2;
					BsonDocument bsonDocument;
					if (num == 0)
					{
						<>1__state = -1;
						string path = SystemCollection.GetOption(options, "filename")?.AsString ?? throw new LiteException(0, "Collection $" + sysFileCsv.Name + " requires string as 'filename' or a document field 'filename'");
						string asString = SystemCollection.GetOption(options, "encoding", "utf-8").AsString;
						<delimiter>5__2 = SystemCollection.GetOption(options, "delimiter", ",").AsString[0];
						<header>5__3 = new List<string>();
						if (options.IsDocument && options["header"].IsArray)
						{
							<header>5__3.AddRange(options["header"].AsArray.Select((BsonValue x) => x.AsString));
						}
						<fs>5__4 = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
						<>1__state = -3;
						<reader>5__5 = new StreamReader(<fs>5__4, Encoding.GetEncoding(asString));
						<>1__state = -4;
						if (<header>5__3.Count == 0)
						{
							bool newLine;
							do
							{
								string text = sysFileCsv.ReadString(<reader>5__5, <delimiter>5__2, out newLine);
								if (text == null)
								{
									break;
								}
								<header>5__3.Add(text);
							}
							while (!newLine);
						}
						num2 = 0;
						bsonDocument = new BsonDocument();
						goto IL_019b;
					}
					if (num == 1)
					{
						<>1__state = -4;
						bsonDocument = new BsonDocument();
						num2 = 0;
						goto IL_019b;
					}
					result = false;
					goto end_IL_0000;
					IL_019b:
					while (true)
					{
						bool newLine2;
						string text2 = sysFileCsv.ReadString(<reader>5__5, <delimiter>5__2, out newLine2);
						if (text2 == null)
						{
							result = false;
							<>m__Finally2();
							<>m__Finally1();
							break;
						}
						if (num2 < <header>5__3.Count)
						{
							string name = <header>5__3[num2++];
							bsonDocument[name] = text2;
						}
						if (newLine2)
						{
							<>2__current = bsonDocument;
							<>1__state = 1;
							result = true;
							break;
						}
					}
					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;
				if (<fs>5__4 != null)
				{
					((IDisposable)<fs>5__4).Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<reader>5__5 != null)
				{
					((IDisposable)<reader>5__5).Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Input>d__2 <Input>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Input>d__ = this;
				}
				else
				{
					<Input>d__ = new <Input>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Input>d__.options = <>3__options;
				return <Input>d__;
			}

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

		private static readonly IFormatProvider _numberFormat = CultureInfo.InvariantCulture.NumberFormat;

		public SysFileCsv()
			: base("$file_csv")
		{
		}

		[IteratorStateMachine(typeof(<Input>d__2))]
		public override IEnumerable<BsonDocument> Input(BsonValue options)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Input>d__2(-2)
			{
				<>4__this = this,
				<>3__options = options
			};
		}

		public override int Output(IEnumerable<BsonDocument> source, BsonValue options)
		{
			string path = SystemCollection.GetOption(options, "filename")?.AsString ?? throw new LiteException(0, "Collection $file_json requires string as 'filename' or a document field 'filename'");
			bool asBoolean = SystemCollection.GetOption(options, "overwritten", false).AsBoolean;
			string asString = SystemCollection.GetOption(options, "encoding", "utf-8").AsString;
			char value = SystemCollection.GetOption(options, "delimiter", ",").AsString[0];
			bool asBoolean2 = SystemCollection.GetOption(options, "header", true).AsBoolean;
			int num = 0;
			IList<string> list = null;
			FileStream fileStream = null;
			StreamWriter streamWriter = null;
			try
			{
				foreach (BsonDocument item in source)
				{
					if (num++ == 0)
					{
						fileStream = new FileStream(path, (!asBoolean) ? FileMode.CreateNew : FileMode.OpenOrCreate);
						streamWriter = new StreamWriter(fileStream, Encoding.GetEncoding(asString));
						list = item.Keys.ToList();
						if (asBoolean2)
						{
							int num2 = 0;
							foreach (KeyValuePair<string, BsonValue> item2 in item)
							{
								if (num2++ > 0)
								{
									streamWriter.Write(value);
								}
								streamWriter.Write(item2.Key);
							}
							streamWriter.WriteLine();
						}
					}
					else
					{
						streamWriter.WriteLine();
					}
					int num3 = 0;
					foreach (string item3 in list)
					{
						BsonValue value2 = item[item3];
						if (num3++ > 0)
						{
							streamWriter.Write(value);
						}
						WriteValue(value2, streamWriter);
					}
				}
				if (num > 0)
				{
					streamWriter.Flush();
				}
			}
			finally
			{
				streamWriter?.Dispose();
				fileStream?.Dispose();
			}
			return num;
		}

		private void WriteValue(BsonValue value, StreamWriter writer)
		{
			switch (value.Type)
			{
			case BsonType.MinValue:
			case BsonType.Null:
			case BsonType.Document:
			case BsonType.Array:
			case BsonType.MaxValue:
				writer.Write("null");
				break;
			case BsonType.Int64:
				writer.Write(value.AsInt64.ToString(CultureInfo.InvariantCulture.NumberFormat));
				break;
			case BsonType.Decimal:
				writer.Write(value.AsDecimal.ToString(CultureInfo.InvariantCulture.NumberFormat));
				break;
			case BsonType.Binary:
				writer.Write("\"" + Convert.ToBase64String(value.AsBinary) + "\"");
				break;
			case BsonType.ObjectId:
				writer.Write("\"" + value.AsObjectId.ToString() + "\"");
				break;
			case BsonType.Guid:
				writer.Write("\"" + value.AsGuid.ToString() + "\"");
				break;
			case BsonType.DateTime:
				writer.Write("\"" + value.AsDateTime.ToUniversalTime().ToString("o") + "\"");
				break;
			default:
				writer.Write(value.ToString());
				break;
			}
		}

		private string ReadString(TextReader reader, char delimiter, out bool newLine)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = reader.Read();
			while (num == 10 || num == 13)
			{
				num = reader.Read();
			}
			if (num == -1)
			{
				newLine = true;
				return null;
			}
			if (num == 34)
			{
				while (num != -1)
				{
					num = reader.Read();
					if (num == 34)
					{
						int num2 = reader.Read();
						if (num2 != 34)
						{
							num = num2;
							break;
						}
						stringBuilder.Append('"');
					}
					else
					{
						stringBuilder.Append((char)num);
					}
				}
			}
			else
			{
				while (num != 10 && num != 13 && num != delimiter && num != -1)
				{
					stringBuilder.Append((char)num);
					num = reader.Read();
				}
			}
			newLine = num == 10 || num == 13;
			return stringBuilder.ToString();
		}
	}
	internal class SysFileJson : SystemCollection
	{
		[CompilerGenerated]
		private sealed class <Input>d__1 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private BsonValue options;

			public BsonValue <>3__options;

			public SysFileJson <>4__this;

			private FileStream <fs>5__2;

			private StreamReader <reader>5__3;

			private IEnumerator<BsonDocument> <>7__wrap3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -5) <= 2u || num == 1)
				{
					try
					{
						if ((uint)(num - -5) <= 1u || num == 1)
						{
							try
							{
								if (num == -5 || num == 1)
								{
									try
									{
									}
									finally
									{
										<>m__Finally3();
									}
								}
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<fs>5__2 = null;
				<reader>5__3 = null;
				<>7__wrap3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					SysFileJson sysFileJson = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						string path = SystemCollection.GetOption(options, "filename")?.AsString ?? throw new LiteException(0, "Collection $" + sysFileJson.Name + " requires string as 'filename' or a document field 'filename'");
						string asString = SystemCollection.GetOption(options, "encoding", "utf-8").AsString;
						<fs>5__2 = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
						<>1__state = -3;
						<reader>5__3 = new StreamReader(<fs>5__2, Encoding.GetEncoding(asString));
						<>1__state = -4;
						IEnumerable<BsonDocument> enumerable = from x in new JsonReader(<reader>5__3).DeserializeArray()
							select x.AsDocument;
						<>7__wrap3 = enumerable.GetEnumerator();
						<>1__state = -5;
						break;
					}
					case 1:
						<>1__state = -5;
						break;
					}
					if (<>7__wrap3.MoveNext())
					{
						BsonDocument current = <>7__wrap3.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally3();
					<>7__wrap3 = null;
					<>m__Finally2();
					<reader>5__3 = null;
					<>m__Finally1();
					<fs>5__2 = 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 (<fs>5__2 != null)
				{
					((IDisposable)<fs>5__2).Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<reader>5__3 != null)
				{
					((IDisposable)<reader>5__3).Dispose();
				}
			}

			private void <>m__Finally3()
			{
				<>1__state = -4;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Input>d__1 <Input>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Input>d__ = this;
				}
				else
				{
					<Input>d__ = new <Input>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<Input>d__.options = <>3__options;
				return <Input>d__;
			}

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

		public SysFileJson()
			: base("$file_json")
		{
		}

		[IteratorStateMachine(typeof(<Input>d__1))]
		public override IEnumerable<BsonDocument> Input(BsonValue options)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Input>d__1(-2)
			{
				<>4__this = this,
				<>3__options = options
			};
		}

		public override int Output(IEnumerable<BsonDocument> source, BsonValue options)
		{
			string path = SystemCollection.GetOption(options, "filename")?.AsString ?? throw new LiteException(0, "Collection $file_json requires string as filename or a document field 'filename'");
			bool asBoolean = SystemCollection.GetOption(options, "pretty", false).AsBoolean;
			int asInt = SystemCollection.GetOption(options, "indent", 4).AsInt32;
			string asString = SystemCollection.GetOption(options, "encoding", "utf-8").AsString;
			bool asBoolean2 = SystemCollection.GetOption(options, "overwritten", false).AsBoolean;
			int num = 0;
			FileStream fileStream = null;
			StreamWriter streamWriter = null;
			JsonWriter jsonWriter = null;
			try
			{
				foreach (BsonDocument item in source)
				{
					if (num++ == 0)
					{
						fileStream = new FileStream(path, (!asBoolean2) ? FileMode.CreateNew : FileMode.OpenOrCreate);
						streamWriter = new StreamWriter(fileStream, Encoding.GetEncoding(asString));
						jsonWriter = new JsonWriter(streamWriter)
						{
							Pretty = asBoolean,
							Indent = asInt
						};
						streamWriter.WriteLine("[");
					}
					else
					{
						streamWriter.WriteLine(",");
					}
					jsonWriter.Serialize(item);
				}
				if (num > 0)
				{
					streamWriter.WriteLine();
					streamWriter.Write("]");
					streamWriter.Flush();
				}
			}
			finally
			{
				streamWriter?.Dispose();
				fileStream?.Dispose();
			}
			return num;
		}
	}
	internal class SysPageList : SystemCollection
	{
		[CompilerGenerated]
		private sealed class <GetAllList>d__5 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			public SysPageList <>4__this;

			private TransactionService transaction;

			public TransactionService <>3__transaction;

			private Snapshot snapshot;

			public Snapshot <>3__snapshot;

			private IEnumerator<BsonDocument> <>7__wrap1;

			private Dictionary<uint, string>.Enumerator <>7__wrap2;

			private Snapshot <snap>5__4;

			private int <slot>5__5;

			private CollectionIndex[] <>7__wrap5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				switch (num)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -6:
				case -5:
				case -4:
				case 2:
				case 3:
					try
					{
						switch (num)
						{
						case -5:
						case 2:
							try
							{
							}
							finally
							{
								<>m__Finally3();
							}
							break;
						case -6:
						case 3:
							try
							{
							}
							finally
							{
								<>m__Finally4();
							}
							break;
						}
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = null;
				<snap>5__4 = null;
				<>7__wrap5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					SysPageList sysPageList = <>4__this;
					CollectionIndex[] array;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = sysPageList.GetList(sysPageList._header.FreeEmptyPageList, null, transaction, snapshot).GetEnumerator();
						<>1__state = -3;
						goto IL_008e;
					case 1:
						<>1__state = -3;
						goto IL_008e;
					case 2:
						<>1__state = -5;
						goto IL_0167;
					case 3:
						{
							<>1__state = -6;
							goto IL_023a;
						}
						IL_008e:
						if (<>7__wrap1.MoveNext())
						{
							BsonDocument current = <>7__wrap1.Current;
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						<>7__wrap2 = sysPageList._collections.GetEnumerator();
						<>1__state = -4;
						goto IL_0283;
						IL_0262:
						if (<slot>5__5 < <>7__wrap5.Length)
						{
							CollectionIndex collectionIndex = <>7__wrap5[<slot>5__5];
							IEnumerable<BsonDocument> list = sysPageList.GetList(collectionIndex.FreeIndexPageList, collectionIndex.Name, transaction, <snap>5__4);
							<>7__wrap1 = list.GetEnumerator();
							<>1__state = -6;
							goto IL_023a;
						}
						<>7__wrap5 = null;
						<snap>5__4 = null;
						goto IL_0283;
						IL_0283:
						if (<>7__wrap2.MoveNext())
						{
							KeyValuePair<uint, string> current2 = <>7__wrap2.Current;
							<snap>5__4 = transaction.CreateSnapshot(LockMode.Read, current2.Value, addIfNotExists: false);
							<slot>5__5 = 0;
							goto IL_0193;
						}
						<>m__Finally2();
						return false;
						IL_0167:
						if (<>7__wrap1.MoveNext())
						{
							BsonDocument current3 = <>7__wrap1.Current;
							<>2__current = current3;
							<>1__state = 2;
							return true;
						}
						<>m__Finally3();
						<>7__wrap1 = null;
						<slot>5__5++;
						goto IL_0193;
						IL_023a:
						if (<>7__wrap1.MoveNext())
						{
							BsonDocument current4 = <>7__wrap1.Current;
							<>2__current = current4;
							<>1__state = 3;
							return true;
						}
						<>m__Finally4();
						<>7__wrap1 = null;
						<slot>5__5++;
						goto IL_0262;
						IL_0193:
						if (<slot>5__5 < 5)
						{
							IEnumerable<BsonDocument> list2 = sysPageList.GetList(<snap>5__4.CollectionPage.FreeDataPageList[<slot>5__5], null, transaction, <snap>5__4);
							<>7__wrap1 = list2.GetEnumerator();
							<>1__state = -5;
							goto IL_0167;
						}
						array = <snap>5__4.CollectionPage.GetCollectionIndexes().ToArray();
						<>7__wrap5 = array;
						<slot>5__5 = 0;
						goto IL_0262;
					}
				}
				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();
				}
			}

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

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

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

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<GetAllList>d__5 <GetAllList>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetAllList>d__ = this;
				}
				else
				{
					<GetAllList>d__ = new <GetAllList>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetAllList>d__.transaction = <>3__transaction;
				<GetAllList>d__.snapshot = <>3__snapshot;
				return <GetAllList>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetList>d__6 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private uint pageID;

			public uint <>3__pageID;

			private Snapshot snapshot;

			public Snapshot <>3__snapshot;

			public SysPageList <>4__this;

			private string indexName;

			public string <>3__indexName;

			private TransactionService transaction;

			public TransactionService <>3__transaction;

			private BasePage <page>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SysPageList sysPageList = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (<page>5__2.NextPageID == uint.MaxValue)
					{
						goto IL_017a;
					}
					transaction.Safepoint();
					<page>5__2 = snapshot.GetPage<BasePage>(<page>5__2.NextPageID);
				}
				else
				{
					<>1__state = -1;
					if (pageID == uint.MaxValue)
					{
						return false;
					}
					<page>5__2 = snapshot.GetPage<BasePage>(pageID);
				}
				if (<page>5__2 != null)
				{
					sysPageList._collections.TryGetValue(<page>5__2.ColID, out var value);
					<>2__current = new BsonDocument
					{
						["pageID"] = (int)<page>5__2.PageID,
						["pageType"] = <page>5__2.PageType.ToString(),
						["slot"] = (int)<page>5__2.PageListSlot,
						["collection"] = value,
						["index"] = indexName,
						["freeBytes"] = <page>5__2.FreeBytes,
						["itemsCount"] = (int)<page>5__2.ItemsCount
					};
					<>1__state = 1;
					return true;
				}
				goto IL_017a;
				IL_017a:
				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]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<GetList>d__6 <GetList>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetList>d__ = this;
				}
				else
				{
					<GetList>d__ = new <GetList>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetList>d__.pageID = <>3__pageID;
				<GetList>d__.indexName = <>3__indexName;
				<GetList>d__.transaction = <>3__transaction;
				<GetList>d__.snapshot = <>3__snapshot;
				return <GetList>d__;
			}

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

		[CompilerGenerated]
		private sealed class <Input>d__4 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private BsonValue options;

			public BsonValue <>3__options;

			public SysPageList <>4__this;

			private IEnumerator<BsonDocument> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <Input>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 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					SysPageList sysPageList = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						BsonValue option = SystemCollection.GetOption(options, "pageID");
						TransactionService threadTransaction = sysPageList._monitor.GetThreadTransaction();
						Snapshot snapshot = threadTransaction.CreateSnapshot(LockMode.Read, "$", addIfNotExists: false);
						sysPageList._collections = sysPageList._header.GetCollections().ToDictionary((KeyValuePair<string, uint> x) => x.Value, (KeyValuePair<string, uint> x) => x.Key);
						IEnumerable<BsonDocument> enumerable = ((option != null) ? sysPageList.GetList((uint)option.AsInt32, null, threadTransaction, snapshot) : sysPageList.GetAllList(threadTransaction, snapshot));
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						BsonDocument current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = 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__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Input>d__4 <Input>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Input>d__ = this;
				}
				else
				{
					<Input>d__ = new <Input>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Input>d__.options = <>3__options;
				return <Input>d__;
			}

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

		private readonly HeaderPage _header;

		private readonly TransactionMonitor _monitor;

		private Dictionary<uint, string> _collections;

		public SysPageList(HeaderPage header, TransactionMonitor monitor)
			: base("$page_list")
		{
			_header = header;
			_monitor = monitor;
		}

		[IteratorStateMachine(typeof(<Input>d__4))]
		public override IEnumerable<BsonDocument> Input(BsonValue options)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Input>d__4(-2)
			{
				<>4__this = this,
				<>3__options = options
			};
		}

		[IteratorStateMachine(typeof(<GetAllList>d__5))]
		private IEnumerable<BsonDocument> GetAllList(TransactionService transaction, Snapshot snapshot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllList>d__5(-2)
			{
				<>4__this = this,
				<>3__transaction = transaction,
				<>3__snapshot = snapshot
			};
		}

		[IteratorStateMachine(typeof(<GetList>d__6))]
		private IEnumerable<BsonDocument> GetList(uint pageID, string indexName, TransactionService transaction, Snapshot snapshot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetList>d__6(-2)
			{
				<>4__this = this,
				<>3__pageID = pageID,
				<>3__indexName = indexName,
				<>3__transaction = transaction,
				<>3__snapshot = snapshot
			};
		}
	}
	internal class SysQuery : SystemCollection
	{
		[CompilerGenerated]
		private sealed class <Input>d__2 : IEnumerable<BsonDocument>, IEnumerable, IEnumerator<BsonDocument>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BsonDocument <>2__current;

			private int <>l__initialThreadId;

			private BsonValue options;

			public BsonValue <>3__options;

			public SysQuery <>4__this;

			private IBsonDataReader <reader>5__2;

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

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

			[DebuggerHidden]
			public <Input>d__2(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();
					}
				}
				<reader>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					SysQuery sysQuery = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						string source = options?.AsString ?? throw new LiteException(0, "Collection $query(sql) requires `sql` string parameter");
						SqlParser sqlParser = new SqlParser(sysQuery._engine, new Tokenizer(source), null);
						<reader>5__2 = sqlParser.Execute();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<reader>5__2.Read())
					{
						BsonValue current = <reader>5__2.Current;
						<>2__current = (current.IsDocument ? current.AsDocument : new BsonDocument { ["expr"] = current });
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<reader>5__2 = 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 (<reader>5__2 != null)
				{
					<reader>5__2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BsonDocument> IEnumerable<BsonDocument>.GetEnumerator()
			{
				<Input>d__2 <Input>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Input>d__ = this;
				}
				else
				{
					<Input>d__ = new <Input>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Input>d__.options = <>3__options;
				return <Input>d__;
			}

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

		private readonly ILiteEngine _engine;

		public SysQuery(ILiteEngine engine)
			: base("$query")
		{
			_engine = engine;
		}

		[IteratorStateMachine(typeof(<Input>d__2))]
		public override IEnumerable<BsonDocument> Input(BsonValue options)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Input>d__2(-2)
			{
				<>4__this = this,
				<>3__options = options
			};
		}
	}
	internal class SystemCollection
	{
		private readonly string _name;

		private readonly Func<IEnumerable<BsonDocument>> _input;

		public string Name => _name;

		public SystemCollection(string name)
		{
			if (!name.StartsWith("$"))
			{
				throw new ArgumentException("System collection name must starts with $");
			}
			_name = name;
		}

		public SystemCollection(string name, Func<IEnumerable<BsonDocument>> input)
			: this(name)
		{
			_input = input;
		}

		public virtual IEnumerable<BsonDocument> Input(BsonValue options)
		{
			return _input();
		}

		public virtual int Output(IEnumerable<BsonDocument> source, BsonValue options)
		{
			throw new LiteException(0, _name + " do not support as output collection");
		}

		protected static BsonValue GetOption(BsonValue options, string key)
		{
			return GetOption(options, key, null);
		}

		protected static BsonValue GetOption(BsonValue options, string key, BsonValue defaultValue)
		{
			if (options != null && options.IsDocument)
			{
				if (options.AsDocument.TryGetValue(key, out var value))
				{
					if (defaultValue == null || value.Type == defaultValue.Type)
					{
						return value;
					}
					throw new LiteException(0, $"Parameter `{key}` expect {defaultValue.Type} value type");
				}
				return defaultValue;
			}
			if (!(defaultValue == null))
			{
				return defaultValue;
			}
			return options;
		}
	}
}
namespace LiteDB.Vector
{
	internal static class LiteCollectionVectorExtensions
	{
		public static bool EnsureIndex<T>(this ILiteCollection<T> collection, string name, BsonExpression expression, VectorIndexOptions options)
		{
			return Unwrap(collection).EnsureVectorIndex(name, expression, options);
		}

		public static bool EnsureIndex<T>(this ILiteCollection<T> collection, BsonExpression expression, VectorIndexOptions options)
		{
			return Unwrap(collection).EnsureVectorIndex(expression, options);
		}

		public static bool EnsureIndex<T, K>(this ILiteCollection<T> collection, Expression<Func<T, K>> keySelector, VectorIndexOptions options)
		{
			return Unwrap(collection).EnsureVectorIndex(keySelector, options);
		}

		public static bool EnsureIndex<T, K>(this ILiteCollection<T> collection, string name, Expression<Func<T, K>> keySelector, VectorIndexOptions options)
		{
			return Unwrap(collection).EnsureVectorIndex(name, keySelector, options);
		}

		private static LiteCollection<T> Unwrap<T>(ILiteCollection<T> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			if (collection is LiteCollection<T> result)
			{
				return result;
			}
			throw new ArgumentException("Vector index operations require LiteDB's default collection implementation.", "collection");
		}
	}
	internal static class LiteQueryableVectorExtensions
	{
		public static ILiteQueryable<T> WhereNear<T>(this ILiteQueryable<T> source, string vectorField, float[] target, double maxDistance)
		{
			return Unwrap(source).VectorWhereNear(vectorField, target, maxDistance);
		}

		public static ILiteQueryable<T> WhereNear<T>(this ILiteQueryable<T> source, BsonExpression fieldExpr, float[] target, double maxDistance)
		{
			return Unwrap(source).VectorWhereNear(fieldExpr, target, maxDistance);
		}

		public static ILiteQueryable<T> WhereNear<T, K>(this ILiteQueryable<T> source, Expression<Func<T, K>> field, float[] target, double maxDistance)
		{
			return Unwrap(source).VectorWhereNear(field, target, maxDistance);
		}

		public static IEnumerable<T> FindNearest<T>(this ILiteQueryable<T> source, string vectorField, float[] target, double maxDistance)
		{
			return Unwrap(source).VectorWhereNear(vectorField, target, maxDistance).ToEnumerable();
		}

		public static ILiteQueryableResult<T> TopKNear<T, K>(this ILiteQueryable<T> source, Expression<Func<T, K>> field, float[] target, int k)
		{
			return Unwrap(source).VectorTopKNear(field, target, k);
		}

		public static ILiteQueryableResult<T> TopKNear<T>(this ILiteQueryable<T> source, string field, float[] target, int k)
		{
			return Unwrap(source).VectorTopKNear(field, target, k);
		}

		public static ILiteQueryableResult<T> TopKNear<T>(this ILiteQueryable<T> source, BsonExpression fieldExpr, float[] target, int k)
		{
			return Unwrap(source).VectorTopKNear(fieldExpr, target, k);
		}

		private static LiteQueryable<T> Unwrap<T>(ILiteQueryable<T> source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (source is LiteQueryable<T> result)
			{
				return result;
			}
			throw new ArgumentException("Vector operations require LiteDB's default queryable implementation.", "source");
		}
	}
	internal static class LiteRepositoryVectorExtensions
	{
		public static bool EnsureIndex<T>(this ILiteRepository repository, string name, BsonExpression expression, VectorIndexOptions options, string collectionName = null)
		{
			return Unwrap(repository).EnsureVectorIndex<T>(name, expression, options, collectionName);
		}

		public static bool EnsureIndex<T>(this ILiteRepository repository, BsonExpression expression, VectorIndexOptions options, string collectionName = null)
		{
			return Unwrap(repository).EnsureVectorIndex<T>(expression, options, collectionName);
		}

		public static bool EnsureIndex<T, K>(this ILiteRepository repository, Expression<Func<T, K>> keySelector, VectorIndexOptions options, string collectionName = null)
		{
			return Unwrap(repository).EnsureVectorIndex(keySelector, options, collectionName);
		}

		public static bool EnsureIndex<T, K>(this ILiteRepository repository, string name, Expression<Func<T, K>> keySelector, VectorIndexOptions options, string collectionName = null)
		{
			return Unwrap(repository).EnsureVectorIndex(name, keySelector, options, collectionName);
		}

		private static LiteRepository Unwrap(ILiteRepository repository)
		{
			if (repository == null)
			{
				throw new ArgumentNullException("repository");
			}
			if (repository is LiteRepository result)
			{
				return result;
			}
			throw new ArgumentException("Vector index operations require LiteDB's default repository implementation.", "repository");
		}
	}
	internal enum VectorDistanceMetric : byte
	{
		Euclidean,
		Cosine,
		DotProduct
	}
	internal sealed class VectorIndexOptions
	{
		public ushort Dimensions { get; }

		public VectorDistanceMetric Metric { get; }

		public VectorIndexOptions(ushort dimensions, VectorDistanceMetric metric = VectorDistanceMetric.Cosine)
		{
			if (dimensions == 0)
			{
				throw new ArgumentOutOfRangeException("dimensions", dimensions, "Dimensions must be greater than zero.");
			}
			Dimensions = dimensions;
			Metric = metric;
		}
	}
}
namespace LiteDB.Client.Shared
{
	internal static class SharedMutexNameFactory
	{
		private const int WINDOWS_MUTEX_NAME_MAX = 250;

		private const int CONSERVATIVE_EXTERNAL_PREFIX_LENGTH = 13;

		internal static string Create(string fileName, SharedMutexNameStrategy strategy)
		{
			return strategy switch
			{
				SharedMutexNameStrategy.Default => CreateUsingUriEncodingWithFallback(fileName), 
				SharedMutexNameStrategy.UriEscape => CreateUsingUriEncoding(fileName), 
				SharedMutexNameStrategy.Sha1Hash => CreateUsingSha1(fileName), 
				_ => throw new ArgumentOutOfRangeException("strategy", strategy, null), 
			};
		}

		private static string CreateUsingUriEncodingWithFallback(string fileName)
		{
			string text = Normalize(fileName);
			string text2 = Uri.EscapeDataString(text);
			if (IsWindows() && text2.Length + 13 > 250)
			{
				return "sha1-" + ComputeSha1Hex(text);
			}
			return text2;
		}

		private static string CreateUsingUriEncoding(string fileName)
		{
			string text = Normalize(fileName);
			string text2 = Uri.EscapeDataString(text);
			if (IsWindows() && text2.Length + 13 > 250)
			{
				return "sha1-" + ComputeSha1Hex(text);
			}
			return text2;
		}

		private static bool IsWindows()
		{
			return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
		}

		internal static string CreateUsingSha1(string value)
		{
			return ComputeSha1Hex(Normalize(value));
		}

		private static string Normalize(string path)
		{
			return Path.GetFullPath(path).ToLowerInvariant();
		}

		private static string ComputeSha1Hex(string input)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(input);
			using SHA1 sHA = SHA1.Create();
			byte[] array = sHA.ComputeHash(bytes);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("X2"));
			}
			return stringBuilder.ToString();
		}
	}
}
[CompilerGenerated]
internal sealed class <4841a9b5-eb72-4db5-b843-508d8f28cfef><PrivateImplementationDetails>
{
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 16)]
	internal struct __StaticArrayInitTypeSize=16
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 20)]
	internal struct __StaticArrayInitTypeSize=20
	{
	}

	internal static readonly __StaticArrayInitTypeSize=20 922EDBD4B9866F46F53D8ECEAC2CEF018353178303D75DB92D7C5B22C48B701F/* Not supported: data(0C 00 00 00 32 00 00 00 64 00 00 00 F4 01 00 00 E8 03 00 00) */;

	internal static readonly __StaticArrayInitTypeSize=16 EAA0F1FB54F6BEDA002754D2D7C470521C67E524EE1700421AA371706C1C8270/* Not supported: data(B0 1C 00 00 E8 17 00 00 20 13 00 00 90 09 00 00) */;
}
namespace FxResources.System.Buffers
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class <f389ca43-32bf-4e24-ad8c-a6ed5efddff3>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(<f389ca43-32bf-4e24-ad8c-a6ed5efddff3>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 System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsByRefLikeAttribute : Attribute
	{
	}
}
namespace FxResources.System.Memory
{
	internal static class SR
	{
	}
}
namespace System
{
	internal readonly 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 <075f253c-571b-4ba4-adf1-4b6a86403830>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(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.Format(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.Argument_InvalidTypeWithPointersNotSupported, type));
		}

		internal static void ThrowArgumentException_DestinationTooShort()
		{
			throw CreateArgumentException_DestinationTooShort();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentException_DestinationTooShort()
		{
			return new ArgumentException(<075f253c-571b-4ba4-adf1-4b6a86403830>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", <075f253c-571b-4ba4-adf1-4b6a86403830>SR.Format(<075f253c-571b-4ba4-adf1-4b6a86403830>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", <075f253c-571b-4ba4-adf1-4b6a86403830>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(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.OutstandingReferences);
		}

		internal static void ThrowInvalidOperationException_UnexpectedSegmentType()
		{
			throw CreateInvalidOperationException_UnexpectedSegmentType();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateInvalidOperationException_UnexpectedSegmentType()
		{
			return new InvalidOperationException(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.UnexpectedSegmentType);
		}

		internal static void ThrowInvalidOperationException_EndPositionNotReached()
		{
			throw CreateInvalidOperationException_EndPositionNotReached();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateInvalidOperationException_EndPositionNotReached()
		{
			return new InvalidOperationException(<075f253c-571b-4ba4-adf1-4b6a86403830>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(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.Argument_BadFormatSpecifier);
		}

		internal static void ThrowArgumentException_OverlapAlignmentMismatch()
		{
			throw CreateArgumentException_OverlapAlignmentMismatch();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentException_OverlapAlignmentMismatch()
		{
			return new ArgumentException(<075f253c-571b-4ba4-adf1-4b6a86403830>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 value2 = 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)) && (value2.High < 429496729 || (value2.High == 429496729 && (value2.Mid < 2576980377u || (value2.Mid == 2576980377u && (value2.Low < 2576980377u || (value2.Low == 2576980377u && *ptr <= 53)))))))
				{
					DecimalDecCalc.DecMul10(ref value2);
					if (*ptr != 0)
					{
						DecimalDecCalc.DecAddInt32(ref value2, (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 value2, 1u);
						if ((value2.High | value2.Mid | value2.Low) == 0)
						{
							value2.High = 429496729u;
							value2.Mid = 2576980377u;
							value2.Low = 2576980378u;
							num++;
						}
					}
				}
			}
			if (num > 0)
			{
				return false;
			}
			if (num <= -29)
			{
				value2.High = 0u;
				value2.Low = 0u;
				value2.Mid = 0u;
				value2.Scale = 28;
			}
			else
			{
				value2.Scale = -num;
			}
			value2.IsNegative = number.IsNegative;
			value = System.Runtime.CompilerServices.Unsafe.As<MutableDecimal, decimal>(ref value2);
			return true;
		}

		public static void DecimalToNumber(decimal value, ref NumberBuffer number)
		{
			ref MutableDecimal reference = ref System.Runtime.CompilerServices.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);
		}
	}
	internal ref 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>(System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(ref _b0), 51);

		public unsafe byte* UnsafeDigits => (byte*)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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();
		}
	}
	[DebuggerTypeProxy(typeof(System.MemoryDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	internal readonly 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
			{
				Span<T> result;
				if (_index < 0)
				{
					result = ((MemoryManager<T>)_object).GetSpan();
					return result.Slice(_index & 0x7FFFFFFF, _length);
				}
				if (typeof(T) == typeof(char) && _object is string text)
				{
					result = new Span<T>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)text), MemoryExtensions.StringAdjustment, text.Length);
					return result.Slice(_index, _length);
				}
				if (_object != null)
				{
					return new Span<T>((T[])_object, _index, _length & 0x7FFFFFFF);
				}
				result = default(Span<T>);
				return result;
			}
		}

		[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 System.Runtime.CompilerServices.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 = System.Runtime.CompilerServices.Unsafe.Add<T>((void*)handle.AddrOfPinnedObject(), _index);
				return new MemoryHandle(pointer, handle);
			}
			if (_object is T[] array)
			{
				if (_length < 0)
				{
					void* pointer2 = System.Runtime.CompilerServices.Unsafe.Add<T>(System.Runtime.CompilerServices.Unsafe.AsPointer<T>(ref MemoryMarshal.GetReference<T>(array)), _index);
					return new MemoryHandle(pointer2);
				}
				GCHandle handle2 = GCHandle.Alloc(array, GCHandleType.Pinned);
				void* pointer3 = System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.IndexOf(ref System.Runtime.CompilerServices.Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.LastIndexOf(ref System.Runtime.CompilerServices.Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.SequenceCompareTo(ref System.Runtime.CompilerServices.Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.IndexOf(ref System.Runtime.CompilerServices.Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.LastIndexOf(ref System.Runtime.CompilerServices.Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value1), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value1), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value1), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value0), System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value1), System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.SequenceCompareTo(ref System.Runtime.CompilerServices.Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref MemoryMarshal.GetReference(span), length - length2)), ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (NUInt)length2 * size);
				}
				return false;
			}
			if (length2 <= length)
			{
				return System.SpanHelpers.SequenceEqual(ref System.Runtime.CompilerServices.Unsafe.Add<T>(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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref MemoryMarshal.GetReference(span), length - length2)), ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (NUInt)length2 * size);
				}
				return false;
			}
			if (length2 <= length)
			{
				return System.SpanHelpers.SequenceEqual(ref System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, num);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, num) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, num2);
				System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.ByteOffset<T>(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other));
			if (System.Runtime.CompilerServices.Unsafe.SizeOf<IntPtr>() == 4)
			{
				if ((uint)(int)intPtr >= (uint)(span.Length * System.Runtime.CompilerServices.Unsafe.SizeOf<T>()))
				{
					return (uint)(int)intPtr > (uint)(-(other.Length * System.Runtime.CompilerServices.Unsafe.SizeOf<T>()));
				}
				return true;
			}
			if ((ulong)(long)intPtr >= (ulong)((long)span.Length * (long)System.Runtime.CompilerServices.Unsafe.SizeOf<T>()))
			{
				return (ulong)(long)intPtr > (ulong)(-((long)other.Length * (long)System.Runtime.CompilerServices.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 = System.Runtime.CompilerServices.Unsafe.ByteOffset<T>(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other));
			if (System.Runtime.CompilerServices.Unsafe.SizeOf<IntPtr>() == 4)
			{
				if ((uint)(int)intPtr < (uint)(span.Length * System.Runtime.CompilerServices.Unsafe.SizeOf<T>()) || (uint)(int)intPtr > (uint)(-(other.Length * System.Runtime.CompilerServices.Unsafe.SizeOf<T>())))
				{
					if ((int)intPtr % System.Runtime.CompilerServices.Unsafe.SizeOf<T>() != 0)
					{
						System.ThrowHelper.ThrowArgumentException_OverlapAlignmentMismatch();
					}
					elementOffset = (int)intPtr / System.Runtime.CompilerServices.Unsafe.SizeOf<T>();
					return true;
				}
				elementOffset = 0;
				return false;
			}
			if ((ulong)(long)intPtr < (ulong)((long)span.Length * (long)System.Runtime.CompilerServices.Unsafe.SizeOf<T>()) || (ulong)(long)intPtr > (ulong)(-((long)other.Length * (long)System.Runtime.CompilerServices.Unsafe.SizeOf<T>())))
			{
				if ((long)intPtr % System.Runtime.CompilerServices.Unsafe.SizeOf<T>() != 0L)
				{
					System.ThrowHelper.ThrowArgumentException_OverlapAlignmentMismatch();
				}
				elementOffset = (int)((long)intPtr / System.Runtime.CompilerServices.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>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<char>>((object)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>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<char>>((object)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>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<char>>((object)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* ptr = text)
			{
				return System.Runtime.CompilerServices.Unsafe.ByteOffset<char>(ref System.Runtime.CompilerServices.Unsafe.As<Pinnable<char>>((object)text).Data, ref System.Runtime.CompilerServices.Unsafe.AsRef<char>((void*)ptr));
			}
		}
	}
	[DebuggerTypeProxy(typeof(System.MemoryDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	internal readonly 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);
				}
				ReadOnlySpan<T> result;
				if (typeof(T) == typeof(char) && _object is string text)
				{
					result = new ReadOnlySpan<T>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)text), MemoryExtensions.StringAdjustment, text.Length);
					return result.Slice(_index, _length);
				}
				if (_object != null)
				{
					return new ReadOnlySpan<T>((T[])_object, _index, _length & 0x7FFFFFFF);
				}
				result = default(ReadOnlySpan<T>);
				return result;
			}
		}

		[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 = System.Runtime.CompilerServices.Unsafe.Add<T>((void*)handle.AddrOfPinnedObject(), _index);
				return new MemoryHandle(pointer, handle);
			}
			if (_object is T[] array)
			{
				if (_length < 0)
				{
					void* pointer2 = System.Runtime.CompilerServices.Unsafe.Add<T>(System.Runtime.CompilerServices.Unsafe.AsPointer<T>(ref MemoryMarshal.GetReference<T>(array)), _index);
					return new MemoryHandle(pointer2);
				}
				GCHandle handle2 = GCHandle.Alloc(array, GCHandleType.Pinned);
				void* pointer3 = System.Runtime.CompilerServices.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;
		}
	}
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	internal readonly ref struct ReadOnlySpan<T>
	{
		public ref struct Enumerator
		{
			private readonly ReadOnlySpan<T> _span;

			private int _index;

			public ref readonly T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				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>);

		public unsafe ref readonly T this[int index]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((uint)index >= (uint)_length)
				{
					System.ThrowHelper.ThrowIndexOutOfRangeException();
				}
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					return ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref System.Runtime.CompilerServices.Unsafe.AsRef<T>(byteOffset.ToPointer()), index);
				}
				return ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(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(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.NotSupported_CannotCallEqualsOnSpan);
		}

		[Obsolete("GetHashCode() on ReadOnlySpan will always throw an exception.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			throw new NotSupportedException(<075f253c-571b-4ba4-adf1-4b6a86403830>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 = System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)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 = System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)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)]
		public unsafe ref readonly T GetPinnableReference()
		{
			if (_length != 0)
			{
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					return ref System.Runtime.CompilerServices.Unsafe.AsRef<T>(byteOffset.ToPointer());
				}
				return ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(ref _pinnable.Data, _byteOffset);
			}
			return ref System.Runtime.CompilerServices.Unsafe.AsRef<T>((void*)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 System.Runtime.CompilerServices.Unsafe.AreSame<T>(ref left.DangerousGetPinnableReference(), ref right.DangerousGetPinnableReference());
			}
			return false;
		}

		public unsafe override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				if (_byteOffset == MemoryExtensions.StringAdjustment)
				{
					object obj = System.Runtime.CompilerServices.Unsafe.As<object>((object)_pinnable);
					if (obj is string text && _length == text.Length)
					{
						return text;
					}
				}
				fixed (char* value = &System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.AsRef<T>(byteOffset.ToPointer());
			}
			return ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(ref _pinnable.Data, _byteOffset);
		}
	}
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	internal readonly ref struct Span<T>
	{
		public ref 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 System.Runtime.CompilerServices.Unsafe.Add<T>(ref System.Runtime.CompilerServices.Unsafe.AsRef<T>(byteOffset.ToPointer()), index);
				}
				return ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(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);
		}

		[Obsolete("Equals() on Span will always throw an exception. Use == instead.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object obj)
		{
			throw new NotSupportedException(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.NotSupported_CannotCallEqualsOnSpan);
		}

		[Obsolete("GetHashCode() on Span will always throw an exception.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			throw new NotSupportedException(<075f253c-571b-4ba4-adf1-4b6a86403830>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 = System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)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>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)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 = System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)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 System.Runtime.CompilerServices.Unsafe.AsRef<T>(byteOffset.ToPointer());
				}
				return ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(ref _pinnable.Data, _byteOffset);
			}
			return ref System.Runtime.CompilerServices.Unsafe.AsRef<T>((void*)null);
		}

		public unsafe void Clear()
		{
			int length = _length;
			if (length == 0)
			{
				return;
			}
			UIntPtr byteLength = (UIntPtr)(ulong)((uint)length * System.Runtime.CompilerServices.Unsafe.SizeOf<T>());
			if ((System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(ref _pinnable.Data, _byteOffset)), byteLength);
				}
			}
			else if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				UIntPtr pointerSizeLength = (UIntPtr)(ulong)(length * System.Runtime.CompilerServices.Unsafe.SizeOf<T>() / sizeof(IntPtr));
				System.SpanHelpers.ClearPointerSizedWithReferences(ref System.Runtime.CompilerServices.Unsafe.As<T, IntPtr>(ref DangerousGetPinnableReference()), pointerSizeLength);
			}
			else
			{
				System.SpanHelpers.ClearPointerSizedWithoutReferences(ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref DangerousGetPinnableReference()), byteLength);
			}
		}

		public unsafe void Fill(T value)
		{
			int length = _length;
			if (length == 0)
			{
				return;
			}
			if (System.Runtime.CompilerServices.Unsafe.SizeOf<T>() == 1)
			{
				byte b = System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref value);
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(byteOffset.ToPointer(), b, (uint)length);
				}
				else
				{
					System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(ref _pinnable.Data, _byteOffset)), b, (uint)length);
				}
				return;
			}
			ref T reference = ref DangerousGetPinnableReference();
			int i;
			for (i = 0; i < (length & -8); i += 8)
			{
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 1) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 2) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 3) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 4) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 5) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 6) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 7) = value;
			}
			if (i < (length & -4))
			{
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 1) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 2) = value;
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, i + 3) = value;
				i += 4;
			}
			for (; i < length; i++)
			{
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref reference, 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 System.Runtime.CompilerServices.Unsafe.AreSame<T>(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 = &System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.Unsafe.AsRef<T>(byteOffset.ToPointer());
			}
			return ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(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 System.Runtime.CompilerServices.Unsafe.ByteOffset<T>(ref System.Runtime.CompilerServices.Unsafe.As<Pinnable<T>>((object)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(System.Runtime.CompilerServices.Unsafe.Add<T>(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 System.Runtime.CompilerServices.Unsafe.Add<byte>(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 System.Runtime.CompilerServices.Unsafe.Add<byte>(ref searchSpace, num2), value2, num3);
				if (num4 == -1)
				{
					break;
				}
				num2 += num4;
				if (SequenceEqual(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(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, System.Runtime.CompilerServices.Unsafe.Add<byte>(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, System.Runtime.CompilerServices.Unsafe.Add<byte>(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)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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 == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr))
					{
						goto IL_0242;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1))
					{
						goto IL_024a;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2))
					{
						goto IL_0258;
					}
					if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3))
					{
						if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 4))
						{
							if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 5))
							{
								if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 6))
								{
									if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr))
					{
						goto IL_0242;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1))
					{
						goto IL_024a;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2))
					{
						goto IL_0258;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3))
					{
						goto IL_0266;
					}
					intPtr += 4;
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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, System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 System.Runtime.CompilerServices.Unsafe.Add<byte>(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 System.Runtime.CompilerServices.Unsafe.Add<byte>(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)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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 == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 7))
					{
						break;
					}
					if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 6))
					{
						if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 5))
						{
							if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 4))
							{
								if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3))
								{
									if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2))
									{
										if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1))
										{
											if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3))
					{
						goto IL_0278;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2))
					{
						goto IL_026a;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1))
					{
						goto IL_025c;
					}
					if (value == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr))
					{
						goto IL_0254;
					}
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					intPtr -= 1;
					if (value != System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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, System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_02ff;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0307;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0315;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
					if (value0 != num2 && value1 != num2)
					{
						num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 4);
						if (value0 != num2 && value1 != num2)
						{
							num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 5);
							if (value0 != num2 && value1 != num2)
							{
								num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 6);
								if (value0 != num2 && value1 != num2)
								{
									num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_02ff;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0307;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0315;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0323;
					}
					intPtr += 4;
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					uint num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_0393;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_039b;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03a9;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
					if (value0 != num2 && value1 != num2 && value2 != num2)
					{
						num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 4);
						if (value0 != num2 && value1 != num2 && value2 != num2)
						{
							num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 5);
							if (value0 != num2 && value1 != num2 && value2 != num2)
							{
								num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 6);
								if (value0 != num2 && value1 != num2 && value2 != num2)
								{
									num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_0393;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_039b;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03a9;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03b7;
					}
					intPtr += 4;
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					uint num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 7);
					if (value0 == num2 || value1 == num2)
					{
						break;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 6);
					if (value0 != num2 && value1 != num2)
					{
						num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 5);
						if (value0 != num2 && value1 != num2)
						{
							num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 4);
							if (value0 != num2 && value1 != num2)
							{
								num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
								if (value0 != num2 && value1 != num2)
								{
									num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
									if (value0 != num2 && value1 != num2)
									{
										num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
										if (value0 != num2 && value1 != num2)
										{
											num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0338;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_032a;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_031c;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0314;
					}
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					intPtr -= 1;
					uint num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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)System.Runtime.CompilerServices.Unsafe.AsPointer<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 7);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						break;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 6);
					if (value0 != num2 && value1 != num2 && value2 != num2)
					{
						num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 5);
						if (value0 != num2 && value1 != num2 && value2 != num2)
						{
							num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 4);
							if (value0 != num2 && value1 != num2 && value2 != num2)
							{
								num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
								if (value0 != num2 && value1 != num2 && value2 != num2)
								{
									num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
									if (value0 != num2 && value1 != num2 && value2 != num2)
									{
										num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
										if (value0 != num2 && value1 != num2 && value2 != num2)
										{
											num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03cf;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03c1;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03b3;
					}
					num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03ab;
					}
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					intPtr -= 1;
					uint num2 = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 = System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 (System.Runtime.CompilerServices.Unsafe.AreSame<byte>(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 (System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr)) != System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref second, intPtr)))
						{
							break;
						}
						intPtr += Vector<byte>.Count;
						continue;
					}
					return System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr2)) == System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref second, intPtr2));
				}
			}
			else
			{
				if ((nuint)(void*)intPtr2 < (nuint)sizeof(UIntPtr))
				{
					while ((void*)intPtr2 > (void*)intPtr)
					{
						if (System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr) == System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref second, intPtr))
						{
							intPtr += 1;
							continue;
						}
						goto IL_013f;
					}
					goto IL_013d;
				}
				intPtr2 -= sizeof(UIntPtr);
				while (true)
				{
					if ((void*)intPtr2 > (void*)intPtr)
					{
						if (System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr)) != System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref second, intPtr)))
						{
							break;
						}
						intPtr += sizeof(UIntPtr);
						continue;
					}
					return System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr2)) == System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 (!System.Runtime.CompilerServices.Unsafe.AreSame<byte>(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 && !(System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr2)) != System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<byte>>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref second, intPtr2))); intPtr2 += Vector<byte>.Count)
					{
					}
				}
				else if ((nuint)(void*)intPtr3 > (nuint)sizeof(UIntPtr))
				{
					intPtr3 -= sizeof(UIntPtr);
					for (; (void*)intPtr3 > (void*)intPtr2 && !(System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr2)) != System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref second, intPtr2))); intPtr2 += sizeof(UIntPtr))
					{
					}
				}
				for (; (void*)intPtr > (void*)intPtr2; intPtr2 += 1)
				{
					int num = System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(ref first, intPtr2).CompareTo(System.Runtime.CompilerServices.Unsafe.AddByteOffset<byte>(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 (!System.Runtime.CompilerServices.Unsafe.AreSame<char>(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 (!(System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<ushort>>(ref System.Runtime.CompilerServices.Unsafe.As<char, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<char>(ref first, intPtr2))) != System.Runtime.CompilerServices.Unsafe.ReadUnaligned<Vector<ushort>>(ref System.Runtime.CompilerServices.Unsafe.As<char, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<char>(ref second, intPtr2)))))
						{
							intPtr2 += Vector<ushort>.Count;
							if ((void*)intPtr3 < (void*)intPtr2)
							{
								break;
							}
						}
					}
					for (; (void*)intPtr >= (void*)(intPtr2 + sizeof(UIntPtr) / 2) && !(System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.As<char, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<char>(ref first, intPtr2))) != System.Runtime.CompilerServices.Unsafe.ReadUnaligned<UIntPtr>(ref System.Runtime.CompilerServices.Unsafe.As<char, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<char>(ref second, intPtr2)))); intPtr2 += sizeof(UIntPtr) / 2)
					{
					}
				}
				if (sizeof(UIntPtr) > 4 && (void*)intPtr >= (void*)(intPtr2 + 2) && System.Runtime.CompilerServices.Unsafe.ReadUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.As<char, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<char>(ref first, intPtr2))) == System.Runtime.CompilerServices.Unsafe.ReadUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.As<char, byte>(ref System.Runtime.CompilerServices.Unsafe.Add<char>(ref second, intPtr2))))
				{
					intPtr2 += 2;
				}
				for (; (void*)intPtr2 < (void*)intPtr; intPtr2 += 1)
				{
					int num = System.Runtime.CompilerServices.Unsafe.Add<char>(ref first, intPtr2).CompareTo(System.Runtime.CompilerServices.Unsafe.Add<char>(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 & (System.Runtime.CompilerServices.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, System.Runtime.CompilerServices.Unsafe.Read<Vector<ushort>>((void*)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 & (System.Runtime.CompilerServices.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, System.Runtime.CompilerServices.Unsafe.Read<Vector<ushort>>((void*)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 System.Runtime.CompilerServices.Unsafe.Add<T>(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 System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num2), value2, num3);
				if (num4 == -1)
				{
					break;
				}
				num2 += num4;
				if (SequenceEqual(ref System.Runtime.CompilerServices.Unsafe.Add<T>(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(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr)))
					{
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 1)))
						{
							goto IL_020a;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 2)))
						{
							goto IL_0218;
						}
						if (!value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 3)))
						{
							if (!value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 4)))
							{
								if (!value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 5)))
								{
									if (!value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 6)))
									{
										if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(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(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr)))
						{
							goto IL_0202;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 1)))
						{
							goto IL_020a;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 2)))
						{
							goto IL_0218;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, intPtr + 3)))
						{
							goto IL_0226;
						}
						intPtr += 4;
					}
					while (true)
					{
						if (length > 0)
						{
							if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cb;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cf;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 3);
						if (!value0.Equals(other) && !value1.Equals(other))
						{
							other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 4);
							if (!value0.Equals(other) && !value1.Equals(other))
							{
								other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 5);
								if (!value0.Equals(other) && !value1.Equals(other))
								{
									other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 6);
									if (!value0.Equals(other) && !value1.Equals(other))
									{
										other = System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c9;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cb;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cf;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 3);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02d3;
						}
						num += 4;
					}
					while (true)
					{
						if (num < length)
						{
							T other = System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c2;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c6;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 3);
						if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
						{
							other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 4);
							if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
							{
								other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 5);
								if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
								{
									other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 6);
									if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
									{
										other = System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c0;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c2;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c6;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(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, System.Runtime.CompilerServices.Unsafe.Add<T>(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 System.Runtime.CompilerServices.Unsafe.Add<T>(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 System.Runtime.CompilerServices.Unsafe.Add<T>(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(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 7)))
					{
						break;
					}
					if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 6)))
					{
						return length + 6;
					}
					if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 5)))
					{
						return length + 5;
					}
					if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 4)))
					{
						return length + 4;
					}
					if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 3)))
					{
						goto IL_01c2;
					}
					if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 2)))
					{
						goto IL_01be;
					}
					if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 1)))
					{
						goto IL_01ba;
					}
					if (!value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length)))
					{
						continue;
					}
				}
				else
				{
					if (length >= 4)
					{
						length -= 4;
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 3)))
						{
							goto IL_01c2;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 2)))
						{
							goto IL_01be;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 1)))
						{
							goto IL_01ba;
						}
						if (value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length)))
						{
							goto IL_01b8;
						}
					}
					do
					{
						if (length > 0)
						{
							length--;
							continue;
						}
						return -1;
					}
					while (!value.Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 7);
					if (value0.Equals(other) || value1.Equals(other))
					{
						break;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 6);
					if (value0.Equals(other) || value1.Equals(other))
					{
						return length + 6;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 5);
					if (value0.Equals(other) || value1.Equals(other))
					{
						return length + 5;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 4);
					if (value0.Equals(other) || value1.Equals(other))
					{
						return length + 4;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 3);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_02cd;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 2);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_02c9;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 1);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_02c5;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						continue;
					}
				}
				else
				{
					T other;
					if (length >= 4)
					{
						length -= 4;
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 3);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cd;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 2);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c9;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 1);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c5;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c3;
						}
					}
					do
					{
						if (length > 0)
						{
							length--;
							other = System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 7);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						break;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 6);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						return length + 6;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 5);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						return length + 5;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 4);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						return length + 4;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 3);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_03da;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 2);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_03d5;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 1);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_03d0;
					}
					other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						continue;
					}
				}
				else
				{
					T other;
					if (length >= 4)
					{
						length -= 4;
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 3);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03da;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 2);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03d5;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length + 1);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03d0;
						}
						other = System.Runtime.CompilerServices.Unsafe.Add<T>(ref searchSpace, length);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03cd;
						}
					}
					do
					{
						if (length > 0)
						{
							length--;
							other = System.Runtime.CompilerServices.Unsafe.Add<T>(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, System.Runtime.CompilerServices.Unsafe.Add<T>(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 (!System.Runtime.CompilerServices.Unsafe.AreSame<T>(ref first, ref second))
			{
				IntPtr intPtr = (IntPtr)0;
				while (true)
				{
					if (length >= 8)
					{
						length -= 8;
						if (System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 1).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 1)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 2).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 2)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 3).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 3)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 4).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 4)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 5).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 5)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 6).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 6)) && System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 7).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 7)))
						{
							intPtr += 8;
							continue;
						}
						goto IL_028b;
					}
					if (length >= 4)
					{
						length -= 4;
						if (!System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr)) || !System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 1).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 1)) || !System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 2).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 2)) || !System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr + 3).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(ref second, intPtr + 3)))
						{
							goto IL_028b;
						}
						intPtr += 4;
					}
					while (length > 0)
					{
						if (System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, intPtr).Equals(System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.Add<T>(ref first, i).CompareTo(System.Runtime.CompilerServices.Unsafe.Add<T>(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 = System.Runtime.CompilerServices.Unsafe.ByteOffset<T>(ref src, ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, srcLength));
			IntPtr intPtr2 = System.Runtime.CompilerServices.Unsafe.ByteOffset<T>(ref dst, ref System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, dstLength));
			IntPtr intPtr3 = System.Runtime.CompilerServices.Unsafe.ByteOffset<T>(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)
			{
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 2) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 2);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 3) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 3);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 4) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 4);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 5) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 5);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 6) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 6);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 7) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 7);
				num3 += num2 * 8;
			}
			if (i < (srcLength & -4))
			{
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 2) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 2);
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3 + num2 * 3) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3 + num2 * 3);
				num3 += num2 * 4;
				i += 4;
			}
			for (; i < srcLength; i++)
			{
				System.Runtime.CompilerServices.Unsafe.Add<T>(ref dst, num3) = System.Runtime.CompilerServices.Unsafe.Add<T>(ref src, num3);
				num3 += num2;
			}
			return;
			IL_006f:
			if (!num && !IsReferenceOrContainsReferences<T>())
			{
				ref byte reference = ref System.Runtime.CompilerServices.Unsafe.As<T, byte>(ref dst);
				ref byte reference2 = ref System.Runtime.CompilerServices.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));
					System.Runtime.CompilerServices.Unsafe.CopyBlock(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, (IntPtr)(long)num5), ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, (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 * System.Runtime.CompilerServices.Unsafe.SizeOf<T>());
				return (IntPtr)((byte*)(void*)start + num);
			}
			ulong num2 = (ulong)index * (ulong)System.Runtime.CompilerServices.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)
			{
				System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned((void*)ptr, (byte)0, (uint)byteLength);
				return;
			}
			ulong num = (ulong)byteLength;
			uint num2 = (uint)(num & 0xFFFFFFFFu);
			System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned((void*)ptr, (byte)0, num2);
			num -= num2;
			ptr += num2;
			while (num != 0)
			{
				num2 = (uint)((num >= uint.MaxValue) ? uint.MaxValue : num);
				System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned((void*)ptr, (byte)0, num2);
				ptr += num2;
				num -= num2;
			}
		}

		public unsafe static void ClearLessThanPointerSized(ref byte b, UIntPtr byteLength)
		{
			if (sizeof(UIntPtr) == 4)
			{
				System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(ref b, (byte)0, (uint)byteLength);
				return;
			}
			ulong num = (ulong)byteLength;
			uint num2 = (uint)(num & 0xFFFFFFFFu);
			System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(ref b, (byte)0, num2);
			num -= num2;
			long num3 = num2;
			while (num != 0)
			{
				num2 = (uint)((num >= uint.MaxValue) ? uint.MaxValue : num);
				System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref b, (IntPtr)num3), (byte)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))
			{
				System.Runtime.CompilerServices.Unsafe.As<byte, Reg64>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref b, zero)) = default(Reg64);
			}
			if (zero.LessThanEqual(byteLength - sizeof(Reg32)))
			{
				System.Runtime.CompilerServices.Unsafe.As<byte, Reg32>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref b, zero)) = default(Reg32);
				zero += sizeof(Reg32);
			}
			if (zero.LessThanEqual(byteLength - sizeof(Reg16)))
			{
				System.Runtime.CompilerServices.Unsafe.As<byte, Reg16>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref b, zero)) = default(Reg16);
				zero += sizeof(Reg16);
			}
			if (zero.LessThanEqual(byteLength - 8))
			{
				System.Runtime.CompilerServices.Unsafe.As<byte, long>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref b, zero)) = 0L;
				zero += 8;
			}
			if (sizeof(IntPtr) == 4 && zero.LessThanEqual(byteLength - 4))
			{
				System.Runtime.CompilerServices.Unsafe.As<byte, int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(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))
			{
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 0) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 1) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 2) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 3) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 4) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 5) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 6) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 7) = default(IntPtr);
				intPtr = zero;
			}
			if ((zero = intPtr + 4).LessThanEqual(pointerSizeLength))
			{
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 0) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 1) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 2) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 3) = default(IntPtr);
				intPtr = zero;
			}
			if ((zero = intPtr + 2).LessThanEqual(pointerSizeLength))
			{
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 0) = default(IntPtr);
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(ref ip, intPtr + 1) = default(IntPtr);
				intPtr = zero;
			}
			if ((intPtr + 1).LessThanEqual(pointerSizeLength))
			{
				System.Runtime.CompilerServices.Unsafe.Add<IntPtr>(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 <075f253c-571b-4ba4-adf1-4b6a86403830>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 <075f253c-571b-4ba4-adf1-4b6a86403830>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.CompilerServices
{
	[AttributeUsage(AttributeTargets.All)]
	internal class __BlockReflectionAttribute : Attribute
	{
	}
}
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 (System.Runtime.CompilerServices.Unsafe.SizeOf<T>() > source.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			return System.Runtime.CompilerServices.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 (System.Runtime.CompilerServices.Unsafe.SizeOf<T>() > (uint)source.Length)
			{
				value = default(T);
				return false;
			}
			value = System.Runtime.CompilerServices.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)System.Runtime.CompilerServices.Unsafe.SizeOf<T>() > (uint)destination.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			System.Runtime.CompilerServices.Unsafe.WriteUnaligned<T>(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 (System.Runtime.CompilerServices.Unsafe.SizeOf<T>() > (uint)destination.Length)
			{
				return false;
			}
			System.Runtime.CompilerServices.Unsafe.WriteUnaligned<T>(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 * System.Runtime.CompilerServices.Unsafe.SizeOf<T>());
			return new Span<byte>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<byte>>((object)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 * System.Runtime.CompilerServices.Unsafe.SizeOf<T>());
			return new ReadOnlySpan<byte>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<byte>>((object)span.Pinnable), span.ByteOffset, length);
		}

		public static Memory<T> AsMemory<T>(ReadOnlyMemory<T> memory)
		{
			return System.Runtime.CompilerServices.Unsafe.As<ReadOnlyMemory<T>, Memory<T>>(ref memory);
		}

		public unsafe static ref T GetReference<T>(Span<T> span)
		{
			if (span.Pinnable == null)
			{
				return ref System.Runtime.CompilerServices.Unsafe.AsRef<T>(span.ByteOffset.ToPointer());
			}
			return ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(ref span.Pinnable.Data, span.ByteOffset);
		}

		public unsafe static ref T GetReference<T>(ReadOnlySpan<T> span)
		{
			if (span.Pinnable == null)
			{
				return ref System.Runtime.CompilerServices.Unsafe.AsRef<T>(span.ByteOffset.ToPointer());
			}
			return ref System.Runtime.CompilerServices.Unsafe.AddByteOffset<T>(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)System.Runtime.CompilerServices.Unsafe.SizeOf<TFrom>())) / System.Runtime.CompilerServices.Unsafe.SizeOf<TTo>());
				return new Span<TTo>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<TTo>>((object)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)System.Runtime.CompilerServices.Unsafe.SizeOf<TFrom>())) / System.Runtime.CompilerServices.Unsafe.SizeOf<TTo>());
				return new ReadOnlySpan<TTo>(System.Runtime.CompilerServices.Unsafe.As<Pinnable<TTo>>((object)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 / System.Runtime.CompilerServices.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>(this in 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(in source, value);
		}

		private static SequencePosition? PositionOfMultiSegment<T>(in 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>(this in 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(in source, destination);
			}
		}

		private static void CopyToMultiSegment<T>(in 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>(this in ReadOnlySequence<T> sequence)
		{
			T[] array = new T[sequence.Length];
			CopyTo(in 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, in value, span);
			}
		}

		private static void WriteMultiSegment<T>(IBufferWriter<T> writer, in 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
	}
	[DebuggerTypeProxy(typeof(ReadOnlySequenceDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	internal readonly 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 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(in _sequenceStart);
			int index2 = GetIndex(in _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(in 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(in start2, in end);
		}

		public ReadOnlySequence<T> Slice(long start, SequencePosition end)
		{
			if (start < 0)
			{
				System.ThrowHelper.ThrowStartOrEndArgumentValidationException(start);
			}
			uint index = (uint)GetIndex(in end);
			object @object = end.GetObject();
			uint index2 = (uint)GetIndex(in _sequenceStart);
			object object2 = _sequenceStart.GetObject();
			uint index3 = (uint)GetIndex(in _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(in start2, in end);
				}
			}
			SequencePosition start3 = new SequencePosition(object2, (int)index2 + (int)start);
			return SliceImpl(in start3, in end);
		}

		public ReadOnlySequence<T> Slice(SequencePosition start, long length)
		{
			uint index = (uint)GetIndex(in start);
			object @object = start.GetObject();
			uint index2 = (uint)GetIndex(in _sequenceStart);
			object object2 = _sequenceStart.GetObject();
			uint index3 = (uint)GetIndex(in _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(in start, in end);
				}
			}
			SequencePosition end2 = new SequencePosition(@object, (int)index + (int)length);
			return SliceImpl(in start, in 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(in start), start.GetObject(), (uint)GetIndex(in end), end.GetObject());
			return SliceImpl(in start, in end);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySequence<T> Slice(SequencePosition start)
		{
			BoundsCheck(in start);
			return SliceImpl(in start, in _sequenceEnd);
		}

		public ReadOnlySequence<T> Slice(long start)
		{
			if (start < 0)
			{
				System.ThrowHelper.ThrowStartOrEndArgumentValidationException(start);
			}
			if (start == 0L)
			{
				return this;
			}
			SequencePosition start2 = Seek(in _sequenceStart, in _sequenceEnd, start, System.ExceptionArgument.start);
			return SliceImpl(in start2, in _sequenceEnd);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				ReadOnlySequence<T> readOnlySequence = this;
				ReadOnlySequence<char> sequence = System.Runtime.CompilerServices.Unsafe.As<ReadOnlySequence<T>, ReadOnlySequence<char>>(ref readOnlySequence);
				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(in sequence));
				}
			}
			return $"System.Buffers.ReadOnlySequence<{typeof(T).Name}>[{Length}]";
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(in 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(in origin, in _sequenceEnd, offset, System.ExceptionArgument.offset);
		}

		public bool TryGet(ref SequencePosition position, out ReadOnlyMemory<T> memory, bool advance = true)
		{
			SequencePosition next;
			bool result = TryGetBuffer(in position, out memory, out next);
			if (advance)
			{
				position = next;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool TryGetBuffer(in 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(in position);
			int index2 = GetIndex(in _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 SequencePosition start, in SequencePosition end, long offset, System.ExceptionArgument argument)
		{
			int index = GetIndex(in start);
			int index2 = GetIndex(in 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 SequencePosition position)
		{
			uint index = (uint)GetIndex(in position);
			uint index2 = (uint)GetIndex(in _sequenceStart);
			uint index3 = (uint)GetIndex(in _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(in _sequenceStart);
			uint index2 = (uint)GetIndex(in _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 SequencePosition position)
		{
			return position.GetInteger() & 0x7FFFFFFF;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ReadOnlySequence<T> SliceImpl(in SequencePosition start, in SequencePosition end)
		{
			return new ReadOnlySequence<T>(start.GetObject(), GetIndex(in start) | (_sequenceStart.GetInteger() & int.MinValue), end.GetObject(), GetIndex(in end) | (_sequenceEnd.GetInteger() & int.MinValue));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private long GetLength()
		{
			int index = GetIndex(in _sequenceStart);
			int index2 = GetIndex(in _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(in _sequenceStart);
			endSegment = (ReadOnlySequenceSegment<T>)_sequenceEnd.GetObject();
			endIndex = GetIndex(in _sequenceEnd);
			return true;
		}

		internal bool TryGetArray(out ArraySegment<T> segment)
		{
			if (GetSequenceType() != SequenceType.Array)
			{
				segment = default(ArraySegment<T>);
				return false;
			}
			int index = GetIndex(in _sequenceStart);
			segment = new ArraySegment<T>((T[])_sequenceStart.GetObject(), index, GetIndex(in _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(in _sequenceStart);
			length = GetIndex(in _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(in 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; }
	}
	internal readonly 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(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.Format(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.Argument_CannotParsePrecision, (byte)99));
					}
					num = num * 10 + num2;
					if (num > 99)
					{
						throw new FormatException(<075f253c-571b-4ba4-adf1-4b6a86403830>SR.Format(<075f253c-571b-4ba4-adf1-4b6a86403830>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 System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2), ref reference3);
						if (num6 >= 0)
						{
							WriteThreeLowOrderBytes(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(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 num7 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num - 4);
							int num8 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num - 3);
							int num9 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num - 2);
							int num10 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num - 1);
							num7 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference3, num7);
							num8 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference3, num8);
							num7 <<= 18;
							num8 <<= 12;
							num7 |= num8;
							if (num10 != 61)
							{
								num9 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference3, num9);
								num10 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference3, num10);
								num9 <<= 6;
								num7 |= num10;
								num7 |= num9;
								if (num7 >= 0)
								{
									if (num3 <= length - 3)
									{
										WriteThreeLowOrderBytes(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, num3), num7);
										num3 += 3;
										goto IL_01eb;
									}
									goto IL_0205;
								}
							}
							else if (num9 != 61)
							{
								num9 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference3, num9);
								num9 <<= 6;
								num7 |= num9;
								if (num7 >= 0)
								{
									if (num3 <= length - 2)
									{
										System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, num3) = (byte)(num7 >> 16);
										System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, num3 + 1) = (byte)(num7 >> 8);
										num3 += 2;
										goto IL_01eb;
									}
									goto IL_0205;
								}
							}
							else if (num7 >= 0)
							{
								if (num3 <= length - 1)
								{
									System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, num3) = (byte)(num7 >> 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 System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num), ref reference2);
					if (num3 >= 0)
					{
						WriteThreeLowOrderBytes(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2), num3);
						num2 += 3;
						num += 4;
						continue;
					}
					goto IL_0172;
				}
				int num4 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, length - 4);
				int num5 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, length - 3);
				int num6 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, length - 2);
				int num7 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, length - 1);
				num4 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference2, num4);
				num5 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference2, num5);
				num4 <<= 18;
				num5 <<= 12;
				num4 |= num5;
				if (num7 != 61)
				{
					num6 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference2, num6);
					num7 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference2, num7);
					num6 <<= 6;
					num4 |= num7;
					num4 |= num6;
					if (num4 >= 0)
					{
						WriteThreeLowOrderBytes(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2), num4);
						num2 += 3;
						goto IL_016d;
					}
				}
				else if (num6 != 61)
				{
					num6 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref reference2, num6);
					num6 <<= 6;
					num4 |= num6;
					if (num4 >= 0)
					{
						System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2) = (byte)(num4 >> 16);
						System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2 + 1) = (byte)(num4 >> 8);
						num2 += 2;
						goto IL_016d;
					}
				}
				else if (num4 >= 0)
				{
					System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2) = (byte)(num4 >> 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 num = encodedBytes;
			int num2 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodedBytes, 1);
			int num3 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodedBytes, 2);
			int num4 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodedBytes, 3);
			num = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref decodingMap, num);
			num2 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref decodingMap, num2);
			num3 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref decodingMap, num3);
			num4 = System.Runtime.CompilerServices.Unsafe.Add<sbyte>(ref decodingMap, num4);
			num <<= 18;
			num2 <<= 12;
			num3 <<= 6;
			num |= num4;
			num2 |= num3;
			return num | num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteThreeLowOrderBytes(ref byte destination, int value)
		{
			destination = (byte)(value >> 16);
			System.Runtime.CompilerServices.Unsafe.Add<byte>(ref destination, 1) = (byte)(value >> 8);
			System.Runtime.CompilerServices.Unsafe.Add<byte>(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 System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, i), ref encodingMap);
				System.Runtime.CompilerServices.Unsafe.WriteUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, num2), num3);
				num2 += 4;
			}
			if (num == length - 2)
			{
				if (isFinalBlock)
				{
					if (i == length - 1)
					{
						num3 = EncodeAndPadTwo(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, i), ref encodingMap);
						System.Runtime.CompilerServices.Unsafe.WriteUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference2, num2), num3);
						num2 += 4;
						i++;
					}
					else if (i == length - 2)
					{
						num3 = EncodeAndPadOne(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, i), ref encodingMap);
						System.Runtime.CompilerServices.Unsafe.WriteUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(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 System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num3), ref encodingMap);
					System.Runtime.CompilerServices.Unsafe.WriteUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2), num4);
					num2 -= 4;
					break;
				default:
					num4 = EncodeAndPadOne(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num3), ref encodingMap);
					System.Runtime.CompilerServices.Unsafe.WriteUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num2), num4);
					num2 -= 4;
					break;
				case 0:
					break;
				}
				for (num3 -= 3; num3 >= 0; num3 -= 3)
				{
					num4 = Encode(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(ref reference, num3), ref encodingMap);
					System.Runtime.CompilerServices.Unsafe.WriteUnaligned<int>(ref System.Runtime.CompilerServices.Unsafe.Add<byte>(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) | (System.Runtime.CompilerServices.Unsafe.Add<byte>(ref threeBytes, 1) << 8) | System.Runtime.CompilerServices.Unsafe.Add<byte>(ref threeBytes, 2);
			int num2 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodingMap, num >> 18);
			int num3 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodingMap, (num >> 12) & 0x3F);
			int num4 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodingMap, (num >> 6) & 0x3F);
			int num5 = System.Runtime.CompilerServices.Unsafe.Add<byte>(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) | (System.Runtime.CompilerServices.Unsafe.Add<byte>(ref twoBytes, 1) << 8);
			int num2 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodingMap, num >> 18);
			int num3 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodingMap, (num >> 12) & 0x3F);
			int num4 = System.Runtime.CompilerServices.Unsafe.Add<byte>(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 = System.Runtime.CompilerServices.Unsafe.Add<byte>(ref encodingMap, num >> 10);
			int num3 = System.Runtime.CompilerServices.Unsafe.Add<byte>(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 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(in 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(in 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(<075f253c-571b-4ba4-adf1-4b6a86403830>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(<075f253c-571b-4ba4-adf1-4b6a86403830>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(in 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(<075f253c-571b-4ba4-adf1-4b6a86403830>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(<075f253c-571b-4ba4-adf1-4b6a86403830>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(in 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 System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.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 System.Runtime.CompilerServices.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);
		}
	}
}
namespace FxResources.System.Numerics.Vectors
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class MathF
	{
		public const float PI = 3.1415927f;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Abs(float x)
		{
			return Math.Abs(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Acos(float x)
		{
			return (float)Math.Acos(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Cos(float x)
		{
			return (float)Math.Cos(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float IEEERemainder(float x, float y)
		{
			return (float)Math.IEEERemainder(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Pow(float x, float y)
		{
			return (float)Math.Pow(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sin(float x)
		{
			return (float)Math.Sin(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sqrt(float x)
		{
			return (float)Math.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Tan(float x)
		{
			return (float)Math.Tan(x);
		}
	}
	internal static class SR
	{
		private static readonly bool s_usingResourceKeys = AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", out var isEnabled) && isEnabled;

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(FxResources.System.Numerics.Vectors.SR)));

		internal static string Arg_ArgumentOutOfRangeException => GetResourceString("Arg_ArgumentOutOfRangeException");

		internal static string Arg_ElementsInSourceIsGreaterThanDestination => GetResourceString("Arg_ElementsInSourceIsGreaterThanDestination");

		internal static string Arg_NullArgumentNullRef => GetResourceString("Arg_NullArgumentNullRef");

		internal static string Arg_TypeNotSupported => GetResourceString("Arg_TypeNotSupported");

		internal static string Arg_InsufficientNumberOfElements => GetResourceString("Arg_InsufficientNumberOfElements");

		private static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		internal static string GetResourceString(string resourceKey)
		{
			if (UsingResourceKeys())
			{
				return resourceKey;
			}
			string result = null;
			try
			{
				result = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		internal static string GetResourceString(string resourceKey, string defaultString)
		{
			string resourceString = GetResourceString(resourceKey);
			if (!(resourceKey == resourceString) && resourceString != null)
			{
				return resourceString;
			}
			return defaultString;
		}

		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.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field, Inherited = false)]
	internal sealed class IntrinsicAttribute : Attribute
	{
	}
}
namespace System.Numerics
{
	internal class ConstantHelper
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte GetByteWithAllBitsSet()
		{
			byte result = 0;
			result = byte.MaxValue;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static sbyte GetSByteWithAllBitsSet()
		{
			sbyte result = 0;
			result = -1;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ushort GetUInt16WithAllBitsSet()
		{
			ushort result = 0;
			result = ushort.MaxValue;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short GetInt16WithAllBitsSet()
		{
			short result = 0;
			result = -1;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint GetUInt32WithAllBitsSet()
		{
			uint result = 0u;
			result = uint.MaxValue;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetInt32WithAllBitsSet()
		{
			int result = 0;
			result = -1;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong GetUInt64WithAllBitsSet()
		{
			ulong result = 0uL;
			result = ulong.MaxValue;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long GetInt64WithAllBitsSet()
		{
			long result = 0L;
			result = -1L;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static float GetSingleWithAllBitsSet()
		{
			float result = 0f;
			*(int*)(&result) = -1;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static double GetDoubleWithAllBitsSet()
		{
			double result = 0.0;
			*(long*)(&result) = -1L;
			return result;
		}
	}
	[StructLayout(LayoutKind.Explicit)]
	internal struct Register
	{
		[FieldOffset(0)]
		internal byte byte_0;

		[FieldOffset(1)]
		internal byte byte_1;

		[FieldOffset(2)]
		internal byte byte_2;

		[FieldOffset(3)]
		internal byte byte_3;

		[FieldOffset(4)]
		internal byte byte_4;

		[FieldOffset(5)]
		internal byte byte_5;

		[FieldOffset(6)]
		internal byte byte_6;

		[FieldOffset(7)]
		internal byte byte_7;

		[FieldOffset(8)]
		internal byte byte_8;

		[FieldOffset(9)]
		internal byte byte_9;

		[FieldOffset(10)]
		internal byte byte_10;

		[FieldOffset(11)]
		internal byte byte_11;

		[FieldOffset(12)]
		internal byte byte_12;

		[FieldOffset(13)]
		internal byte byte_13;

		[FieldOffset(14)]
		internal byte byte_14;

		[FieldOffset(15)]
		internal byte byte_15;

		[FieldOffset(0)]
		internal sbyte sbyte_0;

		[FieldOffset(1)]
		internal sbyte sbyte_1;

		[FieldOffset(2)]
		internal sbyte sbyte_2;

		[FieldOffset(3)]
		internal sbyte sbyte_3;

		[FieldOffset(4)]
		internal sbyte sbyte_4;

		[FieldOffset(5)]
		internal sbyte sbyte_5;

		[FieldOffset(6)]
		internal sbyte sbyte_6;

		[FieldOffset(7)]
		internal sbyte sbyte_7;

		[FieldOffset(8)]
		internal sbyte sbyte_8;

		[FieldOffset(9)]
		internal sbyte sbyte_9;

		[FieldOffset(10)]
		internal sbyte sbyte_10;

		[FieldOffset(11)]
		internal sbyte sbyte_11;

		[FieldOffset(12)]
		internal sbyte sbyte_12;

		[FieldOffset(13)]
		internal sbyte sbyte_13;

		[FieldOffset(14)]
		internal sbyte sbyte_14;

		[FieldOffset(15)]
		internal sbyte sbyte_15;

		[FieldOffset(0)]
		internal ushort uint16_0;

		[FieldOffset(2)]
		internal ushort uint16_1;

		[FieldOffset(4)]
		internal ushort uint16_2;

		[FieldOffset(6)]
		internal ushort uint16_3;

		[FieldOffset(8)]
		internal ushort uint16_4;

		[FieldOffset(10)]
		internal ushort uint16_5;

		[FieldOffset(12)]
		internal ushort uint16_6;

		[FieldOffset(14)]
		internal ushort uint16_7;

		[FieldOffset(0)]
		internal short int16_0;

		[FieldOffset(2)]
		internal short int16_1;

		[FieldOffset(4)]
		internal short int16_2;

		[FieldOffset(6)]
		internal short int16_3;

		[FieldOffset(8)]
		internal short int16_4;

		[FieldOffset(10)]
		internal short int16_5;

		[FieldOffset(12)]
		internal short int16_6;

		[FieldOffset(14)]
		internal short int16_7;

		[FieldOffset(0)]
		internal uint uint32_0;

		[FieldOffset(4)]
		internal uint uint32_1;

		[FieldOffset(8)]
		internal uint uint32_2;

		[FieldOffset(12)]
		internal uint uint32_3;

		[FieldOffset(0)]
		internal int int32_0;

		[FieldOffset(4)]
		internal int int32_1;

		[FieldOffset(8)]
		internal int int32_2;

		[FieldOffset(12)]
		internal int int32_3;

		[FieldOffset(0)]
		internal ulong uint64_0;

		[FieldOffset(8)]
		internal ulong uint64_1;

		[FieldOffset(0)]
		internal long int64_0;

		[FieldOffset(8)]
		internal long int64_1;

		[FieldOffset(0)]
		internal float single_0;

		[FieldOffset(4)]
		internal float single_1;

		[FieldOffset(8)]
		internal float single_2;

		[FieldOffset(12)]
		internal float single_3;

		[FieldOffset(0)]
		internal double double_0;

		[FieldOffset(8)]
		internal double double_1;
	}
	[System.Runtime.CompilerServices.Intrinsic]
	internal struct Vector<T> : IEquatable<Vector<T>>, IFormattable where T : struct
	{
		private struct VectorSizeHelper
		{
			internal Vector<T> _placeholder;

			internal byte _byte;
		}

		private System.Numerics.Register register;

		private static readonly int s_count = InitializeCount();

		private static readonly Vector<T> s_zero = default(Vector<T>);

		private static readonly Vector<T> s_one = new Vector<T>(GetOneValue());

		private static readonly Vector<T> s_allOnes = new Vector<T>(GetAllBitsSetValue());

		public static int Count
		{
			[System.Runtime.CompilerServices.Intrinsic]
			get
			{
				return s_count;
			}
		}

		public static Vector<T> Zero
		{
			[System.Runtime.CompilerServices.Intrinsic]
			get
			{
				return s_zero;
			}
		}

		public static Vector<T> One
		{
			[System.Runtime.CompilerServices.Intrinsic]
			get
			{
				return s_one;
			}
		}

		internal static Vector<T> AllOnes => s_allOnes;

		public unsafe T this[int index]
		{
			[System.Runtime.CompilerServices.Intrinsic]
			get
			{
				if (index >= Count || index < 0)
				{
					throw new IndexOutOfRangeException(System.SR.Format(System.SR.Arg_ArgumentOutOfRangeException, index));
				}
				if (typeof(T) == typeof(byte))
				{
					fixed (byte* ptr = &register.byte_0)
					{
						return (T)(object)ptr[index];
					}
				}
				if (typeof(T) == typeof(sbyte))
				{
					fixed (sbyte* ptr2 = &register.sbyte_0)
					{
						return (T)(object)ptr2[index];
					}
				}
				if (typeof(T) == typeof(ushort))
				{
					fixed (ushort* ptr3 = &register.uint16_0)
					{
						return (T)(object)ptr3[index];
					}
				}
				if (typeof(T) == typeof(short))
				{
					fixed (short* ptr4 = &register.int16_0)
					{
						return (T)(object)ptr4[index];
					}
				}
				if (typeof(T) == typeof(uint))
				{
					fixed (uint* ptr5 = &register.uint32_0)
					{
						return (T)(object)ptr5[index];
					}
				}
				if (typeof(T) == typeof(int))
				{
					fixed (int* ptr6 = &register.int32_0)
					{
						return (T)(object)ptr6[index];
					}
				}
				if (typeof(T) == typeof(ulong))
				{
					fixed (ulong* ptr7 = &register.uint64_0)
					{
						return (T)(object)ptr7[index];
					}
				}
				if (typeof(T) == typeof(long))
				{
					fixed (long* ptr8 = &register.int64_0)
					{
						return (T)(object)ptr8[index];
					}
				}
				if (typeof(T) == typeof(float))
				{
					fixed (float* ptr9 = &register.single_0)
					{
						return (T)(object)ptr9[index];
					}
				}
				if (typeof(T) == typeof(double))
				{
					fixed (double* ptr10 = &register.double_0)
					{
						return (T)(object)ptr10[index];
					}
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
		}

		private unsafe static int InitializeCount()
		{
			VectorSizeHelper vectorSizeHelper = default(VectorSizeHelper);
			byte* ptr = &vectorSizeHelper._placeholder.register.byte_0;
			byte* ptr2 = &vectorSizeHelper._byte;
			int num = (int)(ptr2 - ptr);
			int num2 = -1;
			if (typeof(T) == typeof(byte))
			{
				num2 = 1;
			}
			else if (typeof(T) == typeof(sbyte))
			{
				num2 = 1;
			}
			else if (typeof(T) == typeof(ushort))
			{
				num2 = 2;
			}
			else if (typeof(T) == typeof(short))
			{
				num2 = 2;
			}
			else if (typeof(T) == typeof(uint))
			{
				num2 = 4;
			}
			else if (typeof(T) == typeof(int))
			{
				num2 = 4;
			}
			else if (typeof(T) == typeof(ulong))
			{
				num2 = 8;
			}
			else if (typeof(T) == typeof(long))
			{
				num2 = 8;
			}
			else if (typeof(T) == typeof(float))
			{
				num2 = 4;
			}
			else
			{
				if (!(typeof(T) == typeof(double)))
				{
					throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
				}
				num2 = 8;
			}
			return num / num2;
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe Vector(T value)
		{
			this = default(Vector<T>);
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					fixed (byte* ptr = &register.byte_0)
					{
						for (int i = 0; i < Count; i++)
						{
							ptr[i] = (byte)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(sbyte))
				{
					fixed (sbyte* ptr2 = &register.sbyte_0)
					{
						for (int j = 0; j < Count; j++)
						{
							ptr2[j] = (sbyte)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(ushort))
				{
					fixed (ushort* ptr3 = &register.uint16_0)
					{
						for (int k = 0; k < Count; k++)
						{
							ptr3[k] = (ushort)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(short))
				{
					fixed (short* ptr4 = &register.int16_0)
					{
						for (int l = 0; l < Count; l++)
						{
							ptr4[l] = (short)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(uint))
				{
					fixed (uint* ptr5 = &register.uint32_0)
					{
						for (int m = 0; m < Count; m++)
						{
							ptr5[m] = (uint)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(int))
				{
					fixed (int* ptr6 = &register.int32_0)
					{
						for (int n = 0; n < Count; n++)
						{
							ptr6[n] = (int)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(ulong))
				{
					fixed (ulong* ptr7 = &register.uint64_0)
					{
						for (int num = 0; num < Count; num++)
						{
							ptr7[num] = (ulong)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(long))
				{
					fixed (long* ptr8 = &register.int64_0)
					{
						for (int num2 = 0; num2 < Count; num2++)
						{
							ptr8[num2] = (long)(object)value;
						}
					}
				}
				else if (typeof(T) == typeof(float))
				{
					fixed (float* ptr9 = &register.single_0)
					{
						for (int num3 = 0; num3 < Count; num3++)
						{
							ptr9[num3] = (float)(object)value;
						}
					}
				}
				else
				{
					if (!(typeof(T) == typeof(double)))
					{
						return;
					}
					fixed (double* ptr10 = &register.double_0)
					{
						for (int num4 = 0; num4 < Count; num4++)
						{
							ptr10[num4] = (double)(object)value;
						}
					}
				}
			}
			else if (typeof(T) == typeof(byte))
			{
				register.byte_0 = (byte)(object)value;
				register.byte_1 = (byte)(object)value;
				register.byte_2 = (byte)(object)value;
				register.byte_3 = (byte)(object)value;
				register.byte_4 = (byte)(object)value;
				register.byte_5 = (byte)(object)value;
				register.byte_6 = (byte)(object)value;
				register.byte_7 = (byte)(object)value;
				register.byte_8 = (byte)(object)value;
				register.byte_9 = (byte)(object)value;
				register.byte_10 = (byte)(object)value;
				register.byte_11 = (byte)(object)value;
				register.byte_12 = (byte)(object)value;
				register.byte_13 = (byte)(object)value;
				register.byte_14 = (byte)(object)value;
				register.byte_15 = (byte)(object)value;
			}
			else if (typeof(T) == typeof(sbyte))
			{
				register.sbyte_0 = (sbyte)(object)value;
				register.sbyte_1 = (sbyte)(object)value;
				register.sbyte_2 = (sbyte)(object)value;
				register.sbyte_3 = (sbyte)(object)value;
				register.sbyte_4 = (sbyte)(object)value;
				register.sbyte_5 = (sbyte)(object)value;
				register.sbyte_6 = (sbyte)(object)value;
				register.sbyte_7 = (sbyte)(object)value;
				register.sbyte_8 = (sbyte)(object)value;
				register.sbyte_9 = (sbyte)(object)value;
				register.sbyte_10 = (sbyte)(object)value;
				register.sbyte_11 = (sbyte)(object)value;
				register.sbyte_12 = (sbyte)(object)value;
				register.sbyte_13 = (sbyte)(object)value;
				register.sbyte_14 = (sbyte)(object)value;
				register.sbyte_15 = (sbyte)(object)value;
			}
			else if (typeof(T) == typeof(ushort))
			{
				register.uint16_0 = (ushort)(object)value;
				register.uint16_1 = (ushort)(object)value;
				register.uint16_2 = (ushort)(object)value;
				register.uint16_3 = (ushort)(object)value;
				register.uint16_4 = (ushort)(object)value;
				register.uint16_5 = (ushort)(object)value;
				register.uint16_6 = (ushort)(object)value;
				register.uint16_7 = (ushort)(object)value;
			}
			else if (typeof(T) == typeof(short))
			{
				register.int16_0 = (short)(object)value;
				register.int16_1 = (short)(object)value;
				register.int16_2 = (short)(object)value;
				register.int16_3 = (short)(object)value;
				register.int16_4 = (short)(object)value;
				register.int16_5 = (short)(object)value;
				register.int16_6 = (short)(object)value;
				register.int16_7 = (short)(object)value;
			}
			else if (typeof(T) == typeof(uint))
			{
				register.uint32_0 = (uint)(object)value;
				register.uint32_1 = (uint)(object)value;
				register.uint32_2 = (uint)(object)value;
				register.uint32_3 = (uint)(object)value;
			}
			else if (typeof(T) == typeof(int))
			{
				register.int32_0 = (int)(object)value;
				register.int32_1 = (int)(object)value;
				register.int32_2 = (int)(object)value;
				register.int32_3 = (int)(object)value;
			}
			else if (typeof(T) == typeof(ulong))
			{
				register.uint64_0 = (ulong)(object)value;
				register.uint64_1 = (ulong)(object)value;
			}
			else if (typeof(T) == typeof(long))
			{
				register.int64_0 = (long)(object)value;
				register.int64_1 = (long)(object)value;
			}
			else if (typeof(T) == typeof(float))
			{
				register.single_0 = (float)(object)value;
				register.single_1 = (float)(object)value;
				register.single_2 = (float)(object)value;
				register.single_3 = (float)(object)value;
			}
			else if (typeof(T) == typeof(double))
			{
				register.double_0 = (double)(object)value;
				register.double_1 = (double)(object)value;
			}
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public Vector(T[] values)
			: this(values, 0)
		{
		}

		public unsafe Vector(T[] values, int index)
		{
			this = default(Vector<T>);
			if (values == null)
			{
				throw new NullReferenceException(System.SR.Arg_NullArgumentNullRef);
			}
			if (index < 0 || values.Length - index < Count)
			{
				throw new IndexOutOfRangeException(System.SR.Format(System.SR.Arg_InsufficientNumberOfElements, Count, "values"));
			}
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					fixed (byte* ptr = &register.byte_0)
					{
						for (int i = 0; i < Count; i++)
						{
							ptr[i] = (byte)(object)values[i + index];
						}
					}
				}
				else if (typeof(T) == typeof(sbyte))
				{
					fixed (sbyte* ptr2 = &register.sbyte_0)
					{
						for (int j = 0; j < Count; j++)
						{
							ptr2[j] = (sbyte)(object)values[j + index];
						}
					}
				}
				else if (typeof(T) == typeof(ushort))
				{
					fixed (ushort* ptr3 = &register.uint16_0)
					{
						for (int k = 0; k < Count; k++)
						{
							ptr3[k] = (ushort)(object)values[k + index];
						}
					}
				}
				else if (typeof(T) == typeof(short))
				{
					fixed (short* ptr4 = &register.int16_0)
					{
						for (int l = 0; l < Count; l++)
						{
							ptr4[l] = (short)(object)values[l + index];
						}
					}
				}
				else if (typeof(T) == typeof(uint))
				{
					fixed (uint* ptr5 = &register.uint32_0)
					{
						for (int m = 0; m < Count; m++)
						{
							ptr5[m] = (uint)(object)values[m + index];
						}
					}
				}
				else if (typeof(T) == typeof(int))
				{
					fixed (int* ptr6 = &register.int32_0)
					{
						for (int n = 0; n < Count; n++)
						{
							ptr6[n] = (int)(object)values[n + index];
						}
					}
				}
				else if (typeof(T) == typeof(ulong))
				{
					fixed (ulong* ptr7 = &register.uint64_0)
					{
						for (int num = 0; num < Count; num++)
						{
							ptr7[num] = (ulong)(object)values[num + index];
						}
					}
				}
				else if (typeof(T) == typeof(long))
				{
					fixed (long* ptr8 = &register.int64_0)
					{
						for (int num2 = 0; num2 < Count; num2++)
						{
							ptr8[num2] = (long)(object)values[num2 + index];
						}
					}
				}
				else if (typeof(T) == typeof(float))
				{
					fixed (float* ptr9 = &register.single_0)
					{
						for (int num3 = 0; num3 < Count; num3++)
						{
							ptr9[num3] = (float)(object)values[num3 + index];
						}
					}
				}
				else
				{
					if (!(typeof(T) == typeof(double)))
					{
						return;
					}
					fixed (double* ptr10 = &register.double_0)
					{
						for (int num4 = 0; num4 < Count; num4++)
						{
							ptr10[num4] = (double)(object)values[num4 + index];
						}
					}
				}
			}
			else if (typeof(T) == typeof(byte))
			{
				fixed (byte* ptr11 = &register.byte_0)
				{
					*ptr11 = (byte)(object)values[index];
					ptr11[1] = (byte)(object)values[1 + index];
					ptr11[2] = (byte)(object)values[2 + index];
					ptr11[3] = (byte)(object)values[3 + index];
					ptr11[4] = (byte)(object)values[4 + index];
					ptr11[5] = (byte)(object)values[5 + index];
					ptr11[6] = (byte)(object)values[6 + index];
					ptr11[7] = (byte)(object)values[7 + index];
					ptr11[8] = (byte)(object)values[8 + index];
					ptr11[9] = (byte)(object)values[9 + index];
					ptr11[10] = (byte)(object)values[10 + index];
					ptr11[11] = (byte)(object)values[11 + index];
					ptr11[12] = (byte)(object)values[12 + index];
					ptr11[13] = (byte)(object)values[13 + index];
					ptr11[14] = (byte)(object)values[14 + index];
					ptr11[15] = (byte)(object)values[15 + index];
				}
			}
			else if (typeof(T) == typeof(sbyte))
			{
				fixed (sbyte* ptr12 = &register.sbyte_0)
				{
					*ptr12 = (sbyte)(object)values[index];
					ptr12[1] = (sbyte)(object)values[1 + index];
					ptr12[2] = (sbyte)(object)values[2 + index];
					ptr12[3] = (sbyte)(object)values[3 + index];
					ptr12[4] = (sbyte)(object)values[4 + index];
					ptr12[5] = (sbyte)(object)values[5 + index];
					ptr12[6] = (sbyte)(object)values[6 + index];
					ptr12[7] = (sbyte)(object)values[7 + index];
					ptr12[8] = (sbyte)(object)values[8 + index];
					ptr12[9] = (sbyte)(object)values[9 + index];
					ptr12[10] = (sbyte)(object)values[10 + index];
					ptr12[11] = (sbyte)(object)values[11 + index];
					ptr12[12] = (sbyte)(object)values[12 + index];
					ptr12[13] = (sbyte)(object)values[13 + index];
					ptr12[14] = (sbyte)(object)values[14 + index];
					ptr12[15] = (sbyte)(object)values[15 + index];
				}
			}
			else if (typeof(T) == typeof(ushort))
			{
				fixed (ushort* ptr13 = &register.uint16_0)
				{
					*ptr13 = (ushort)(object)values[index];
					ptr13[1] = (ushort)(object)values[1 + index];
					ptr13[2] = (ushort)(object)values[2 + index];
					ptr13[3] = (ushort)(object)values[3 + index];
					ptr13[4] = (ushort)(object)values[4 + index];
					ptr13[5] = (ushort)(object)values[5 + index];
					ptr13[6] = (ushort)(object)values[6 + index];
					ptr13[7] = (ushort)(object)values[7 + index];
				}
			}
			else if (typeof(T) == typeof(short))
			{
				fixed (short* ptr14 = &register.int16_0)
				{
					*ptr14 = (short)(object)values[index];
					ptr14[1] = (short)(object)values[1 + index];
					ptr14[2] = (short)(object)values[2 + index];
					ptr14[3] = (short)(object)values[3 + index];
					ptr14[4] = (short)(object)values[4 + index];
					ptr14[5] = (short)(object)values[5 + index];
					ptr14[6] = (short)(object)values[6 + index];
					ptr14[7] = (short)(object)values[7 + index];
				}
			}
			else if (typeof(T) == typeof(uint))
			{
				fixed (uint* ptr15 = &register.uint32_0)
				{
					*ptr15 = (uint)(object)values[index];
					ptr15[1] = (uint)(object)values[1 + index];
					ptr15[2] = (uint)(object)values[2 + index];
					ptr15[3] = (uint)(object)values[3 + index];
				}
			}
			else if (typeof(T) == typeof(int))
			{
				fixed (int* ptr16 = &register.int32_0)
				{
					*ptr16 = (int)(object)values[index];
					ptr16[1] = (int)(object)values[1 + index];
					ptr16[2] = (int)(object)values[2 + index];
					ptr16[3] = (int)(object)values[3 + index];
				}
			}
			else if (typeof(T) == typeof(ulong))
			{
				fixed (ulong* ptr17 = &register.uint64_0)
				{
					*ptr17 = (ulong)(object)values[index];
					ptr17[1] = (ulong)(object)values[1 + index];
				}
			}
			else if (typeof(T) == typeof(long))
			{
				fixed (long* ptr18 = &register.int64_0)
				{
					*ptr18 = (long)(object)values[index];
					ptr18[1] = (long)(object)values[1 + index];
				}
			}
			else if (typeof(T) == typeof(float))
			{
				fixed (float* ptr19 = &register.single_0)
				{
					*ptr19 = (float)(object)values[index];
					ptr19[1] = (float)(object)values[1 + index];
					ptr19[2] = (float)(object)values[2 + index];
					ptr19[3] = (float)(object)values[3 + index];
				}
			}
			else if (typeof(T) == typeof(double))
			{
				fixed (double* ptr20 = &register.double_0)
				{
					*ptr20 = (double)(object)values[index];
					ptr20[1] = (double)(object)values[1 + index];
				}
			}
		}

		internal unsafe Vector(void* dataPointer)
			: this(dataPointer, 0)
		{
		}

		internal unsafe Vector(void* dataPointer, int offset)
		{
			this = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				byte* ptr = (byte*)dataPointer;
				ptr += offset;
				fixed (byte* ptr2 = &register.byte_0)
				{
					for (int i = 0; i < Count; i++)
					{
						ptr2[i] = ptr[i];
					}
				}
				return;
			}
			if (typeof(T) == typeof(sbyte))
			{
				sbyte* ptr3 = (sbyte*)dataPointer;
				ptr3 += offset;
				fixed (sbyte* ptr4 = &register.sbyte_0)
				{
					for (int j = 0; j < Count; j++)
					{
						ptr4[j] = ptr3[j];
					}
				}
				return;
			}
			if (typeof(T) == typeof(ushort))
			{
				ushort* ptr5 = (ushort*)dataPointer;
				ptr5 += offset;
				fixed (ushort* ptr6 = &register.uint16_0)
				{
					for (int k = 0; k < Count; k++)
					{
						ptr6[k] = ptr5[k];
					}
				}
				return;
			}
			if (typeof(T) == typeof(short))
			{
				short* ptr7 = (short*)dataPointer;
				ptr7 += offset;
				fixed (short* ptr8 = &register.int16_0)
				{
					for (int l = 0; l < Count; l++)
					{
						ptr8[l] = ptr7[l];
					}
				}
				return;
			}
			if (typeof(T) == typeof(uint))
			{
				uint* ptr9 = (uint*)dataPointer;
				ptr9 += offset;
				fixed (uint* ptr10 = &register.uint32_0)
				{
					for (int m = 0; m < Count; m++)
					{
						ptr10[m] = ptr9[m];
					}
				}
				return;
			}
			if (typeof(T) == typeof(int))
			{
				int* ptr11 = (int*)dataPointer;
				ptr11 += offset;
				fixed (int* ptr12 = &register.int32_0)
				{
					for (int n = 0; n < Count; n++)
					{
						ptr12[n] = ptr11[n];
					}
				}
				return;
			}
			if (typeof(T) == typeof(ulong))
			{
				ulong* ptr13 = (ulong*)dataPointer;
				ptr13 += offset;
				fixed (ulong* ptr14 = &register.uint64_0)
				{
					for (int num = 0; num < Count; num++)
					{
						ptr14[num] = ptr13[num];
					}
				}
				return;
			}
			if (typeof(T) == typeof(long))
			{
				long* ptr15 = (long*)dataPointer;
				ptr15 += offset;
				fixed (long* ptr16 = &register.int64_0)
				{
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr16[num2] = ptr15[num2];
					}
				}
				return;
			}
			if (typeof(T) == typeof(float))
			{
				float* ptr17 = (float*)dataPointer;
				ptr17 += offset;
				fixed (float* ptr18 = &register.single_0)
				{
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr18[num3] = ptr17[num3];
					}
				}
				return;
			}
			if (typeof(T) == typeof(double))
			{
				double* ptr19 = (double*)dataPointer;
				ptr19 += offset;
				fixed (double* ptr20 = &register.double_0)
				{
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr20[num4] = ptr19[num4];
					}
				}
				return;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		private Vector(ref System.Numerics.Register existingRegister)
		{
			register = existingRegister;
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public void CopyTo(T[] destination)
		{
			CopyTo(destination, 0);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe void CopyTo(T[] destination, int startIndex)
		{
			if (destination == null)
			{
				throw new NullReferenceException(System.SR.Arg_NullArgumentNullRef);
			}
			if (startIndex < 0 || startIndex >= destination.Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", System.SR.Format(System.SR.Arg_ArgumentOutOfRangeException, startIndex));
			}
			if (destination.Length - startIndex < Count)
			{
				throw new ArgumentException(System.SR.Format(System.SR.Arg_ElementsInSourceIsGreaterThanDestination, startIndex));
			}
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					fixed (byte* ptr = (byte[])(object)destination)
					{
						for (int i = 0; i < Count; i++)
						{
							ptr[startIndex + i] = (byte)(object)this[i];
						}
					}
				}
				else if (typeof(T) == typeof(sbyte))
				{
					fixed (sbyte* ptr2 = (sbyte[])(object)destination)
					{
						for (int j = 0; j < Count; j++)
						{
							ptr2[startIndex + j] = (sbyte)(object)this[j];
						}
					}
				}
				else if (typeof(T) == typeof(ushort))
				{
					fixed (ushort* ptr3 = (ushort[])(object)destination)
					{
						for (int k = 0; k < Count; k++)
						{
							ptr3[startIndex + k] = (ushort)(object)this[k];
						}
					}
				}
				else if (typeof(T) == typeof(short))
				{
					fixed (short* ptr4 = (short[])(object)destination)
					{
						for (int l = 0; l < Count; l++)
						{
							ptr4[startIndex + l] = (short)(object)this[l];
						}
					}
				}
				else if (typeof(T) == typeof(uint))
				{
					fixed (uint* ptr5 = (uint[])(object)destination)
					{
						for (int m = 0; m < Count; m++)
						{
							ptr5[startIndex + m] = (uint)(object)this[m];
						}
					}
				}
				else if (typeof(T) == typeof(int))
				{
					fixed (int* ptr6 = (int[])(object)destination)
					{
						for (int n = 0; n < Count; n++)
						{
							ptr6[startIndex + n] = (int)(object)this[n];
						}
					}
				}
				else if (typeof(T) == typeof(ulong))
				{
					fixed (ulong* ptr7 = (ulong[])(object)destination)
					{
						for (int num = 0; num < Count; num++)
						{
							ptr7[startIndex + num] = (ulong)(object)this[num];
						}
					}
				}
				else if (typeof(T) == typeof(long))
				{
					fixed (long* ptr8 = (long[])(object)destination)
					{
						for (int num2 = 0; num2 < Count; num2++)
						{
							ptr8[startIndex + num2] = (long)(object)this[num2];
						}
					}
				}
				else if (typeof(T) == typeof(float))
				{
					fixed (float* ptr9 = (float[])(object)destination)
					{
						for (int num3 = 0; num3 < Count; num3++)
						{
							ptr9[startIndex + num3] = (float)(object)this[num3];
						}
					}
				}
				else
				{
					if (!(typeof(T) == typeof(double)))
					{
						return;
					}
					fixed (double* ptr10 = (double[])(object)destination)
					{
						for (int num4 = 0; num4 < Count; num4++)
						{
							ptr10[startIndex + num4] = (double)(object)this[num4];
						}
					}
				}
			}
			else if (typeof(T) == typeof(byte))
			{
				fixed (byte* ptr11 = (byte[])(object)destination)
				{
					ptr11[startIndex] = register.byte_0;
					ptr11[startIndex + 1] = register.byte_1;
					ptr11[startIndex + 2] = register.byte_2;
					ptr11[startIndex + 3] = register.byte_3;
					ptr11[startIndex + 4] = register.byte_4;
					ptr11[startIndex + 5] = register.byte_5;
					ptr11[startIndex + 6] = register.byte_6;
					ptr11[startIndex + 7] = register.byte_7;
					ptr11[startIndex + 8] = register.byte_8;
					ptr11[startIndex + 9] = register.byte_9;
					ptr11[startIndex + 10] = register.byte_10;
					ptr11[startIndex + 11] = register.byte_11;
					ptr11[startIndex + 12] = register.byte_12;
					ptr11[startIndex + 13] = register.byte_13;
					ptr11[startIndex + 14] = register.byte_14;
					ptr11[startIndex + 15] = register.byte_15;
				}
			}
			else if (typeof(T) == typeof(sbyte))
			{
				fixed (sbyte* ptr12 = (sbyte[])(object)destination)
				{
					ptr12[startIndex] = register.sbyte_0;
					ptr12[startIndex + 1] = register.sbyte_1;
					ptr12[startIndex + 2] = register.sbyte_2;
					ptr12[startIndex + 3] = register.sbyte_3;
					ptr12[startIndex + 4] = register.sbyte_4;
					ptr12[startIndex + 5] = register.sbyte_5;
					ptr12[startIndex + 6] = register.sbyte_6;
					ptr12[startIndex + 7] = register.sbyte_7;
					ptr12[startIndex + 8] = register.sbyte_8;
					ptr12[startIndex + 9] = register.sbyte_9;
					ptr12[startIndex + 10] = register.sbyte_10;
					ptr12[startIndex + 11] = register.sbyte_11;
					ptr12[startIndex + 12] = register.sbyte_12;
					ptr12[startIndex + 13] = register.sbyte_13;
					ptr12[startIndex + 14] = register.sbyte_14;
					ptr12[startIndex + 15] = register.sbyte_15;
				}
			}
			else if (typeof(T) == typeof(ushort))
			{
				fixed (ushort* ptr13 = (ushort[])(object)destination)
				{
					ptr13[startIndex] = register.uint16_0;
					ptr13[startIndex + 1] = register.uint16_1;
					ptr13[startIndex + 2] = register.uint16_2;
					ptr13[startIndex + 3] = register.uint16_3;
					ptr13[startIndex + 4] = register.uint16_4;
					ptr13[startIndex + 5] = register.uint16_5;
					ptr13[startIndex + 6] = register.uint16_6;
					ptr13[startIndex + 7] = register.uint16_7;
				}
			}
			else if (typeof(T) == typeof(short))
			{
				fixed (short* ptr14 = (short[])(object)destination)
				{
					ptr14[startIndex] = register.int16_0;
					ptr14[startIndex + 1] = register.int16_1;
					ptr14[startIndex + 2] = register.int16_2;
					ptr14[startIndex + 3] = register.int16_3;
					ptr14[startIndex + 4] = register.int16_4;
					ptr14[startIndex + 5] = register.int16_5;
					ptr14[startIndex + 6] = register.int16_6;
					ptr14[startIndex + 7] = register.int16_7;
				}
			}
			else if (typeof(T) == typeof(uint))
			{
				fixed (uint* ptr15 = (uint[])(object)destination)
				{
					ptr15[startIndex] = register.uint32_0;
					ptr15[startIndex + 1] = register.uint32_1;
					ptr15[startIndex + 2] = register.uint32_2;
					ptr15[startIndex + 3] = register.uint32_3;
				}
			}
			else if (typeof(T) == typeof(int))
			{
				fixed (int* ptr16 = (int[])(object)destination)
				{
					ptr16[startIndex] = register.int32_0;
					ptr16[startIndex + 1] = register.int32_1;
					ptr16[startIndex + 2] = register.int32_2;
					ptr16[startIndex + 3] = register.int32_3;
				}
			}
			else if (typeof(T) == typeof(ulong))
			{
				fixed (ulong* ptr17 = (ulong[])(object)destination)
				{
					ptr17[startIndex] = register.uint64_0;
					ptr17[startIndex + 1] = register.uint64_1;
				}
			}
			else if (typeof(T) == typeof(long))
			{
				fixed (long* ptr18 = (long[])(object)destination)
				{
					ptr18[startIndex] = register.int64_0;
					ptr18[startIndex + 1] = register.int64_1;
				}
			}
			else if (typeof(T) == typeof(float))
			{
				fixed (float* ptr19 = (float[])(object)destination)
				{
					ptr19[startIndex] = register.single_0;
					ptr19[startIndex + 1] = register.single_1;
					ptr19[startIndex + 2] = register.single_2;
					ptr19[startIndex + 3] = register.single_3;
				}
			}
			else if (typeof(T) == typeof(double))
			{
				fixed (double* ptr20 = (double[])(object)destination)
				{
					ptr20[startIndex] = register.double_0;
					ptr20[startIndex + 1] = register.double_1;
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override bool Equals(object obj)
		{
			if (!(obj is Vector<T>))
			{
				return false;
			}
			return Equals((Vector<T>)obj);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public bool Equals(Vector<T> other)
		{
			if (Vector.IsHardwareAccelerated)
			{
				for (int i = 0; i < Count; i++)
				{
					if (!ScalarEquals(this[i], other[i]))
					{
						return false;
					}
				}
				return true;
			}
			if (typeof(T) == typeof(byte))
			{
				if (register.byte_0 == other.register.byte_0 && register.byte_1 == other.register.byte_1 && register.byte_2 == other.register.byte_2 && register.byte_3 == other.register.byte_3 && register.byte_4 == other.register.byte_4 && register.byte_5 == other.register.byte_5 && register.byte_6 == other.register.byte_6 && register.byte_7 == other.register.byte_7 && register.byte_8 == other.register.byte_8 && register.byte_9 == other.register.byte_9 && register.byte_10 == other.register.byte_10 && register.byte_11 == other.register.byte_11 && register.byte_12 == other.register.byte_12 && register.byte_13 == other.register.byte_13 && register.byte_14 == other.register.byte_14)
				{
					return register.byte_15 == other.register.byte_15;
				}
				return false;
			}
			if (typeof(T) == typeof(sbyte))
			{
				if (register.sbyte_0 == other.register.sbyte_0 && register.sbyte_1 == other.register.sbyte_1 && register.sbyte_2 == other.register.sbyte_2 && register.sbyte_3 == other.register.sbyte_3 && register.sbyte_4 == other.register.sbyte_4 && register.sbyte_5 == other.register.sbyte_5 && register.sbyte_6 == other.register.sbyte_6 && register.sbyte_7 == other.register.sbyte_7 && register.sbyte_8 == other.register.sbyte_8 && register.sbyte_9 == other.register.sbyte_9 && register.sbyte_10 == other.register.sbyte_10 && register.sbyte_11 == other.register.sbyte_11 && register.sbyte_12 == other.register.sbyte_12 && register.sbyte_13 == other.register.sbyte_13 && register.sbyte_14 == other.register.sbyte_14)
				{
					return register.sbyte_15 == other.register.sbyte_15;
				}
				return false;
			}
			if (typeof(T) == typeof(ushort))
			{
				if (register.uint16_0 == other.register.uint16_0 && register.uint16_1 == other.register.uint16_1 && register.uint16_2 == other.register.uint16_2 && register.uint16_3 == other.register.uint16_3 && register.uint16_4 == other.register.uint16_4 && register.uint16_5 == other.register.uint16_5 && register.uint16_6 == other.register.uint16_6)
				{
					return register.uint16_7 == other.register.uint16_7;
				}
				return false;
			}
			if (typeof(T) == typeof(short))
			{
				if (register.int16_0 == other.register.int16_0 && register.int16_1 == other.register.int16_1 && register.int16_2 == other.register.int16_2 && register.int16_3 == other.register.int16_3 && register.int16_4 == other.register.int16_4 && register.int16_5 == other.register.int16_5 && register.int16_6 == other.register.int16_6)
				{
					return register.int16_7 == other.register.int16_7;
				}
				return false;
			}
			if (typeof(T) == typeof(uint))
			{
				if (register.uint32_0 == other.register.uint32_0 && register.uint32_1 == other.register.uint32_1 && register.uint32_2 == other.register.uint32_2)
				{
					return register.uint32_3 == other.register.uint32_3;
				}
				return false;
			}
			if (typeof(T) == typeof(int))
			{
				if (register.int32_0 == other.register.int32_0 && register.int32_1 == other.register.int32_1 && register.int32_2 == other.register.int32_2)
				{
					return register.int32_3 == other.register.int32_3;
				}
				return false;
			}
			if (typeof(T) == typeof(ulong))
			{
				if (register.uint64_0 == other.register.uint64_0)
				{
					return register.uint64_1 == other.register.uint64_1;
				}
				return false;
			}
			if (typeof(T) == typeof(long))
			{
				if (register.int64_0 == other.register.int64_0)
				{
					return register.int64_1 == other.register.int64_1;
				}
				return false;
			}
			if (typeof(T) == typeof(float))
			{
				if (register.single_0 == other.register.single_0 && register.single_1 == other.register.single_1 && register.single_2 == other.register.single_2)
				{
					return register.single_3 == other.register.single_3;
				}
				return false;
			}
			if (typeof(T) == typeof(double))
			{
				if (register.double_0 == other.register.double_0)
				{
					return register.double_1 == other.register.double_1;
				}
				return false;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		public override int GetHashCode()
		{
			int num = 0;
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					for (int i = 0; i < Count; i++)
					{
						num = HashHelpers.Combine(num, ((byte)(object)this[i]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(sbyte))
				{
					for (int j = 0; j < Count; j++)
					{
						num = HashHelpers.Combine(num, ((sbyte)(object)this[j]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(ushort))
				{
					for (int k = 0; k < Count; k++)
					{
						num = HashHelpers.Combine(num, ((ushort)(object)this[k]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(short))
				{
					for (int l = 0; l < Count; l++)
					{
						num = HashHelpers.Combine(num, ((short)(object)this[l]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(uint))
				{
					for (int m = 0; m < Count; m++)
					{
						num = HashHelpers.Combine(num, ((uint)(object)this[m]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(int))
				{
					for (int n = 0; n < Count; n++)
					{
						num = HashHelpers.Combine(num, ((int)(object)this[n]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(ulong))
				{
					for (int num2 = 0; num2 < Count; num2++)
					{
						num = HashHelpers.Combine(num, ((ulong)(object)this[num2]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(long))
				{
					for (int num3 = 0; num3 < Count; num3++)
					{
						num = HashHelpers.Combine(num, ((long)(object)this[num3]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(float))
				{
					for (int num4 = 0; num4 < Count; num4++)
					{
						num = HashHelpers.Combine(num, ((float)(object)this[num4]).GetHashCode());
					}
					return num;
				}
				if (typeof(T) == typeof(double))
				{
					for (int num5 = 0; num5 < Count; num5++)
					{
						num = HashHelpers.Combine(num, ((double)(object)this[num5]).GetHashCode());
					}
					return num;
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			if (typeof(T) == typeof(byte))
			{
				num = HashHelpers.Combine(num, register.byte_0.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_1.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_2.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_3.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_4.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_5.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_6.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_7.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_8.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_9.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_10.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_11.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_12.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_13.GetHashCode());
				num = HashHelpers.Combine(num, register.byte_14.GetHashCode());
				return HashHelpers.Combine(num, register.byte_15.GetHashCode());
			}
			if (typeof(T) == typeof(sbyte))
			{
				num = HashHelpers.Combine(num, register.sbyte_0.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_1.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_2.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_3.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_4.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_5.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_6.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_7.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_8.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_9.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_10.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_11.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_12.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_13.GetHashCode());
				num = HashHelpers.Combine(num, register.sbyte_14.GetHashCode());
				return HashHelpers.Combine(num, register.sbyte_15.GetHashCode());
			}
			if (typeof(T) == typeof(ushort))
			{
				num = HashHelpers.Combine(num, register.uint16_0.GetHashCode());
				num = HashHelpers.Combine(num, register.uint16_1.GetHashCode());
				num = HashHelpers.Combine(num, register.uint16_2.GetHashCode());
				num = HashHelpers.Combine(num, register.uint16_3.GetHashCode());
				num = HashHelpers.Combine(num, register.uint16_4.GetHashCode());
				num = HashHelpers.Combine(num, register.uint16_5.GetHashCode());
				num = HashHelpers.Combine(num, register.uint16_6.GetHashCode());
				return HashHelpers.Combine(num, register.uint16_7.GetHashCode());
			}
			if (typeof(T) == typeof(short))
			{
				num = HashHelpers.Combine(num, register.int16_0.GetHashCode());
				num = HashHelpers.Combine(num, register.int16_1.GetHashCode());
				num = HashHelpers.Combine(num, register.int16_2.GetHashCode());
				num = HashHelpers.Combine(num, register.int16_3.GetHashCode());
				num = HashHelpers.Combine(num, register.int16_4.GetHashCode());
				num = HashHelpers.Combine(num, register.int16_5.GetHashCode());
				num = HashHelpers.Combine(num, register.int16_6.GetHashCode());
				return HashHelpers.Combine(num, register.int16_7.GetHashCode());
			}
			if (typeof(T) == typeof(uint))
			{
				num = HashHelpers.Combine(num, register.uint32_0.GetHashCode());
				num = HashHelpers.Combine(num, register.uint32_1.GetHashCode());
				num = HashHelpers.Combine(num, register.uint32_2.GetHashCode());
				return HashHelpers.Combine(num, register.uint32_3.GetHashCode());
			}
			if (typeof(T) == typeof(int))
			{
				num = HashHelpers.Combine(num, register.int32_0.GetHashCode());
				num = HashHelpers.Combine(num, register.int32_1.GetHashCode());
				num = HashHelpers.Combine(num, register.int32_2.GetHashCode());
				return HashHelpers.Combine(num, register.int32_3.GetHashCode());
			}
			if (typeof(T) == typeof(ulong))
			{
				num = HashHelpers.Combine(num, register.uint64_0.GetHashCode());
				return HashHelpers.Combine(num, register.uint64_1.GetHashCode());
			}
			if (typeof(T) == typeof(long))
			{
				num = HashHelpers.Combine(num, register.int64_0.GetHashCode());
				return HashHelpers.Combine(num, register.int64_1.GetHashCode());
			}
			if (typeof(T) == typeof(float))
			{
				num = HashHelpers.Combine(num, register.single_0.GetHashCode());
				num = HashHelpers.Combine(num, register.single_1.GetHashCode());
				num = HashHelpers.Combine(num, register.single_2.GetHashCode());
				return HashHelpers.Combine(num, register.single_3.GetHashCode());
			}
			if (typeof(T) == typeof(double))
			{
				num = HashHelpers.Combine(num, register.double_0.GetHashCode());
				return HashHelpers.Combine(num, register.double_1.GetHashCode());
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		public override string ToString()
		{
			return ToString("G", CultureInfo.CurrentCulture);
		}

		public string ToString(string format)
		{
			return ToString(format, CultureInfo.CurrentCulture);
		}

		public string ToString(string format, IFormatProvider formatProvider)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string numberGroupSeparator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
			stringBuilder.Append('<');
			for (int i = 0; i < Count - 1; i++)
			{
				stringBuilder.Append(((IFormattable)(object)this[i]).ToString(format, formatProvider));
				stringBuilder.Append(numberGroupSeparator);
				stringBuilder.Append(' ');
			}
			stringBuilder.Append(((IFormattable)(object)this[Count - 1]).ToString(format, formatProvider));
			stringBuilder.Append('>');
			return stringBuilder.ToString();
		}

		public unsafe static Vector<T>operator +(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(object)ScalarAdd(left[i], right[i]);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(object)ScalarAdd(left[j], right[j]);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(object)ScalarAdd(left[k], right[k]);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(object)ScalarAdd(left[l], right[l]);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (uint)(object)ScalarAdd(left[m], right[m]);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (int)(object)ScalarAdd(left[n], right[n]);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ulong)(object)ScalarAdd(left[num], right[num]);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (long)(object)ScalarAdd(left[num2], right[num2]);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (float)(object)ScalarAdd(left[num3], right[num3]);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (double)(object)ScalarAdd(left[num4], right[num4]);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = (byte)(left.register.byte_0 + right.register.byte_0);
				result.register.byte_1 = (byte)(left.register.byte_1 + right.register.byte_1);
				result.register.byte_2 = (byte)(left.register.byte_2 + right.register.byte_2);
				result.register.byte_3 = (byte)(left.register.byte_3 + right.register.byte_3);
				result.register.byte_4 = (byte)(left.register.byte_4 + right.register.byte_4);
				result.register.byte_5 = (byte)(left.register.byte_5 + right.register.byte_5);
				result.register.byte_6 = (byte)(left.register.byte_6 + right.register.byte_6);
				result.register.byte_7 = (byte)(left.register.byte_7 + right.register.byte_7);
				result.register.byte_8 = (byte)(left.register.byte_8 + right.register.byte_8);
				result.register.byte_9 = (byte)(left.register.byte_9 + right.register.byte_9);
				result.register.byte_10 = (byte)(left.register.byte_10 + right.register.byte_10);
				result.register.byte_11 = (byte)(left.register.byte_11 + right.register.byte_11);
				result.register.byte_12 = (byte)(left.register.byte_12 + right.register.byte_12);
				result.register.byte_13 = (byte)(left.register.byte_13 + right.register.byte_13);
				result.register.byte_14 = (byte)(left.register.byte_14 + right.register.byte_14);
				result.register.byte_15 = (byte)(left.register.byte_15 + right.register.byte_15);
			}
			else if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = (sbyte)(left.register.sbyte_0 + right.register.sbyte_0);
				result.register.sbyte_1 = (sbyte)(left.register.sbyte_1 + right.register.sbyte_1);
				result.register.sbyte_2 = (sbyte)(left.register.sbyte_2 + right.register.sbyte_2);
				result.register.sbyte_3 = (sbyte)(left.register.sbyte_3 + right.register.sbyte_3);
				result.register.sbyte_4 = (sbyte)(left.register.sbyte_4 + right.register.sbyte_4);
				result.register.sbyte_5 = (sbyte)(left.register.sbyte_5 + right.register.sbyte_5);
				result.register.sbyte_6 = (sbyte)(left.register.sbyte_6 + right.register.sbyte_6);
				result.register.sbyte_7 = (sbyte)(left.register.sbyte_7 + right.register.sbyte_7);
				result.register.sbyte_8 = (sbyte)(left.register.sbyte_8 + right.register.sbyte_8);
				result.register.sbyte_9 = (sbyte)(left.register.sbyte_9 + right.register.sbyte_9);
				result.register.sbyte_10 = (sbyte)(left.register.sbyte_10 + right.register.sbyte_10);
				result.register.sbyte_11 = (sbyte)(left.register.sbyte_11 + right.register.sbyte_11);
				result.register.sbyte_12 = (sbyte)(left.register.sbyte_12 + right.register.sbyte_12);
				result.register.sbyte_13 = (sbyte)(left.register.sbyte_13 + right.register.sbyte_13);
				result.register.sbyte_14 = (sbyte)(left.register.sbyte_14 + right.register.sbyte_14);
				result.register.sbyte_15 = (sbyte)(left.register.sbyte_15 + right.register.sbyte_15);
			}
			else if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = (ushort)(left.register.uint16_0 + right.register.uint16_0);
				result.register.uint16_1 = (ushort)(left.register.uint16_1 + right.register.uint16_1);
				result.register.uint16_2 = (ushort)(left.register.uint16_2 + right.register.uint16_2);
				result.register.uint16_3 = (ushort)(left.register.uint16_3 + right.register.uint16_3);
				result.register.uint16_4 = (ushort)(left.register.uint16_4 + right.register.uint16_4);
				result.register.uint16_5 = (ushort)(left.register.uint16_5 + right.register.uint16_5);
				result.register.uint16_6 = (ushort)(left.register.uint16_6 + right.register.uint16_6);
				result.register.uint16_7 = (ushort)(left.register.uint16_7 + right.register.uint16_7);
			}
			else if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = (short)(left.register.int16_0 + right.register.int16_0);
				result.register.int16_1 = (short)(left.register.int16_1 + right.register.int16_1);
				result.register.int16_2 = (short)(left.register.int16_2 + right.register.int16_2);
				result.register.int16_3 = (short)(left.register.int16_3 + right.register.int16_3);
				result.register.int16_4 = (short)(left.register.int16_4 + right.register.int16_4);
				result.register.int16_5 = (short)(left.register.int16_5 + right.register.int16_5);
				result.register.int16_6 = (short)(left.register.int16_6 + right.register.int16_6);
				result.register.int16_7 = (short)(left.register.int16_7 + right.register.int16_7);
			}
			else if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = left.register.uint32_0 + right.register.uint32_0;
				result.register.uint32_1 = left.register.uint32_1 + right.register.uint32_1;
				result.register.uint32_2 = left.register.uint32_2 + right.register.uint32_2;
				result.register.uint32_3 = left.register.uint32_3 + right.register.uint32_3;
			}
			else if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = left.register.int32_0 + right.register.int32_0;
				result.register.int32_1 = left.register.int32_1 + right.register.int32_1;
				result.register.int32_2 = left.register.int32_2 + right.register.int32_2;
				result.register.int32_3 = left.register.int32_3 + right.register.int32_3;
			}
			else if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = left.register.uint64_0 + right.register.uint64_0;
				result.register.uint64_1 = left.register.uint64_1 + right.register.uint64_1;
			}
			else if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = left.register.int64_0 + right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 + right.register.int64_1;
			}
			else if (typeof(T) == typeof(float))
			{
				result.register.single_0 = left.register.single_0 + right.register.single_0;
				result.register.single_1 = left.register.single_1 + right.register.single_1;
				result.register.single_2 = left.register.single_2 + right.register.single_2;
				result.register.single_3 = left.register.single_3 + right.register.single_3;
			}
			else if (typeof(T) == typeof(double))
			{
				result.register.double_0 = left.register.double_0 + right.register.double_0;
				result.register.double_1 = left.register.double_1 + right.register.double_1;
			}
			return result;
		}

		public unsafe static Vector<T>operator -(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(object)ScalarSubtract(left[i], right[i]);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(object)ScalarSubtract(left[j], right[j]);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(object)ScalarSubtract(left[k], right[k]);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(object)ScalarSubtract(left[l], right[l]);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (uint)(object)ScalarSubtract(left[m], right[m]);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (int)(object)ScalarSubtract(left[n], right[n]);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ulong)(object)ScalarSubtract(left[num], right[num]);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (long)(object)ScalarSubtract(left[num2], right[num2]);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (float)(object)ScalarSubtract(left[num3], right[num3]);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (double)(object)ScalarSubtract(left[num4], right[num4]);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = (byte)(left.register.byte_0 - right.register.byte_0);
				result.register.byte_1 = (byte)(left.register.byte_1 - right.register.byte_1);
				result.register.byte_2 = (byte)(left.register.byte_2 - right.register.byte_2);
				result.register.byte_3 = (byte)(left.register.byte_3 - right.register.byte_3);
				result.register.byte_4 = (byte)(left.register.byte_4 - right.register.byte_4);
				result.register.byte_5 = (byte)(left.register.byte_5 - right.register.byte_5);
				result.register.byte_6 = (byte)(left.register.byte_6 - right.register.byte_6);
				result.register.byte_7 = (byte)(left.register.byte_7 - right.register.byte_7);
				result.register.byte_8 = (byte)(left.register.byte_8 - right.register.byte_8);
				result.register.byte_9 = (byte)(left.register.byte_9 - right.register.byte_9);
				result.register.byte_10 = (byte)(left.register.byte_10 - right.register.byte_10);
				result.register.byte_11 = (byte)(left.register.byte_11 - right.register.byte_11);
				result.register.byte_12 = (byte)(left.register.byte_12 - right.register.byte_12);
				result.register.byte_13 = (byte)(left.register.byte_13 - right.register.byte_13);
				result.register.byte_14 = (byte)(left.register.byte_14 - right.register.byte_14);
				result.register.byte_15 = (byte)(left.register.byte_15 - right.register.byte_15);
			}
			else if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = (sbyte)(left.register.sbyte_0 - right.register.sbyte_0);
				result.register.sbyte_1 = (sbyte)(left.register.sbyte_1 - right.register.sbyte_1);
				result.register.sbyte_2 = (sbyte)(left.register.sbyte_2 - right.register.sbyte_2);
				result.register.sbyte_3 = (sbyte)(left.register.sbyte_3 - right.register.sbyte_3);
				result.register.sbyte_4 = (sbyte)(left.register.sbyte_4 - right.register.sbyte_4);
				result.register.sbyte_5 = (sbyte)(left.register.sbyte_5 - right.register.sbyte_5);
				result.register.sbyte_6 = (sbyte)(left.register.sbyte_6 - right.register.sbyte_6);
				result.register.sbyte_7 = (sbyte)(left.register.sbyte_7 - right.register.sbyte_7);
				result.register.sbyte_8 = (sbyte)(left.register.sbyte_8 - right.register.sbyte_8);
				result.register.sbyte_9 = (sbyte)(left.register.sbyte_9 - right.register.sbyte_9);
				result.register.sbyte_10 = (sbyte)(left.register.sbyte_10 - right.register.sbyte_10);
				result.register.sbyte_11 = (sbyte)(left.register.sbyte_11 - right.register.sbyte_11);
				result.register.sbyte_12 = (sbyte)(left.register.sbyte_12 - right.register.sbyte_12);
				result.register.sbyte_13 = (sbyte)(left.register.sbyte_13 - right.register.sbyte_13);
				result.register.sbyte_14 = (sbyte)(left.register.sbyte_14 - right.register.sbyte_14);
				result.register.sbyte_15 = (sbyte)(left.register.sbyte_15 - right.register.sbyte_15);
			}
			else if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = (ushort)(left.register.uint16_0 - right.register.uint16_0);
				result.register.uint16_1 = (ushort)(left.register.uint16_1 - right.register.uint16_1);
				result.register.uint16_2 = (ushort)(left.register.uint16_2 - right.register.uint16_2);
				result.register.uint16_3 = (ushort)(left.register.uint16_3 - right.register.uint16_3);
				result.register.uint16_4 = (ushort)(left.register.uint16_4 - right.register.uint16_4);
				result.register.uint16_5 = (ushort)(left.register.uint16_5 - right.register.uint16_5);
				result.register.uint16_6 = (ushort)(left.register.uint16_6 - right.register.uint16_6);
				result.register.uint16_7 = (ushort)(left.register.uint16_7 - right.register.uint16_7);
			}
			else if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = (short)(left.register.int16_0 - right.register.int16_0);
				result.register.int16_1 = (short)(left.register.int16_1 - right.register.int16_1);
				result.register.int16_2 = (short)(left.register.int16_2 - right.register.int16_2);
				result.register.int16_3 = (short)(left.register.int16_3 - right.register.int16_3);
				result.register.int16_4 = (short)(left.register.int16_4 - right.register.int16_4);
				result.register.int16_5 = (short)(left.register.int16_5 - right.register.int16_5);
				result.register.int16_6 = (short)(left.register.int16_6 - right.register.int16_6);
				result.register.int16_7 = (short)(left.register.int16_7 - right.register.int16_7);
			}
			else if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = left.register.uint32_0 - right.register.uint32_0;
				result.register.uint32_1 = left.register.uint32_1 - right.register.uint32_1;
				result.register.uint32_2 = left.register.uint32_2 - right.register.uint32_2;
				result.register.uint32_3 = left.register.uint32_3 - right.register.uint32_3;
			}
			else if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = left.register.int32_0 - right.register.int32_0;
				result.register.int32_1 = left.register.int32_1 - right.register.int32_1;
				result.register.int32_2 = left.register.int32_2 - right.register.int32_2;
				result.register.int32_3 = left.register.int32_3 - right.register.int32_3;
			}
			else if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = left.register.uint64_0 - right.register.uint64_0;
				result.register.uint64_1 = left.register.uint64_1 - right.register.uint64_1;
			}
			else if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = left.register.int64_0 - right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 - right.register.int64_1;
			}
			else if (typeof(T) == typeof(float))
			{
				result.register.single_0 = left.register.single_0 - right.register.single_0;
				result.register.single_1 = left.register.single_1 - right.register.single_1;
				result.register.single_2 = left.register.single_2 - right.register.single_2;
				result.register.single_3 = left.register.single_3 - right.register.single_3;
			}
			else if (typeof(T) == typeof(double))
			{
				result.register.double_0 = left.register.double_0 - right.register.double_0;
				result.register.double_1 = left.register.double_1 - right.register.double_1;
			}
			return result;
		}

		public unsafe static Vector<T>operator *(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(object)ScalarMultiply(left[i], right[i]);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(object)ScalarMultiply(left[j], right[j]);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(object)ScalarMultiply(left[k], right[k]);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(object)ScalarMultiply(left[l], right[l]);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (uint)(object)ScalarMultiply(left[m], right[m]);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (int)(object)ScalarMultiply(left[n], right[n]);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ulong)(object)ScalarMultiply(left[num], right[num]);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (long)(object)ScalarMultiply(left[num2], right[num2]);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (float)(object)ScalarMultiply(left[num3], right[num3]);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (double)(object)ScalarMultiply(left[num4], right[num4]);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = (byte)(left.register.byte_0 * right.register.byte_0);
				result.register.byte_1 = (byte)(left.register.byte_1 * right.register.byte_1);
				result.register.byte_2 = (byte)(left.register.byte_2 * right.register.byte_2);
				result.register.byte_3 = (byte)(left.register.byte_3 * right.register.byte_3);
				result.register.byte_4 = (byte)(left.register.byte_4 * right.register.byte_4);
				result.register.byte_5 = (byte)(left.register.byte_5 * right.register.byte_5);
				result.register.byte_6 = (byte)(left.register.byte_6 * right.register.byte_6);
				result.register.byte_7 = (byte)(left.register.byte_7 * right.register.byte_7);
				result.register.byte_8 = (byte)(left.register.byte_8 * right.register.byte_8);
				result.register.byte_9 = (byte)(left.register.byte_9 * right.register.byte_9);
				result.register.byte_10 = (byte)(left.register.byte_10 * right.register.byte_10);
				result.register.byte_11 = (byte)(left.register.byte_11 * right.register.byte_11);
				result.register.byte_12 = (byte)(left.register.byte_12 * right.register.byte_12);
				result.register.byte_13 = (byte)(left.register.byte_13 * right.register.byte_13);
				result.register.byte_14 = (byte)(left.register.byte_14 * right.register.byte_14);
				result.register.byte_15 = (byte)(left.register.byte_15 * right.register.byte_15);
			}
			else if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = (sbyte)(left.register.sbyte_0 * right.register.sbyte_0);
				result.register.sbyte_1 = (sbyte)(left.register.sbyte_1 * right.register.sbyte_1);
				result.register.sbyte_2 = (sbyte)(left.register.sbyte_2 * right.register.sbyte_2);
				result.register.sbyte_3 = (sbyte)(left.register.sbyte_3 * right.register.sbyte_3);
				result.register.sbyte_4 = (sbyte)(left.register.sbyte_4 * right.register.sbyte_4);
				result.register.sbyte_5 = (sbyte)(left.register.sbyte_5 * right.register.sbyte_5);
				result.register.sbyte_6 = (sbyte)(left.register.sbyte_6 * right.register.sbyte_6);
				result.register.sbyte_7 = (sbyte)(left.register.sbyte_7 * right.register.sbyte_7);
				result.register.sbyte_8 = (sbyte)(left.register.sbyte_8 * right.register.sbyte_8);
				result.register.sbyte_9 = (sbyte)(left.register.sbyte_9 * right.register.sbyte_9);
				result.register.sbyte_10 = (sbyte)(left.register.sbyte_10 * right.register.sbyte_10);
				result.register.sbyte_11 = (sbyte)(left.register.sbyte_11 * right.register.sbyte_11);
				result.register.sbyte_12 = (sbyte)(left.register.sbyte_12 * right.register.sbyte_12);
				result.register.sbyte_13 = (sbyte)(left.register.sbyte_13 * right.register.sbyte_13);
				result.register.sbyte_14 = (sbyte)(left.register.sbyte_14 * right.register.sbyte_14);
				result.register.sbyte_15 = (sbyte)(left.register.sbyte_15 * right.register.sbyte_15);
			}
			else if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = (ushort)(left.register.uint16_0 * right.register.uint16_0);
				result.register.uint16_1 = (ushort)(left.register.uint16_1 * right.register.uint16_1);
				result.register.uint16_2 = (ushort)(left.register.uint16_2 * right.register.uint16_2);
				result.register.uint16_3 = (ushort)(left.register.uint16_3 * right.register.uint16_3);
				result.register.uint16_4 = (ushort)(left.register.uint16_4 * right.register.uint16_4);
				result.register.uint16_5 = (ushort)(left.register.uint16_5 * right.register.uint16_5);
				result.register.uint16_6 = (ushort)(left.register.uint16_6 * right.register.uint16_6);
				result.register.uint16_7 = (ushort)(left.register.uint16_7 * right.register.uint16_7);
			}
			else if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = (short)(left.register.int16_0 * right.register.int16_0);
				result.register.int16_1 = (short)(left.register.int16_1 * right.register.int16_1);
				result.register.int16_2 = (short)(left.register.int16_2 * right.register.int16_2);
				result.register.int16_3 = (short)(left.register.int16_3 * right.register.int16_3);
				result.register.int16_4 = (short)(left.register.int16_4 * right.register.int16_4);
				result.register.int16_5 = (short)(left.register.int16_5 * right.register.int16_5);
				result.register.int16_6 = (short)(left.register.int16_6 * right.register.int16_6);
				result.register.int16_7 = (short)(left.register.int16_7 * right.register.int16_7);
			}
			else if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = left.register.uint32_0 * right.register.uint32_0;
				result.register.uint32_1 = left.register.uint32_1 * right.register.uint32_1;
				result.register.uint32_2 = left.register.uint32_2 * right.register.uint32_2;
				result.register.uint32_3 = left.register.uint32_3 * right.register.uint32_3;
			}
			else if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = left.register.int32_0 * right.register.int32_0;
				result.register.int32_1 = left.register.int32_1 * right.register.int32_1;
				result.register.int32_2 = left.register.int32_2 * right.register.int32_2;
				result.register.int32_3 = left.register.int32_3 * right.register.int32_3;
			}
			else if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = left.register.uint64_0 * right.register.uint64_0;
				result.register.uint64_1 = left.register.uint64_1 * right.register.uint64_1;
			}
			else if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = left.register.int64_0 * right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 * right.register.int64_1;
			}
			else if (typeof(T) == typeof(float))
			{
				result.register.single_0 = left.register.single_0 * right.register.single_0;
				result.register.single_1 = left.register.single_1 * right.register.single_1;
				result.register.single_2 = left.register.single_2 * right.register.single_2;
				result.register.single_3 = left.register.single_3 * right.register.single_3;
			}
			else if (typeof(T) == typeof(double))
			{
				result.register.double_0 = left.register.double_0 * right.register.double_0;
				result.register.double_1 = left.register.double_1 * right.register.double_1;
			}
			return result;
		}

		public static Vector<T>operator *(Vector<T> value, T factor)
		{
			if (Vector.IsHardwareAccelerated)
			{
				return new Vector<T>(factor) * value;
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = (byte)(value.register.byte_0 * (byte)(object)factor);
				result.register.byte_1 = (byte)(value.register.byte_1 * (byte)(object)factor);
				result.register.byte_2 = (byte)(value.register.byte_2 * (byte)(object)factor);
				result.register.byte_3 = (byte)(value.register.byte_3 * (byte)(object)factor);
				result.register.byte_4 = (byte)(value.register.byte_4 * (byte)(object)factor);
				result.register.byte_5 = (byte)(value.register.byte_5 * (byte)(object)factor);
				result.register.byte_6 = (byte)(value.register.byte_6 * (byte)(object)factor);
				result.register.byte_7 = (byte)(value.register.byte_7 * (byte)(object)factor);
				result.register.byte_8 = (byte)(value.register.byte_8 * (byte)(object)factor);
				result.register.byte_9 = (byte)(value.register.byte_9 * (byte)(object)factor);
				result.register.byte_10 = (byte)(value.register.byte_10 * (byte)(object)factor);
				result.register.byte_11 = (byte)(value.register.byte_11 * (byte)(object)factor);
				result.register.byte_12 = (byte)(value.register.byte_12 * (byte)(object)factor);
				result.register.byte_13 = (byte)(value.register.byte_13 * (byte)(object)factor);
				result.register.byte_14 = (byte)(value.register.byte_14 * (byte)(object)factor);
				result.register.byte_15 = (byte)(value.register.byte_15 * (byte)(object)factor);
			}
			else if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = (sbyte)(value.register.sbyte_0 * (sbyte)(object)factor);
				result.register.sbyte_1 = (sbyte)(value.register.sbyte_1 * (sbyte)(object)factor);
				result.register.sbyte_2 = (sbyte)(value.register.sbyte_2 * (sbyte)(object)factor);
				result.register.sbyte_3 = (sbyte)(value.register.sbyte_3 * (sbyte)(object)factor);
				result.register.sbyte_4 = (sbyte)(value.register.sbyte_4 * (sbyte)(object)factor);
				result.register.sbyte_5 = (sbyte)(value.register.sbyte_5 * (sbyte)(object)factor);
				result.register.sbyte_6 = (sbyte)(value.register.sbyte_6 * (sbyte)(object)factor);
				result.register.sbyte_7 = (sbyte)(value.register.sbyte_7 * (sbyte)(object)factor);
				result.register.sbyte_8 = (sbyte)(value.register.sbyte_8 * (sbyte)(object)factor);
				result.register.sbyte_9 = (sbyte)(value.register.sbyte_9 * (sbyte)(object)factor);
				result.register.sbyte_10 = (sbyte)(value.register.sbyte_10 * (sbyte)(object)factor);
				result.register.sbyte_11 = (sbyte)(value.register.sbyte_11 * (sbyte)(object)factor);
				result.register.sbyte_12 = (sbyte)(value.register.sbyte_12 * (sbyte)(object)factor);
				result.register.sbyte_13 = (sbyte)(value.register.sbyte_13 * (sbyte)(object)factor);
				result.register.sbyte_14 = (sbyte)(value.register.sbyte_14 * (sbyte)(object)factor);
				result.register.sbyte_15 = (sbyte)(value.register.sbyte_15 * (sbyte)(object)factor);
			}
			else if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = (ushort)(value.register.uint16_0 * (ushort)(object)factor);
				result.register.uint16_1 = (ushort)(value.register.uint16_1 * (ushort)(object)factor);
				result.register.uint16_2 = (ushort)(value.register.uint16_2 * (ushort)(object)factor);
				result.register.uint16_3 = (ushort)(value.register.uint16_3 * (ushort)(object)factor);
				result.register.uint16_4 = (ushort)(value.register.uint16_4 * (ushort)(object)factor);
				result.register.uint16_5 = (ushort)(value.register.uint16_5 * (ushort)(object)factor);
				result.register.uint16_6 = (ushort)(value.register.uint16_6 * (ushort)(object)factor);
				result.register.uint16_7 = (ushort)(value.register.uint16_7 * (ushort)(object)factor);
			}
			else if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = (short)(value.register.int16_0 * (short)(object)factor);
				result.register.int16_1 = (short)(value.register.int16_1 * (short)(object)factor);
				result.register.int16_2 = (short)(value.register.int16_2 * (short)(object)factor);
				result.register.int16_3 = (short)(value.register.int16_3 * (short)(object)factor);
				result.register.int16_4 = (short)(value.register.int16_4 * (short)(object)factor);
				result.register.int16_5 = (short)(value.register.int16_5 * (short)(object)factor);
				result.register.int16_6 = (short)(value.register.int16_6 * (short)(object)factor);
				result.register.int16_7 = (short)(value.register.int16_7 * (short)(object)factor);
			}
			else if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = value.register.uint32_0 * (uint)(object)factor;
				result.register.uint32_1 = value.register.uint32_1 * (uint)(object)factor;
				result.register.uint32_2 = value.register.uint32_2 * (uint)(object)factor;
				result.register.uint32_3 = value.register.uint32_3 * (uint)(object)factor;
			}
			else if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = value.register.int32_0 * (int)(object)factor;
				result.register.int32_1 = value.register.int32_1 * (int)(object)factor;
				result.register.int32_2 = value.register.int32_2 * (int)(object)factor;
				result.register.int32_3 = value.register.int32_3 * (int)(object)factor;
			}
			else if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = value.register.uint64_0 * (ulong)(object)factor;
				result.register.uint64_1 = value.register.uint64_1 * (ulong)(object)factor;
			}
			else if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = value.register.int64_0 * (long)(object)factor;
				result.register.int64_1 = value.register.int64_1 * (long)(object)factor;
			}
			else if (typeof(T) == typeof(float))
			{
				result.register.single_0 = value.register.single_0 * (float)(object)factor;
				result.register.single_1 = value.register.single_1 * (float)(object)factor;
				result.register.single_2 = value.register.single_2 * (float)(object)factor;
				result.register.single_3 = value.register.single_3 * (float)(object)factor;
			}
			else if (typeof(T) == typeof(double))
			{
				result.register.double_0 = value.register.double_0 * (double)(object)factor;
				result.register.double_1 = value.register.double_1 * (double)(object)factor;
			}
			return result;
		}

		public static Vector<T>operator *(T factor, Vector<T> value)
		{
			if (Vector.IsHardwareAccelerated)
			{
				return new Vector<T>(factor) * value;
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = (byte)(value.register.byte_0 * (byte)(object)factor);
				result.register.byte_1 = (byte)(value.register.byte_1 * (byte)(object)factor);
				result.register.byte_2 = (byte)(value.register.byte_2 * (byte)(object)factor);
				result.register.byte_3 = (byte)(value.register.byte_3 * (byte)(object)factor);
				result.register.byte_4 = (byte)(value.register.byte_4 * (byte)(object)factor);
				result.register.byte_5 = (byte)(value.register.byte_5 * (byte)(object)factor);
				result.register.byte_6 = (byte)(value.register.byte_6 * (byte)(object)factor);
				result.register.byte_7 = (byte)(value.register.byte_7 * (byte)(object)factor);
				result.register.byte_8 = (byte)(value.register.byte_8 * (byte)(object)factor);
				result.register.byte_9 = (byte)(value.register.byte_9 * (byte)(object)factor);
				result.register.byte_10 = (byte)(value.register.byte_10 * (byte)(object)factor);
				result.register.byte_11 = (byte)(value.register.byte_11 * (byte)(object)factor);
				result.register.byte_12 = (byte)(value.register.byte_12 * (byte)(object)factor);
				result.register.byte_13 = (byte)(value.register.byte_13 * (byte)(object)factor);
				result.register.byte_14 = (byte)(value.register.byte_14 * (byte)(object)factor);
				result.register.byte_15 = (byte)(value.register.byte_15 * (byte)(object)factor);
			}
			else if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = (sbyte)(value.register.sbyte_0 * (sbyte)(object)factor);
				result.register.sbyte_1 = (sbyte)(value.register.sbyte_1 * (sbyte)(object)factor);
				result.register.sbyte_2 = (sbyte)(value.register.sbyte_2 * (sbyte)(object)factor);
				result.register.sbyte_3 = (sbyte)(value.register.sbyte_3 * (sbyte)(object)factor);
				result.register.sbyte_4 = (sbyte)(value.register.sbyte_4 * (sbyte)(object)factor);
				result.register.sbyte_5 = (sbyte)(value.register.sbyte_5 * (sbyte)(object)factor);
				result.register.sbyte_6 = (sbyte)(value.register.sbyte_6 * (sbyte)(object)factor);
				result.register.sbyte_7 = (sbyte)(value.register.sbyte_7 * (sbyte)(object)factor);
				result.register.sbyte_8 = (sbyte)(value.register.sbyte_8 * (sbyte)(object)factor);
				result.register.sbyte_9 = (sbyte)(value.register.sbyte_9 * (sbyte)(object)factor);
				result.register.sbyte_10 = (sbyte)(value.register.sbyte_10 * (sbyte)(object)factor);
				result.register.sbyte_11 = (sbyte)(value.register.sbyte_11 * (sbyte)(object)factor);
				result.register.sbyte_12 = (sbyte)(value.register.sbyte_12 * (sbyte)(object)factor);
				result.register.sbyte_13 = (sbyte)(value.register.sbyte_13 * (sbyte)(object)factor);
				result.register.sbyte_14 = (sbyte)(value.register.sbyte_14 * (sbyte)(object)factor);
				result.register.sbyte_15 = (sbyte)(value.register.sbyte_15 * (sbyte)(object)factor);
			}
			else if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = (ushort)(value.register.uint16_0 * (ushort)(object)factor);
				result.register.uint16_1 = (ushort)(value.register.uint16_1 * (ushort)(object)factor);
				result.register.uint16_2 = (ushort)(value.register.uint16_2 * (ushort)(object)factor);
				result.register.uint16_3 = (ushort)(value.register.uint16_3 * (ushort)(object)factor);
				result.register.uint16_4 = (ushort)(value.register.uint16_4 * (ushort)(object)factor);
				result.register.uint16_5 = (ushort)(value.register.uint16_5 * (ushort)(object)factor);
				result.register.uint16_6 = (ushort)(value.register.uint16_6 * (ushort)(object)factor);
				result.register.uint16_7 = (ushort)(value.register.uint16_7 * (ushort)(object)factor);
			}
			else if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = (short)(value.register.int16_0 * (short)(object)factor);
				result.register.int16_1 = (short)(value.register.int16_1 * (short)(object)factor);
				result.register.int16_2 = (short)(value.register.int16_2 * (short)(object)factor);
				result.register.int16_3 = (short)(value.register.int16_3 * (short)(object)factor);
				result.register.int16_4 = (short)(value.register.int16_4 * (short)(object)factor);
				result.register.int16_5 = (short)(value.register.int16_5 * (short)(object)factor);
				result.register.int16_6 = (short)(value.register.int16_6 * (short)(object)factor);
				result.register.int16_7 = (short)(value.register.int16_7 * (short)(object)factor);
			}
			else if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = value.register.uint32_0 * (uint)(object)factor;
				result.register.uint32_1 = value.register.uint32_1 * (uint)(object)factor;
				result.register.uint32_2 = value.register.uint32_2 * (uint)(object)factor;
				result.register.uint32_3 = value.register.uint32_3 * (uint)(object)factor;
			}
			else if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = value.register.int32_0 * (int)(object)factor;
				result.register.int32_1 = value.register.int32_1 * (int)(object)factor;
				result.register.int32_2 = value.register.int32_2 * (int)(object)factor;
				result.register.int32_3 = value.register.int32_3 * (int)(object)factor;
			}
			else if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = value.register.uint64_0 * (ulong)(object)factor;
				result.register.uint64_1 = value.register.uint64_1 * (ulong)(object)factor;
			}
			else if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = value.register.int64_0 * (long)(object)factor;
				result.register.int64_1 = value.register.int64_1 * (long)(object)factor;
			}
			else if (typeof(T) == typeof(float))
			{
				result.register.single_0 = value.register.single_0 * (float)(object)factor;
				result.register.single_1 = value.register.single_1 * (float)(object)factor;
				result.register.single_2 = value.register.single_2 * (float)(object)factor;
				result.register.single_3 = value.register.single_3 * (float)(object)factor;
			}
			else if (typeof(T) == typeof(double))
			{
				result.register.double_0 = value.register.double_0 * (double)(object)factor;
				result.register.double_1 = value.register.double_1 * (double)(object)factor;
			}
			return result;
		}

		public unsafe static Vector<T>operator /(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(object)ScalarDivide(left[i], right[i]);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(object)ScalarDivide(left[j], right[j]);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(object)ScalarDivide(left[k], right[k]);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(object)ScalarDivide(left[l], right[l]);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (uint)(object)ScalarDivide(left[m], right[m]);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (int)(object)ScalarDivide(left[n], right[n]);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ulong)(object)ScalarDivide(left[num], right[num]);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (long)(object)ScalarDivide(left[num2], right[num2]);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (float)(object)ScalarDivide(left[num3], right[num3]);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (double)(object)ScalarDivide(left[num4], right[num4]);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = (byte)(left.register.byte_0 / right.register.byte_0);
				result.register.byte_1 = (byte)(left.register.byte_1 / right.register.byte_1);
				result.register.byte_2 = (byte)(left.register.byte_2 / right.register.byte_2);
				result.register.byte_3 = (byte)(left.register.byte_3 / right.register.byte_3);
				result.register.byte_4 = (byte)(left.register.byte_4 / right.register.byte_4);
				result.register.byte_5 = (byte)(left.register.byte_5 / right.register.byte_5);
				result.register.byte_6 = (byte)(left.register.byte_6 / right.register.byte_6);
				result.register.byte_7 = (byte)(left.register.byte_7 / right.register.byte_7);
				result.register.byte_8 = (byte)(left.register.byte_8 / right.register.byte_8);
				result.register.byte_9 = (byte)(left.register.byte_9 / right.register.byte_9);
				result.register.byte_10 = (byte)(left.register.byte_10 / right.register.byte_10);
				result.register.byte_11 = (byte)(left.register.byte_11 / right.register.byte_11);
				result.register.byte_12 = (byte)(left.register.byte_12 / right.register.byte_12);
				result.register.byte_13 = (byte)(left.register.byte_13 / right.register.byte_13);
				result.register.byte_14 = (byte)(left.register.byte_14 / right.register.byte_14);
				result.register.byte_15 = (byte)(left.register.byte_15 / right.register.byte_15);
			}
			else if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = (sbyte)(left.register.sbyte_0 / right.register.sbyte_0);
				result.register.sbyte_1 = (sbyte)(left.register.sbyte_1 / right.register.sbyte_1);
				result.register.sbyte_2 = (sbyte)(left.register.sbyte_2 / right.register.sbyte_2);
				result.register.sbyte_3 = (sbyte)(left.register.sbyte_3 / right.register.sbyte_3);
				result.register.sbyte_4 = (sbyte)(left.register.sbyte_4 / right.register.sbyte_4);
				result.register.sbyte_5 = (sbyte)(left.register.sbyte_5 / right.register.sbyte_5);
				result.register.sbyte_6 = (sbyte)(left.register.sbyte_6 / right.register.sbyte_6);
				result.register.sbyte_7 = (sbyte)(left.register.sbyte_7 / right.register.sbyte_7);
				result.register.sbyte_8 = (sbyte)(left.register.sbyte_8 / right.register.sbyte_8);
				result.register.sbyte_9 = (sbyte)(left.register.sbyte_9 / right.register.sbyte_9);
				result.register.sbyte_10 = (sbyte)(left.register.sbyte_10 / right.register.sbyte_10);
				result.register.sbyte_11 = (sbyte)(left.register.sbyte_11 / right.register.sbyte_11);
				result.register.sbyte_12 = (sbyte)(left.register.sbyte_12 / right.register.sbyte_12);
				result.register.sbyte_13 = (sbyte)(left.register.sbyte_13 / right.register.sbyte_13);
				result.register.sbyte_14 = (sbyte)(left.register.sbyte_14 / right.register.sbyte_14);
				result.register.sbyte_15 = (sbyte)(left.register.sbyte_15 / right.register.sbyte_15);
			}
			else if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = (ushort)(left.register.uint16_0 / right.register.uint16_0);
				result.register.uint16_1 = (ushort)(left.register.uint16_1 / right.register.uint16_1);
				result.register.uint16_2 = (ushort)(left.register.uint16_2 / right.register.uint16_2);
				result.register.uint16_3 = (ushort)(left.register.uint16_3 / right.register.uint16_3);
				result.register.uint16_4 = (ushort)(left.register.uint16_4 / right.register.uint16_4);
				result.register.uint16_5 = (ushort)(left.register.uint16_5 / right.register.uint16_5);
				result.register.uint16_6 = (ushort)(left.register.uint16_6 / right.register.uint16_6);
				result.register.uint16_7 = (ushort)(left.register.uint16_7 / right.register.uint16_7);
			}
			else if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = (short)(left.register.int16_0 / right.register.int16_0);
				result.register.int16_1 = (short)(left.register.int16_1 / right.register.int16_1);
				result.register.int16_2 = (short)(left.register.int16_2 / right.register.int16_2);
				result.register.int16_3 = (short)(left.register.int16_3 / right.register.int16_3);
				result.register.int16_4 = (short)(left.register.int16_4 / right.register.int16_4);
				result.register.int16_5 = (short)(left.register.int16_5 / right.register.int16_5);
				result.register.int16_6 = (short)(left.register.int16_6 / right.register.int16_6);
				result.register.int16_7 = (short)(left.register.int16_7 / right.register.int16_7);
			}
			else if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = left.register.uint32_0 / right.register.uint32_0;
				result.register.uint32_1 = left.register.uint32_1 / right.register.uint32_1;
				result.register.uint32_2 = left.register.uint32_2 / right.register.uint32_2;
				result.register.uint32_3 = left.register.uint32_3 / right.register.uint32_3;
			}
			else if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = left.register.int32_0 / right.register.int32_0;
				result.register.int32_1 = left.register.int32_1 / right.register.int32_1;
				result.register.int32_2 = left.register.int32_2 / right.register.int32_2;
				result.register.int32_3 = left.register.int32_3 / right.register.int32_3;
			}
			else if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = left.register.uint64_0 / right.register.uint64_0;
				result.register.uint64_1 = left.register.uint64_1 / right.register.uint64_1;
			}
			else if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = left.register.int64_0 / right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 / right.register.int64_1;
			}
			else if (typeof(T) == typeof(float))
			{
				result.register.single_0 = left.register.single_0 / right.register.single_0;
				result.register.single_1 = left.register.single_1 / right.register.single_1;
				result.register.single_2 = left.register.single_2 / right.register.single_2;
				result.register.single_3 = left.register.single_3 / right.register.single_3;
			}
			else if (typeof(T) == typeof(double))
			{
				result.register.double_0 = left.register.double_0 / right.register.double_0;
				result.register.double_1 = left.register.double_1 / right.register.double_1;
			}
			return result;
		}

		public static Vector<T>operator -(Vector<T> value)
		{
			return Zero - value;
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<T>operator &(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			if (Vector.IsHardwareAccelerated)
			{
				long* ptr = &result.register.int64_0;
				long* ptr2 = &left.register.int64_0;
				long* ptr3 = &right.register.int64_0;
				for (int i = 0; i < Vector<long>.Count; i++)
				{
					ptr[i] = ptr2[i] & ptr3[i];
				}
			}
			else
			{
				result.register.int64_0 = left.register.int64_0 & right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 & right.register.int64_1;
			}
			return result;
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<T>operator |(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			if (Vector.IsHardwareAccelerated)
			{
				long* ptr = &result.register.int64_0;
				long* ptr2 = &left.register.int64_0;
				long* ptr3 = &right.register.int64_0;
				for (int i = 0; i < Vector<long>.Count; i++)
				{
					ptr[i] = ptr2[i] | ptr3[i];
				}
			}
			else
			{
				result.register.int64_0 = left.register.int64_0 | right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 | right.register.int64_1;
			}
			return result;
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<T>operator ^(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			if (Vector.IsHardwareAccelerated)
			{
				long* ptr = &result.register.int64_0;
				long* ptr2 = &left.register.int64_0;
				long* ptr3 = &right.register.int64_0;
				for (int i = 0; i < Vector<long>.Count; i++)
				{
					ptr[i] = ptr2[i] ^ ptr3[i];
				}
			}
			else
			{
				result.register.int64_0 = left.register.int64_0 ^ right.register.int64_0;
				result.register.int64_1 = left.register.int64_1 ^ right.register.int64_1;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T>operator ~(Vector<T> value)
		{
			return s_allOnes ^ value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(Vector<T> left, Vector<T> right)
		{
			return left.Equals(right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator !=(Vector<T> left, Vector<T> right)
		{
			return !(left == right);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<byte>(Vector<T> value)
		{
			return new Vector<byte>(ref value.register);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<sbyte>(Vector<T> value)
		{
			return new Vector<sbyte>(ref value.register);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<ushort>(Vector<T> value)
		{
			return new Vector<ushort>(ref value.register);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<short>(Vector<T> value)
		{
			return new Vector<short>(ref value.register);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<uint>(Vector<T> value)
		{
			return new Vector<uint>(ref value.register);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<int>(Vector<T> value)
		{
			return new Vector<int>(ref value.register);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<ulong>(Vector<T> value)
		{
			return new Vector<ulong>(ref value.register);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<long>(Vector<T> value)
		{
			return new Vector<long>(ref value.register);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<float>(Vector<T> value)
		{
			return new Vector<float>(ref value.register);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public static explicit operator Vector<double>(Vector<T> value)
		{
			return new Vector<double>(ref value.register);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> Equals(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(ScalarEquals(left[i], right[i]) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(ScalarEquals(left[j], right[j]) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(ScalarEquals(left[k], right[k]) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(ScalarEquals(left[l], right[l]) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (ScalarEquals(left[m], right[m]) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (ScalarEquals(left[n], right[n]) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ScalarEquals(left[num], right[num]) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (ScalarEquals(left[num2], right[num2]) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (ScalarEquals(left[num3], right[num3]) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (ScalarEquals(left[num4], right[num4]) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			System.Numerics.Register existingRegister = default(System.Numerics.Register);
			if (typeof(T) == typeof(byte))
			{
				existingRegister.byte_0 = (byte)((left.register.byte_0 == right.register.byte_0) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_1 = (byte)((left.register.byte_1 == right.register.byte_1) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_2 = (byte)((left.register.byte_2 == right.register.byte_2) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_3 = (byte)((left.register.byte_3 == right.register.byte_3) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_4 = (byte)((left.register.byte_4 == right.register.byte_4) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_5 = (byte)((left.register.byte_5 == right.register.byte_5) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_6 = (byte)((left.register.byte_6 == right.register.byte_6) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_7 = (byte)((left.register.byte_7 == right.register.byte_7) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_8 = (byte)((left.register.byte_8 == right.register.byte_8) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_9 = (byte)((left.register.byte_9 == right.register.byte_9) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_10 = (byte)((left.register.byte_10 == right.register.byte_10) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_11 = (byte)((left.register.byte_11 == right.register.byte_11) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_12 = (byte)((left.register.byte_12 == right.register.byte_12) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_13 = (byte)((left.register.byte_13 == right.register.byte_13) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_14 = (byte)((left.register.byte_14 == right.register.byte_14) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_15 = (byte)((left.register.byte_15 == right.register.byte_15) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(sbyte))
			{
				existingRegister.sbyte_0 = (sbyte)((left.register.sbyte_0 == right.register.sbyte_0) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_1 = (sbyte)((left.register.sbyte_1 == right.register.sbyte_1) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_2 = (sbyte)((left.register.sbyte_2 == right.register.sbyte_2) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_3 = (sbyte)((left.register.sbyte_3 == right.register.sbyte_3) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_4 = (sbyte)((left.register.sbyte_4 == right.register.sbyte_4) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_5 = (sbyte)((left.register.sbyte_5 == right.register.sbyte_5) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_6 = (sbyte)((left.register.sbyte_6 == right.register.sbyte_6) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_7 = (sbyte)((left.register.sbyte_7 == right.register.sbyte_7) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_8 = (sbyte)((left.register.sbyte_8 == right.register.sbyte_8) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_9 = (sbyte)((left.register.sbyte_9 == right.register.sbyte_9) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_10 = (sbyte)((left.register.sbyte_10 == right.register.sbyte_10) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_11 = (sbyte)((left.register.sbyte_11 == right.register.sbyte_11) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_12 = (sbyte)((left.register.sbyte_12 == right.register.sbyte_12) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_13 = (sbyte)((left.register.sbyte_13 == right.register.sbyte_13) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_14 = (sbyte)((left.register.sbyte_14 == right.register.sbyte_14) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_15 = (sbyte)((left.register.sbyte_15 == right.register.sbyte_15) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(ushort))
			{
				existingRegister.uint16_0 = (ushort)((left.register.uint16_0 == right.register.uint16_0) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_1 = (ushort)((left.register.uint16_1 == right.register.uint16_1) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_2 = (ushort)((left.register.uint16_2 == right.register.uint16_2) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_3 = (ushort)((left.register.uint16_3 == right.register.uint16_3) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_4 = (ushort)((left.register.uint16_4 == right.register.uint16_4) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_5 = (ushort)((left.register.uint16_5 == right.register.uint16_5) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_6 = (ushort)((left.register.uint16_6 == right.register.uint16_6) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_7 = (ushort)((left.register.uint16_7 == right.register.uint16_7) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(short))
			{
				existingRegister.int16_0 = (short)((left.register.int16_0 == right.register.int16_0) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_1 = (short)((left.register.int16_1 == right.register.int16_1) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_2 = (short)((left.register.int16_2 == right.register.int16_2) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_3 = (short)((left.register.int16_3 == right.register.int16_3) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_4 = (short)((left.register.int16_4 == right.register.int16_4) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_5 = (short)((left.register.int16_5 == right.register.int16_5) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_6 = (short)((left.register.int16_6 == right.register.int16_6) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_7 = (short)((left.register.int16_7 == right.register.int16_7) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(uint))
			{
				existingRegister.uint32_0 = ((left.register.uint32_0 == right.register.uint32_0) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_1 = ((left.register.uint32_1 == right.register.uint32_1) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_2 = ((left.register.uint32_2 == right.register.uint32_2) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_3 = ((left.register.uint32_3 == right.register.uint32_3) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(int))
			{
				existingRegister.int32_0 = ((left.register.int32_0 == right.register.int32_0) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_1 = ((left.register.int32_1 == right.register.int32_1) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_2 = ((left.register.int32_2 == right.register.int32_2) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_3 = ((left.register.int32_3 == right.register.int32_3) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(ulong))
			{
				existingRegister.uint64_0 = ((left.register.uint64_0 == right.register.uint64_0) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
				existingRegister.uint64_1 = ((left.register.uint64_1 == right.register.uint64_1) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(long))
			{
				existingRegister.int64_0 = ((left.register.int64_0 == right.register.int64_0) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
				existingRegister.int64_1 = ((left.register.int64_1 == right.register.int64_1) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(float))
			{
				existingRegister.single_0 = ((left.register.single_0 == right.register.single_0) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_1 = ((left.register.single_1 == right.register.single_1) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_2 = ((left.register.single_2 == right.register.single_2) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_3 = ((left.register.single_3 == right.register.single_3) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(double))
			{
				existingRegister.double_0 = ((left.register.double_0 == right.register.double_0) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
				existingRegister.double_1 = ((left.register.double_1 == right.register.double_1) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
				return new Vector<T>(ref existingRegister);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> LessThan(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(ScalarLessThan(left[i], right[i]) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(ScalarLessThan(left[j], right[j]) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(ScalarLessThan(left[k], right[k]) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(ScalarLessThan(left[l], right[l]) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (ScalarLessThan(left[m], right[m]) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (ScalarLessThan(left[n], right[n]) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ScalarLessThan(left[num], right[num]) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (ScalarLessThan(left[num2], right[num2]) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (ScalarLessThan(left[num3], right[num3]) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (ScalarLessThan(left[num4], right[num4]) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			System.Numerics.Register existingRegister = default(System.Numerics.Register);
			if (typeof(T) == typeof(byte))
			{
				existingRegister.byte_0 = (byte)((left.register.byte_0 < right.register.byte_0) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_1 = (byte)((left.register.byte_1 < right.register.byte_1) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_2 = (byte)((left.register.byte_2 < right.register.byte_2) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_3 = (byte)((left.register.byte_3 < right.register.byte_3) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_4 = (byte)((left.register.byte_4 < right.register.byte_4) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_5 = (byte)((left.register.byte_5 < right.register.byte_5) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_6 = (byte)((left.register.byte_6 < right.register.byte_6) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_7 = (byte)((left.register.byte_7 < right.register.byte_7) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_8 = (byte)((left.register.byte_8 < right.register.byte_8) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_9 = (byte)((left.register.byte_9 < right.register.byte_9) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_10 = (byte)((left.register.byte_10 < right.register.byte_10) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_11 = (byte)((left.register.byte_11 < right.register.byte_11) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_12 = (byte)((left.register.byte_12 < right.register.byte_12) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_13 = (byte)((left.register.byte_13 < right.register.byte_13) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_14 = (byte)((left.register.byte_14 < right.register.byte_14) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_15 = (byte)((left.register.byte_15 < right.register.byte_15) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(sbyte))
			{
				existingRegister.sbyte_0 = (sbyte)((left.register.sbyte_0 < right.register.sbyte_0) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_1 = (sbyte)((left.register.sbyte_1 < right.register.sbyte_1) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_2 = (sbyte)((left.register.sbyte_2 < right.register.sbyte_2) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_3 = (sbyte)((left.register.sbyte_3 < right.register.sbyte_3) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_4 = (sbyte)((left.register.sbyte_4 < right.register.sbyte_4) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_5 = (sbyte)((left.register.sbyte_5 < right.register.sbyte_5) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_6 = (sbyte)((left.register.sbyte_6 < right.register.sbyte_6) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_7 = (sbyte)((left.register.sbyte_7 < right.register.sbyte_7) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_8 = (sbyte)((left.register.sbyte_8 < right.register.sbyte_8) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_9 = (sbyte)((left.register.sbyte_9 < right.register.sbyte_9) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_10 = (sbyte)((left.register.sbyte_10 < right.register.sbyte_10) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_11 = (sbyte)((left.register.sbyte_11 < right.register.sbyte_11) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_12 = (sbyte)((left.register.sbyte_12 < right.register.sbyte_12) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_13 = (sbyte)((left.register.sbyte_13 < right.register.sbyte_13) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_14 = (sbyte)((left.register.sbyte_14 < right.register.sbyte_14) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_15 = (sbyte)((left.register.sbyte_15 < right.register.sbyte_15) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(ushort))
			{
				existingRegister.uint16_0 = (ushort)((left.register.uint16_0 < right.register.uint16_0) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_1 = (ushort)((left.register.uint16_1 < right.register.uint16_1) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_2 = (ushort)((left.register.uint16_2 < right.register.uint16_2) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_3 = (ushort)((left.register.uint16_3 < right.register.uint16_3) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_4 = (ushort)((left.register.uint16_4 < right.register.uint16_4) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_5 = (ushort)((left.register.uint16_5 < right.register.uint16_5) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_6 = (ushort)((left.register.uint16_6 < right.register.uint16_6) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_7 = (ushort)((left.register.uint16_7 < right.register.uint16_7) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(short))
			{
				existingRegister.int16_0 = (short)((left.register.int16_0 < right.register.int16_0) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_1 = (short)((left.register.int16_1 < right.register.int16_1) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_2 = (short)((left.register.int16_2 < right.register.int16_2) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_3 = (short)((left.register.int16_3 < right.register.int16_3) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_4 = (short)((left.register.int16_4 < right.register.int16_4) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_5 = (short)((left.register.int16_5 < right.register.int16_5) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_6 = (short)((left.register.int16_6 < right.register.int16_6) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_7 = (short)((left.register.int16_7 < right.register.int16_7) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(uint))
			{
				existingRegister.uint32_0 = ((left.register.uint32_0 < right.register.uint32_0) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_1 = ((left.register.uint32_1 < right.register.uint32_1) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_2 = ((left.register.uint32_2 < right.register.uint32_2) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_3 = ((left.register.uint32_3 < right.register.uint32_3) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(int))
			{
				existingRegister.int32_0 = ((left.register.int32_0 < right.register.int32_0) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_1 = ((left.register.int32_1 < right.register.int32_1) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_2 = ((left.register.int32_2 < right.register.int32_2) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_3 = ((left.register.int32_3 < right.register.int32_3) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(ulong))
			{
				existingRegister.uint64_0 = ((left.register.uint64_0 < right.register.uint64_0) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
				existingRegister.uint64_1 = ((left.register.uint64_1 < right.register.uint64_1) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(long))
			{
				existingRegister.int64_0 = ((left.register.int64_0 < right.register.int64_0) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
				existingRegister.int64_1 = ((left.register.int64_1 < right.register.int64_1) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(float))
			{
				existingRegister.single_0 = ((left.register.single_0 < right.register.single_0) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_1 = ((left.register.single_1 < right.register.single_1) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_2 = ((left.register.single_2 < right.register.single_2) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_3 = ((left.register.single_3 < right.register.single_3) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(double))
			{
				existingRegister.double_0 = ((left.register.double_0 < right.register.double_0) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
				existingRegister.double_1 = ((left.register.double_1 < right.register.double_1) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
				return new Vector<T>(ref existingRegister);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> GreaterThan(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)(ScalarGreaterThan(left[i], right[i]) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)(ScalarGreaterThan(left[j], right[j]) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)(ScalarGreaterThan(left[k], right[k]) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)(ScalarGreaterThan(left[l], right[l]) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (ScalarGreaterThan(left[m], right[m]) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (ScalarGreaterThan(left[n], right[n]) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ScalarGreaterThan(left[num], right[num]) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (ScalarGreaterThan(left[num2], right[num2]) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (ScalarGreaterThan(left[num3], right[num3]) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (ScalarGreaterThan(left[num4], right[num4]) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			System.Numerics.Register existingRegister = default(System.Numerics.Register);
			if (typeof(T) == typeof(byte))
			{
				existingRegister.byte_0 = (byte)((left.register.byte_0 > right.register.byte_0) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_1 = (byte)((left.register.byte_1 > right.register.byte_1) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_2 = (byte)((left.register.byte_2 > right.register.byte_2) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_3 = (byte)((left.register.byte_3 > right.register.byte_3) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_4 = (byte)((left.register.byte_4 > right.register.byte_4) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_5 = (byte)((left.register.byte_5 > right.register.byte_5) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_6 = (byte)((left.register.byte_6 > right.register.byte_6) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_7 = (byte)((left.register.byte_7 > right.register.byte_7) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_8 = (byte)((left.register.byte_8 > right.register.byte_8) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_9 = (byte)((left.register.byte_9 > right.register.byte_9) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_10 = (byte)((left.register.byte_10 > right.register.byte_10) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_11 = (byte)((left.register.byte_11 > right.register.byte_11) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_12 = (byte)((left.register.byte_12 > right.register.byte_12) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_13 = (byte)((left.register.byte_13 > right.register.byte_13) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_14 = (byte)((left.register.byte_14 > right.register.byte_14) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				existingRegister.byte_15 = (byte)((left.register.byte_15 > right.register.byte_15) ? ConstantHelper.GetByteWithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(sbyte))
			{
				existingRegister.sbyte_0 = (sbyte)((left.register.sbyte_0 > right.register.sbyte_0) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_1 = (sbyte)((left.register.sbyte_1 > right.register.sbyte_1) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_2 = (sbyte)((left.register.sbyte_2 > right.register.sbyte_2) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_3 = (sbyte)((left.register.sbyte_3 > right.register.sbyte_3) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_4 = (sbyte)((left.register.sbyte_4 > right.register.sbyte_4) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_5 = (sbyte)((left.register.sbyte_5 > right.register.sbyte_5) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_6 = (sbyte)((left.register.sbyte_6 > right.register.sbyte_6) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_7 = (sbyte)((left.register.sbyte_7 > right.register.sbyte_7) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_8 = (sbyte)((left.register.sbyte_8 > right.register.sbyte_8) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_9 = (sbyte)((left.register.sbyte_9 > right.register.sbyte_9) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_10 = (sbyte)((left.register.sbyte_10 > right.register.sbyte_10) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_11 = (sbyte)((left.register.sbyte_11 > right.register.sbyte_11) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_12 = (sbyte)((left.register.sbyte_12 > right.register.sbyte_12) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_13 = (sbyte)((left.register.sbyte_13 > right.register.sbyte_13) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_14 = (sbyte)((left.register.sbyte_14 > right.register.sbyte_14) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				existingRegister.sbyte_15 = (sbyte)((left.register.sbyte_15 > right.register.sbyte_15) ? ConstantHelper.GetSByteWithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(ushort))
			{
				existingRegister.uint16_0 = (ushort)((left.register.uint16_0 > right.register.uint16_0) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_1 = (ushort)((left.register.uint16_1 > right.register.uint16_1) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_2 = (ushort)((left.register.uint16_2 > right.register.uint16_2) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_3 = (ushort)((left.register.uint16_3 > right.register.uint16_3) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_4 = (ushort)((left.register.uint16_4 > right.register.uint16_4) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_5 = (ushort)((left.register.uint16_5 > right.register.uint16_5) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_6 = (ushort)((left.register.uint16_6 > right.register.uint16_6) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				existingRegister.uint16_7 = (ushort)((left.register.uint16_7 > right.register.uint16_7) ? ConstantHelper.GetUInt16WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(short))
			{
				existingRegister.int16_0 = (short)((left.register.int16_0 > right.register.int16_0) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_1 = (short)((left.register.int16_1 > right.register.int16_1) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_2 = (short)((left.register.int16_2 > right.register.int16_2) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_3 = (short)((left.register.int16_3 > right.register.int16_3) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_4 = (short)((left.register.int16_4 > right.register.int16_4) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_5 = (short)((left.register.int16_5 > right.register.int16_5) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_6 = (short)((left.register.int16_6 > right.register.int16_6) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				existingRegister.int16_7 = (short)((left.register.int16_7 > right.register.int16_7) ? ConstantHelper.GetInt16WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(uint))
			{
				existingRegister.uint32_0 = ((left.register.uint32_0 > right.register.uint32_0) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_1 = ((left.register.uint32_1 > right.register.uint32_1) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_2 = ((left.register.uint32_2 > right.register.uint32_2) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				existingRegister.uint32_3 = ((left.register.uint32_3 > right.register.uint32_3) ? ConstantHelper.GetUInt32WithAllBitsSet() : 0u);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(int))
			{
				existingRegister.int32_0 = ((left.register.int32_0 > right.register.int32_0) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_1 = ((left.register.int32_1 > right.register.int32_1) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_2 = ((left.register.int32_2 > right.register.int32_2) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				existingRegister.int32_3 = ((left.register.int32_3 > right.register.int32_3) ? ConstantHelper.GetInt32WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(ulong))
			{
				existingRegister.uint64_0 = ((left.register.uint64_0 > right.register.uint64_0) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
				existingRegister.uint64_1 = ((left.register.uint64_1 > right.register.uint64_1) ? ConstantHelper.GetUInt64WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(long))
			{
				existingRegister.int64_0 = ((left.register.int64_0 > right.register.int64_0) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
				existingRegister.int64_1 = ((left.register.int64_1 > right.register.int64_1) ? ConstantHelper.GetInt64WithAllBitsSet() : 0);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(float))
			{
				existingRegister.single_0 = ((left.register.single_0 > right.register.single_0) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_1 = ((left.register.single_1 > right.register.single_1) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_2 = ((left.register.single_2 > right.register.single_2) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				existingRegister.single_3 = ((left.register.single_3 > right.register.single_3) ? ConstantHelper.GetSingleWithAllBitsSet() : 0f);
				return new Vector<T>(ref existingRegister);
			}
			if (typeof(T) == typeof(double))
			{
				existingRegister.double_0 = ((left.register.double_0 > right.register.double_0) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
				existingRegister.double_1 = ((left.register.double_1 > right.register.double_1) ? ConstantHelper.GetDoubleWithAllBitsSet() : 0.0);
				return new Vector<T>(ref existingRegister);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal static Vector<T> GreaterThanOrEqual(Vector<T> left, Vector<T> right)
		{
			return Equals(left, right) | GreaterThan(left, right);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal static Vector<T> LessThanOrEqual(Vector<T> left, Vector<T> right)
		{
			return Equals(left, right) | LessThan(left, right);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal static Vector<T> ConditionalSelect(Vector<T> condition, Vector<T> left, Vector<T> right)
		{
			return (left & condition) | Vector.AndNot(right, condition);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> Abs(Vector<T> value)
		{
			if (typeof(T) == typeof(byte))
			{
				return value;
			}
			if (typeof(T) == typeof(ushort))
			{
				return value;
			}
			if (typeof(T) == typeof(uint))
			{
				return value;
			}
			if (typeof(T) == typeof(ulong))
			{
				return value;
			}
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr = stackalloc sbyte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (sbyte)(object)Math.Abs((sbyte)(object)value[i]);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr2 = stackalloc short[Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (short)(object)Math.Abs((short)(object)value[j]);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr3 = stackalloc int[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (int)(object)Math.Abs((int)(object)value[k]);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr4 = stackalloc long[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (long)(object)Math.Abs((long)(object)value[l]);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr5 = stackalloc float[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (float)(object)Math.Abs((float)(object)value[m]);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr6 = stackalloc double[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (double)(object)Math.Abs((double)(object)value[n]);
					}
					return new Vector<T>(ptr6);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			if (typeof(T) == typeof(sbyte))
			{
				value.register.sbyte_0 = Math.Abs(value.register.sbyte_0);
				value.register.sbyte_1 = Math.Abs(value.register.sbyte_1);
				value.register.sbyte_2 = Math.Abs(value.register.sbyte_2);
				value.register.sbyte_3 = Math.Abs(value.register.sbyte_3);
				value.register.sbyte_4 = Math.Abs(value.register.sbyte_4);
				value.register.sbyte_5 = Math.Abs(value.register.sbyte_5);
				value.register.sbyte_6 = Math.Abs(value.register.sbyte_6);
				value.register.sbyte_7 = Math.Abs(value.register.sbyte_7);
				value.register.sbyte_8 = Math.Abs(value.register.sbyte_8);
				value.register.sbyte_9 = Math.Abs(value.register.sbyte_9);
				value.register.sbyte_10 = Math.Abs(value.register.sbyte_10);
				value.register.sbyte_11 = Math.Abs(value.register.sbyte_11);
				value.register.sbyte_12 = Math.Abs(value.register.sbyte_12);
				value.register.sbyte_13 = Math.Abs(value.register.sbyte_13);
				value.register.sbyte_14 = Math.Abs(value.register.sbyte_14);
				value.register.sbyte_15 = Math.Abs(value.register.sbyte_15);
				return value;
			}
			if (typeof(T) == typeof(short))
			{
				value.register.int16_0 = Math.Abs(value.register.int16_0);
				value.register.int16_1 = Math.Abs(value.register.int16_1);
				value.register.int16_2 = Math.Abs(value.register.int16_2);
				value.register.int16_3 = Math.Abs(value.register.int16_3);
				value.register.int16_4 = Math.Abs(value.register.int16_4);
				value.register.int16_5 = Math.Abs(value.register.int16_5);
				value.register.int16_6 = Math.Abs(value.register.int16_6);
				value.register.int16_7 = Math.Abs(value.register.int16_7);
				return value;
			}
			if (typeof(T) == typeof(int))
			{
				value.register.int32_0 = Math.Abs(value.register.int32_0);
				value.register.int32_1 = Math.Abs(value.register.int32_1);
				value.register.int32_2 = Math.Abs(value.register.int32_2);
				value.register.int32_3 = Math.Abs(value.register.int32_3);
				return value;
			}
			if (typeof(T) == typeof(long))
			{
				value.register.int64_0 = Math.Abs(value.register.int64_0);
				value.register.int64_1 = Math.Abs(value.register.int64_1);
				return value;
			}
			if (typeof(T) == typeof(float))
			{
				value.register.single_0 = Math.Abs(value.register.single_0);
				value.register.single_1 = Math.Abs(value.register.single_1);
				value.register.single_2 = Math.Abs(value.register.single_2);
				value.register.single_3 = Math.Abs(value.register.single_3);
				return value;
			}
			if (typeof(T) == typeof(double))
			{
				value.register.double_0 = Math.Abs(value.register.double_0);
				value.register.double_1 = Math.Abs(value.register.double_1);
				return value;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> Min(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (ScalarLessThan(left[i], right[i]) ? ((byte)(object)left[i]) : ((byte)(object)right[i]));
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (ScalarLessThan(left[j], right[j]) ? ((sbyte)(object)left[j]) : ((sbyte)(object)right[j]));
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ScalarLessThan(left[k], right[k]) ? ((ushort)(object)left[k]) : ((ushort)(object)right[k]));
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (ScalarLessThan(left[l], right[l]) ? ((short)(object)left[l]) : ((short)(object)right[l]));
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (ScalarLessThan(left[m], right[m]) ? ((uint)(object)left[m]) : ((uint)(object)right[m]));
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (ScalarLessThan(left[n], right[n]) ? ((int)(object)left[n]) : ((int)(object)right[n]));
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ScalarLessThan(left[num], right[num]) ? ((ulong)(object)left[num]) : ((ulong)(object)right[num]));
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (ScalarLessThan(left[num2], right[num2]) ? ((long)(object)left[num2]) : ((long)(object)right[num2]));
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (ScalarLessThan(left[num3], right[num3]) ? ((float)(object)left[num3]) : ((float)(object)right[num3]));
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (ScalarLessThan(left[num4], right[num4]) ? ((double)(object)left[num4]) : ((double)(object)right[num4]));
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = ((left.register.byte_0 < right.register.byte_0) ? left.register.byte_0 : right.register.byte_0);
				result.register.byte_1 = ((left.register.byte_1 < right.register.byte_1) ? left.register.byte_1 : right.register.byte_1);
				result.register.byte_2 = ((left.register.byte_2 < right.register.byte_2) ? left.register.byte_2 : right.register.byte_2);
				result.register.byte_3 = ((left.register.byte_3 < right.register.byte_3) ? left.register.byte_3 : right.register.byte_3);
				result.register.byte_4 = ((left.register.byte_4 < right.register.byte_4) ? left.register.byte_4 : right.register.byte_4);
				result.register.byte_5 = ((left.register.byte_5 < right.register.byte_5) ? left.register.byte_5 : right.register.byte_5);
				result.register.byte_6 = ((left.register.byte_6 < right.register.byte_6) ? left.register.byte_6 : right.register.byte_6);
				result.register.byte_7 = ((left.register.byte_7 < right.register.byte_7) ? left.register.byte_7 : right.register.byte_7);
				result.register.byte_8 = ((left.register.byte_8 < right.register.byte_8) ? left.register.byte_8 : right.register.byte_8);
				result.register.byte_9 = ((left.register.byte_9 < right.register.byte_9) ? left.register.byte_9 : right.register.byte_9);
				result.register.byte_10 = ((left.register.byte_10 < right.register.byte_10) ? left.register.byte_10 : right.register.byte_10);
				result.register.byte_11 = ((left.register.byte_11 < right.register.byte_11) ? left.register.byte_11 : right.register.byte_11);
				result.register.byte_12 = ((left.register.byte_12 < right.register.byte_12) ? left.register.byte_12 : right.register.byte_12);
				result.register.byte_13 = ((left.register.byte_13 < right.register.byte_13) ? left.register.byte_13 : right.register.byte_13);
				result.register.byte_14 = ((left.register.byte_14 < right.register.byte_14) ? left.register.byte_14 : right.register.byte_14);
				result.register.byte_15 = ((left.register.byte_15 < right.register.byte_15) ? left.register.byte_15 : right.register.byte_15);
				return result;
			}
			if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = ((left.register.sbyte_0 < right.register.sbyte_0) ? left.register.sbyte_0 : right.register.sbyte_0);
				result.register.sbyte_1 = ((left.register.sbyte_1 < right.register.sbyte_1) ? left.register.sbyte_1 : right.register.sbyte_1);
				result.register.sbyte_2 = ((left.register.sbyte_2 < right.register.sbyte_2) ? left.register.sbyte_2 : right.register.sbyte_2);
				result.register.sbyte_3 = ((left.register.sbyte_3 < right.register.sbyte_3) ? left.register.sbyte_3 : right.register.sbyte_3);
				result.register.sbyte_4 = ((left.register.sbyte_4 < right.register.sbyte_4) ? left.register.sbyte_4 : right.register.sbyte_4);
				result.register.sbyte_5 = ((left.register.sbyte_5 < right.register.sbyte_5) ? left.register.sbyte_5 : right.register.sbyte_5);
				result.register.sbyte_6 = ((left.register.sbyte_6 < right.register.sbyte_6) ? left.register.sbyte_6 : right.register.sbyte_6);
				result.register.sbyte_7 = ((left.register.sbyte_7 < right.register.sbyte_7) ? left.register.sbyte_7 : right.register.sbyte_7);
				result.register.sbyte_8 = ((left.register.sbyte_8 < right.register.sbyte_8) ? left.register.sbyte_8 : right.register.sbyte_8);
				result.register.sbyte_9 = ((left.register.sbyte_9 < right.register.sbyte_9) ? left.register.sbyte_9 : right.register.sbyte_9);
				result.register.sbyte_10 = ((left.register.sbyte_10 < right.register.sbyte_10) ? left.register.sbyte_10 : right.register.sbyte_10);
				result.register.sbyte_11 = ((left.register.sbyte_11 < right.register.sbyte_11) ? left.register.sbyte_11 : right.register.sbyte_11);
				result.register.sbyte_12 = ((left.register.sbyte_12 < right.register.sbyte_12) ? left.register.sbyte_12 : right.register.sbyte_12);
				result.register.sbyte_13 = ((left.register.sbyte_13 < right.register.sbyte_13) ? left.register.sbyte_13 : right.register.sbyte_13);
				result.register.sbyte_14 = ((left.register.sbyte_14 < right.register.sbyte_14) ? left.register.sbyte_14 : right.register.sbyte_14);
				result.register.sbyte_15 = ((left.register.sbyte_15 < right.register.sbyte_15) ? left.register.sbyte_15 : right.register.sbyte_15);
				return result;
			}
			if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = ((left.register.uint16_0 < right.register.uint16_0) ? left.register.uint16_0 : right.register.uint16_0);
				result.register.uint16_1 = ((left.register.uint16_1 < right.register.uint16_1) ? left.register.uint16_1 : right.register.uint16_1);
				result.register.uint16_2 = ((left.register.uint16_2 < right.register.uint16_2) ? left.register.uint16_2 : right.register.uint16_2);
				result.register.uint16_3 = ((left.register.uint16_3 < right.register.uint16_3) ? left.register.uint16_3 : right.register.uint16_3);
				result.register.uint16_4 = ((left.register.uint16_4 < right.register.uint16_4) ? left.register.uint16_4 : right.register.uint16_4);
				result.register.uint16_5 = ((left.register.uint16_5 < right.register.uint16_5) ? left.register.uint16_5 : right.register.uint16_5);
				result.register.uint16_6 = ((left.register.uint16_6 < right.register.uint16_6) ? left.register.uint16_6 : right.register.uint16_6);
				result.register.uint16_7 = ((left.register.uint16_7 < right.register.uint16_7) ? left.register.uint16_7 : right.register.uint16_7);
				return result;
			}
			if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = ((left.register.int16_0 < right.register.int16_0) ? left.register.int16_0 : right.register.int16_0);
				result.register.int16_1 = ((left.register.int16_1 < right.register.int16_1) ? left.register.int16_1 : right.register.int16_1);
				result.register.int16_2 = ((left.register.int16_2 < right.register.int16_2) ? left.register.int16_2 : right.register.int16_2);
				result.register.int16_3 = ((left.register.int16_3 < right.register.int16_3) ? left.register.int16_3 : right.register.int16_3);
				result.register.int16_4 = ((left.register.int16_4 < right.register.int16_4) ? left.register.int16_4 : right.register.int16_4);
				result.register.int16_5 = ((left.register.int16_5 < right.register.int16_5) ? left.register.int16_5 : right.register.int16_5);
				result.register.int16_6 = ((left.register.int16_6 < right.register.int16_6) ? left.register.int16_6 : right.register.int16_6);
				result.register.int16_7 = ((left.register.int16_7 < right.register.int16_7) ? left.register.int16_7 : right.register.int16_7);
				return result;
			}
			if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = ((left.register.uint32_0 < right.register.uint32_0) ? left.register.uint32_0 : right.register.uint32_0);
				result.register.uint32_1 = ((left.register.uint32_1 < right.register.uint32_1) ? left.register.uint32_1 : right.register.uint32_1);
				result.register.uint32_2 = ((left.register.uint32_2 < right.register.uint32_2) ? left.register.uint32_2 : right.register.uint32_2);
				result.register.uint32_3 = ((left.register.uint32_3 < right.register.uint32_3) ? left.register.uint32_3 : right.register.uint32_3);
				return result;
			}
			if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = ((left.register.int32_0 < right.register.int32_0) ? left.register.int32_0 : right.register.int32_0);
				result.register.int32_1 = ((left.register.int32_1 < right.register.int32_1) ? left.register.int32_1 : right.register.int32_1);
				result.register.int32_2 = ((left.register.int32_2 < right.register.int32_2) ? left.register.int32_2 : right.register.int32_2);
				result.register.int32_3 = ((left.register.int32_3 < right.register.int32_3) ? left.register.int32_3 : right.register.int32_3);
				return result;
			}
			if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = ((left.register.uint64_0 < right.register.uint64_0) ? left.register.uint64_0 : right.register.uint64_0);
				result.register.uint64_1 = ((left.register.uint64_1 < right.register.uint64_1) ? left.register.uint64_1 : right.register.uint64_1);
				return result;
			}
			if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = ((left.register.int64_0 < right.register.int64_0) ? left.register.int64_0 : right.register.int64_0);
				result.register.int64_1 = ((left.register.int64_1 < right.register.int64_1) ? left.register.int64_1 : right.register.int64_1);
				return result;
			}
			if (typeof(T) == typeof(float))
			{
				result.register.single_0 = ((left.register.single_0 < right.register.single_0) ? left.register.single_0 : right.register.single_0);
				result.register.single_1 = ((left.register.single_1 < right.register.single_1) ? left.register.single_1 : right.register.single_1);
				result.register.single_2 = ((left.register.single_2 < right.register.single_2) ? left.register.single_2 : right.register.single_2);
				result.register.single_3 = ((left.register.single_3 < right.register.single_3) ? left.register.single_3 : right.register.single_3);
				return result;
			}
			if (typeof(T) == typeof(double))
			{
				result.register.double_0 = ((left.register.double_0 < right.register.double_0) ? left.register.double_0 : right.register.double_0);
				result.register.double_1 = ((left.register.double_1 < right.register.double_1) ? left.register.double_1 : right.register.double_1);
				return result;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> Max(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (ScalarGreaterThan(left[i], right[i]) ? ((byte)(object)left[i]) : ((byte)(object)right[i]));
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (ScalarGreaterThan(left[j], right[j]) ? ((sbyte)(object)left[j]) : ((sbyte)(object)right[j]));
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ScalarGreaterThan(left[k], right[k]) ? ((ushort)(object)left[k]) : ((ushort)(object)right[k]));
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (ScalarGreaterThan(left[l], right[l]) ? ((short)(object)left[l]) : ((short)(object)right[l]));
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (ScalarGreaterThan(left[m], right[m]) ? ((uint)(object)left[m]) : ((uint)(object)right[m]));
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (ScalarGreaterThan(left[n], right[n]) ? ((int)(object)left[n]) : ((int)(object)right[n]));
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ScalarGreaterThan(left[num], right[num]) ? ((ulong)(object)left[num]) : ((ulong)(object)right[num]));
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (ScalarGreaterThan(left[num2], right[num2]) ? ((long)(object)left[num2]) : ((long)(object)right[num2]));
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (ScalarGreaterThan(left[num3], right[num3]) ? ((float)(object)left[num3]) : ((float)(object)right[num3]));
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = (ScalarGreaterThan(left[num4], right[num4]) ? ((double)(object)left[num4]) : ((double)(object)right[num4]));
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			Vector<T> result = default(Vector<T>);
			if (typeof(T) == typeof(byte))
			{
				result.register.byte_0 = ((left.register.byte_0 > right.register.byte_0) ? left.register.byte_0 : right.register.byte_0);
				result.register.byte_1 = ((left.register.byte_1 > right.register.byte_1) ? left.register.byte_1 : right.register.byte_1);
				result.register.byte_2 = ((left.register.byte_2 > right.register.byte_2) ? left.register.byte_2 : right.register.byte_2);
				result.register.byte_3 = ((left.register.byte_3 > right.register.byte_3) ? left.register.byte_3 : right.register.byte_3);
				result.register.byte_4 = ((left.register.byte_4 > right.register.byte_4) ? left.register.byte_4 : right.register.byte_4);
				result.register.byte_5 = ((left.register.byte_5 > right.register.byte_5) ? left.register.byte_5 : right.register.byte_5);
				result.register.byte_6 = ((left.register.byte_6 > right.register.byte_6) ? left.register.byte_6 : right.register.byte_6);
				result.register.byte_7 = ((left.register.byte_7 > right.register.byte_7) ? left.register.byte_7 : right.register.byte_7);
				result.register.byte_8 = ((left.register.byte_8 > right.register.byte_8) ? left.register.byte_8 : right.register.byte_8);
				result.register.byte_9 = ((left.register.byte_9 > right.register.byte_9) ? left.register.byte_9 : right.register.byte_9);
				result.register.byte_10 = ((left.register.byte_10 > right.register.byte_10) ? left.register.byte_10 : right.register.byte_10);
				result.register.byte_11 = ((left.register.byte_11 > right.register.byte_11) ? left.register.byte_11 : right.register.byte_11);
				result.register.byte_12 = ((left.register.byte_12 > right.register.byte_12) ? left.register.byte_12 : right.register.byte_12);
				result.register.byte_13 = ((left.register.byte_13 > right.register.byte_13) ? left.register.byte_13 : right.register.byte_13);
				result.register.byte_14 = ((left.register.byte_14 > right.register.byte_14) ? left.register.byte_14 : right.register.byte_14);
				result.register.byte_15 = ((left.register.byte_15 > right.register.byte_15) ? left.register.byte_15 : right.register.byte_15);
				return result;
			}
			if (typeof(T) == typeof(sbyte))
			{
				result.register.sbyte_0 = ((left.register.sbyte_0 > right.register.sbyte_0) ? left.register.sbyte_0 : right.register.sbyte_0);
				result.register.sbyte_1 = ((left.register.sbyte_1 > right.register.sbyte_1) ? left.register.sbyte_1 : right.register.sbyte_1);
				result.register.sbyte_2 = ((left.register.sbyte_2 > right.register.sbyte_2) ? left.register.sbyte_2 : right.register.sbyte_2);
				result.register.sbyte_3 = ((left.register.sbyte_3 > right.register.sbyte_3) ? left.register.sbyte_3 : right.register.sbyte_3);
				result.register.sbyte_4 = ((left.register.sbyte_4 > right.register.sbyte_4) ? left.register.sbyte_4 : right.register.sbyte_4);
				result.register.sbyte_5 = ((left.register.sbyte_5 > right.register.sbyte_5) ? left.register.sbyte_5 : right.register.sbyte_5);
				result.register.sbyte_6 = ((left.register.sbyte_6 > right.register.sbyte_6) ? left.register.sbyte_6 : right.register.sbyte_6);
				result.register.sbyte_7 = ((left.register.sbyte_7 > right.register.sbyte_7) ? left.register.sbyte_7 : right.register.sbyte_7);
				result.register.sbyte_8 = ((left.register.sbyte_8 > right.register.sbyte_8) ? left.register.sbyte_8 : right.register.sbyte_8);
				result.register.sbyte_9 = ((left.register.sbyte_9 > right.register.sbyte_9) ? left.register.sbyte_9 : right.register.sbyte_9);
				result.register.sbyte_10 = ((left.register.sbyte_10 > right.register.sbyte_10) ? left.register.sbyte_10 : right.register.sbyte_10);
				result.register.sbyte_11 = ((left.register.sbyte_11 > right.register.sbyte_11) ? left.register.sbyte_11 : right.register.sbyte_11);
				result.register.sbyte_12 = ((left.register.sbyte_12 > right.register.sbyte_12) ? left.register.sbyte_12 : right.register.sbyte_12);
				result.register.sbyte_13 = ((left.register.sbyte_13 > right.register.sbyte_13) ? left.register.sbyte_13 : right.register.sbyte_13);
				result.register.sbyte_14 = ((left.register.sbyte_14 > right.register.sbyte_14) ? left.register.sbyte_14 : right.register.sbyte_14);
				result.register.sbyte_15 = ((left.register.sbyte_15 > right.register.sbyte_15) ? left.register.sbyte_15 : right.register.sbyte_15);
				return result;
			}
			if (typeof(T) == typeof(ushort))
			{
				result.register.uint16_0 = ((left.register.uint16_0 > right.register.uint16_0) ? left.register.uint16_0 : right.register.uint16_0);
				result.register.uint16_1 = ((left.register.uint16_1 > right.register.uint16_1) ? left.register.uint16_1 : right.register.uint16_1);
				result.register.uint16_2 = ((left.register.uint16_2 > right.register.uint16_2) ? left.register.uint16_2 : right.register.uint16_2);
				result.register.uint16_3 = ((left.register.uint16_3 > right.register.uint16_3) ? left.register.uint16_3 : right.register.uint16_3);
				result.register.uint16_4 = ((left.register.uint16_4 > right.register.uint16_4) ? left.register.uint16_4 : right.register.uint16_4);
				result.register.uint16_5 = ((left.register.uint16_5 > right.register.uint16_5) ? left.register.uint16_5 : right.register.uint16_5);
				result.register.uint16_6 = ((left.register.uint16_6 > right.register.uint16_6) ? left.register.uint16_6 : right.register.uint16_6);
				result.register.uint16_7 = ((left.register.uint16_7 > right.register.uint16_7) ? left.register.uint16_7 : right.register.uint16_7);
				return result;
			}
			if (typeof(T) == typeof(short))
			{
				result.register.int16_0 = ((left.register.int16_0 > right.register.int16_0) ? left.register.int16_0 : right.register.int16_0);
				result.register.int16_1 = ((left.register.int16_1 > right.register.int16_1) ? left.register.int16_1 : right.register.int16_1);
				result.register.int16_2 = ((left.register.int16_2 > right.register.int16_2) ? left.register.int16_2 : right.register.int16_2);
				result.register.int16_3 = ((left.register.int16_3 > right.register.int16_3) ? left.register.int16_3 : right.register.int16_3);
				result.register.int16_4 = ((left.register.int16_4 > right.register.int16_4) ? left.register.int16_4 : right.register.int16_4);
				result.register.int16_5 = ((left.register.int16_5 > right.register.int16_5) ? left.register.int16_5 : right.register.int16_5);
				result.register.int16_6 = ((left.register.int16_6 > right.register.int16_6) ? left.register.int16_6 : right.register.int16_6);
				result.register.int16_7 = ((left.register.int16_7 > right.register.int16_7) ? left.register.int16_7 : right.register.int16_7);
				return result;
			}
			if (typeof(T) == typeof(uint))
			{
				result.register.uint32_0 = ((left.register.uint32_0 > right.register.uint32_0) ? left.register.uint32_0 : right.register.uint32_0);
				result.register.uint32_1 = ((left.register.uint32_1 > right.register.uint32_1) ? left.register.uint32_1 : right.register.uint32_1);
				result.register.uint32_2 = ((left.register.uint32_2 > right.register.uint32_2) ? left.register.uint32_2 : right.register.uint32_2);
				result.register.uint32_3 = ((left.register.uint32_3 > right.register.uint32_3) ? left.register.uint32_3 : right.register.uint32_3);
				return result;
			}
			if (typeof(T) == typeof(int))
			{
				result.register.int32_0 = ((left.register.int32_0 > right.register.int32_0) ? left.register.int32_0 : right.register.int32_0);
				result.register.int32_1 = ((left.register.int32_1 > right.register.int32_1) ? left.register.int32_1 : right.register.int32_1);
				result.register.int32_2 = ((left.register.int32_2 > right.register.int32_2) ? left.register.int32_2 : right.register.int32_2);
				result.register.int32_3 = ((left.register.int32_3 > right.register.int32_3) ? left.register.int32_3 : right.register.int32_3);
				return result;
			}
			if (typeof(T) == typeof(ulong))
			{
				result.register.uint64_0 = ((left.register.uint64_0 > right.register.uint64_0) ? left.register.uint64_0 : right.register.uint64_0);
				result.register.uint64_1 = ((left.register.uint64_1 > right.register.uint64_1) ? left.register.uint64_1 : right.register.uint64_1);
				return result;
			}
			if (typeof(T) == typeof(long))
			{
				result.register.int64_0 = ((left.register.int64_0 > right.register.int64_0) ? left.register.int64_0 : right.register.int64_0);
				result.register.int64_1 = ((left.register.int64_1 > right.register.int64_1) ? left.register.int64_1 : right.register.int64_1);
				return result;
			}
			if (typeof(T) == typeof(float))
			{
				result.register.single_0 = ((left.register.single_0 > right.register.single_0) ? left.register.single_0 : right.register.single_0);
				result.register.single_1 = ((left.register.single_1 > right.register.single_1) ? left.register.single_1 : right.register.single_1);
				result.register.single_2 = ((left.register.single_2 > right.register.single_2) ? left.register.single_2 : right.register.single_2);
				result.register.single_3 = ((left.register.single_3 > right.register.single_3) ? left.register.single_3 : right.register.single_3);
				return result;
			}
			if (typeof(T) == typeof(double))
			{
				result.register.double_0 = ((left.register.double_0 > right.register.double_0) ? left.register.double_0 : right.register.double_0);
				result.register.double_1 = ((left.register.double_1 > right.register.double_1) ? left.register.double_1 : right.register.double_1);
				return result;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal static T DotProduct(Vector<T> left, Vector<T> right)
		{
			if (Vector.IsHardwareAccelerated)
			{
				T val = default(T);
				for (int i = 0; i < Count; i++)
				{
					val = ScalarAdd(val, ScalarMultiply(left[i], right[i]));
				}
				return val;
			}
			if (typeof(T) == typeof(byte))
			{
				byte b = 0;
				b += (byte)(left.register.byte_0 * right.register.byte_0);
				b += (byte)(left.register.byte_1 * right.register.byte_1);
				b += (byte)(left.register.byte_2 * right.register.byte_2);
				b += (byte)(left.register.byte_3 * right.register.byte_3);
				b += (byte)(left.register.byte_4 * right.register.byte_4);
				b += (byte)(left.register.byte_5 * right.register.byte_5);
				b += (byte)(left.register.byte_6 * right.register.byte_6);
				b += (byte)(left.register.byte_7 * right.register.byte_7);
				b += (byte)(left.register.byte_8 * right.register.byte_8);
				b += (byte)(left.register.byte_9 * right.register.byte_9);
				b += (byte)(left.register.byte_10 * right.register.byte_10);
				b += (byte)(left.register.byte_11 * right.register.byte_11);
				b += (byte)(left.register.byte_12 * right.register.byte_12);
				b += (byte)(left.register.byte_13 * right.register.byte_13);
				b += (byte)(left.register.byte_14 * right.register.byte_14);
				b += (byte)(left.register.byte_15 * right.register.byte_15);
				return (T)(object)b;
			}
			if (typeof(T) == typeof(sbyte))
			{
				sbyte b2 = 0;
				b2 += (sbyte)(left.register.sbyte_0 * right.register.sbyte_0);
				b2 += (sbyte)(left.register.sbyte_1 * right.register.sbyte_1);
				b2 += (sbyte)(left.register.sbyte_2 * right.register.sbyte_2);
				b2 += (sbyte)(left.register.sbyte_3 * right.register.sbyte_3);
				b2 += (sbyte)(left.register.sbyte_4 * right.register.sbyte_4);
				b2 += (sbyte)(left.register.sbyte_5 * right.register.sbyte_5);
				b2 += (sbyte)(left.register.sbyte_6 * right.register.sbyte_6);
				b2 += (sbyte)(left.register.sbyte_7 * right.register.sbyte_7);
				b2 += (sbyte)(left.register.sbyte_8 * right.register.sbyte_8);
				b2 += (sbyte)(left.register.sbyte_9 * right.register.sbyte_9);
				b2 += (sbyte)(left.register.sbyte_10 * right.register.sbyte_10);
				b2 += (sbyte)(left.register.sbyte_11 * right.register.sbyte_11);
				b2 += (sbyte)(left.register.sbyte_12 * right.register.sbyte_12);
				b2 += (sbyte)(left.register.sbyte_13 * right.register.sbyte_13);
				b2 += (sbyte)(left.register.sbyte_14 * right.register.sbyte_14);
				b2 += (sbyte)(left.register.sbyte_15 * right.register.sbyte_15);
				return (T)(object)b2;
			}
			if (typeof(T) == typeof(ushort))
			{
				ushort num = 0;
				num += (ushort)(left.register.uint16_0 * right.register.uint16_0);
				num += (ushort)(left.register.uint16_1 * right.register.uint16_1);
				num += (ushort)(left.register.uint16_2 * right.register.uint16_2);
				num += (ushort)(left.register.uint16_3 * right.register.uint16_3);
				num += (ushort)(left.register.uint16_4 * right.register.uint16_4);
				num += (ushort)(left.register.uint16_5 * right.register.uint16_5);
				num += (ushort)(left.register.uint16_6 * right.register.uint16_6);
				num += (ushort)(left.register.uint16_7 * right.register.uint16_7);
				return (T)(object)num;
			}
			if (typeof(T) == typeof(short))
			{
				short num2 = 0;
				num2 += (short)(left.register.int16_0 * right.register.int16_0);
				num2 += (short)(left.register.int16_1 * right.register.int16_1);
				num2 += (short)(left.register.int16_2 * right.register.int16_2);
				num2 += (short)(left.register.int16_3 * right.register.int16_3);
				num2 += (short)(left.register.int16_4 * right.register.int16_4);
				num2 += (short)(left.register.int16_5 * right.register.int16_5);
				num2 += (short)(left.register.int16_6 * right.register.int16_6);
				num2 += (short)(left.register.int16_7 * right.register.int16_7);
				return (T)(object)num2;
			}
			if (typeof(T) == typeof(uint))
			{
				uint num3 = 0u;
				num3 += left.register.uint32_0 * right.register.uint32_0;
				num3 += left.register.uint32_1 * right.register.uint32_1;
				num3 += left.register.uint32_2 * right.register.uint32_2;
				num3 += left.register.uint32_3 * right.register.uint32_3;
				return (T)(object)num3;
			}
			if (typeof(T) == typeof(int))
			{
				int num4 = 0;
				num4 += left.register.int32_0 * right.register.int32_0;
				num4 += left.register.int32_1 * right.register.int32_1;
				num4 += left.register.int32_2 * right.register.int32_2;
				num4 += left.register.int32_3 * right.register.int32_3;
				return (T)(object)num4;
			}
			if (typeof(T) == typeof(ulong))
			{
				ulong num5 = 0uL;
				num5 += left.register.uint64_0 * right.register.uint64_0;
				num5 += left.register.uint64_1 * right.register.uint64_1;
				return (T)(object)num5;
			}
			if (typeof(T) == typeof(long))
			{
				long num6 = 0L;
				num6 += left.register.int64_0 * right.register.int64_0;
				num6 += left.register.int64_1 * right.register.int64_1;
				return (T)(object)num6;
			}
			if (typeof(T) == typeof(float))
			{
				float num7 = 0f;
				num7 += left.register.single_0 * right.register.single_0;
				num7 += left.register.single_1 * right.register.single_1;
				num7 += left.register.single_2 * right.register.single_2;
				num7 += left.register.single_3 * right.register.single_3;
				return (T)(object)num7;
			}
			if (typeof(T) == typeof(double))
			{
				double num8 = 0.0;
				num8 += left.register.double_0 * right.register.double_0;
				num8 += left.register.double_1 * right.register.double_1;
				return (T)(object)num8;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		internal unsafe static Vector<T> SquareRoot(Vector<T> value)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (typeof(T) == typeof(byte))
				{
					byte* ptr = stackalloc byte[(int)(uint)Count];
					for (int i = 0; i < Count; i++)
					{
						ptr[i] = (byte)Math.Sqrt((int)(byte)(object)value[i]);
					}
					return new Vector<T>(ptr);
				}
				if (typeof(T) == typeof(sbyte))
				{
					sbyte* ptr2 = stackalloc sbyte[(int)(uint)Count];
					for (int j = 0; j < Count; j++)
					{
						ptr2[j] = (sbyte)Math.Sqrt((sbyte)(object)value[j]);
					}
					return new Vector<T>(ptr2);
				}
				if (typeof(T) == typeof(ushort))
				{
					ushort* ptr3 = stackalloc ushort[Count];
					for (int k = 0; k < Count; k++)
					{
						ptr3[k] = (ushort)Math.Sqrt((int)(ushort)(object)value[k]);
					}
					return new Vector<T>(ptr3);
				}
				if (typeof(T) == typeof(short))
				{
					short* ptr4 = stackalloc short[Count];
					for (int l = 0; l < Count; l++)
					{
						ptr4[l] = (short)Math.Sqrt((short)(object)value[l]);
					}
					return new Vector<T>(ptr4);
				}
				if (typeof(T) == typeof(uint))
				{
					uint* ptr5 = stackalloc uint[Count];
					for (int m = 0; m < Count; m++)
					{
						ptr5[m] = (uint)Math.Sqrt((uint)(object)value[m]);
					}
					return new Vector<T>(ptr5);
				}
				if (typeof(T) == typeof(int))
				{
					int* ptr6 = stackalloc int[Count];
					for (int n = 0; n < Count; n++)
					{
						ptr6[n] = (int)Math.Sqrt((int)(object)value[n]);
					}
					return new Vector<T>(ptr6);
				}
				if (typeof(T) == typeof(ulong))
				{
					ulong* ptr7 = stackalloc ulong[Count];
					for (int num = 0; num < Count; num++)
					{
						ptr7[num] = (ulong)Math.Sqrt((ulong)(object)value[num]);
					}
					return new Vector<T>(ptr7);
				}
				if (typeof(T) == typeof(long))
				{
					long* ptr8 = stackalloc long[Count];
					for (int num2 = 0; num2 < Count; num2++)
					{
						ptr8[num2] = (long)Math.Sqrt((long)(object)value[num2]);
					}
					return new Vector<T>(ptr8);
				}
				if (typeof(T) == typeof(float))
				{
					float* ptr9 = stackalloc float[Count];
					for (int num3 = 0; num3 < Count; num3++)
					{
						ptr9[num3] = (float)Math.Sqrt((float)(object)value[num3]);
					}
					return new Vector<T>(ptr9);
				}
				if (typeof(T) == typeof(double))
				{
					double* ptr10 = stackalloc double[Count];
					for (int num4 = 0; num4 < Count; num4++)
					{
						ptr10[num4] = Math.Sqrt((double)(object)value[num4]);
					}
					return new Vector<T>(ptr10);
				}
				throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
			}
			if (typeof(T) == typeof(byte))
			{
				value.register.byte_0 = (byte)Math.Sqrt((int)value.register.byte_0);
				value.register.byte_1 = (byte)Math.Sqrt((int)value.register.byte_1);
				value.register.byte_2 = (byte)Math.Sqrt((int)value.register.byte_2);
				value.register.byte_3 = (byte)Math.Sqrt((int)value.register.byte_3);
				value.register.byte_4 = (byte)Math.Sqrt((int)value.register.byte_4);
				value.register.byte_5 = (byte)Math.Sqrt((int)value.register.byte_5);
				value.register.byte_6 = (byte)Math.Sqrt((int)value.register.byte_6);
				value.register.byte_7 = (byte)Math.Sqrt((int)value.register.byte_7);
				value.register.byte_8 = (byte)Math.Sqrt((int)value.register.byte_8);
				value.register.byte_9 = (byte)Math.Sqrt((int)value.register.byte_9);
				value.register.byte_10 = (byte)Math.Sqrt((int)value.register.byte_10);
				value.register.byte_11 = (byte)Math.Sqrt((int)value.register.byte_11);
				value.register.byte_12 = (byte)Math.Sqrt((int)value.register.byte_12);
				value.register.byte_13 = (byte)Math.Sqrt((int)value.register.byte_13);
				value.register.byte_14 = (byte)Math.Sqrt((int)value.register.byte_14);
				value.register.byte_15 = (byte)Math.Sqrt((int)value.register.byte_15);
				return value;
			}
			if (typeof(T) == typeof(sbyte))
			{
				value.register.sbyte_0 = (sbyte)Math.Sqrt(value.register.sbyte_0);
				value.register.sbyte_1 = (sbyte)Math.Sqrt(value.register.sbyte_1);
				value.register.sbyte_2 = (sbyte)Math.Sqrt(value.register.sbyte_2);
				value.register.sbyte_3 = (sbyte)Math.Sqrt(value.register.sbyte_3);
				value.register.sbyte_4 = (sbyte)Math.Sqrt(value.register.sbyte_4);
				value.register.sbyte_5 = (sbyte)Math.Sqrt(value.register.sbyte_5);
				value.register.sbyte_6 = (sbyte)Math.Sqrt(value.register.sbyte_6);
				value.register.sbyte_7 = (sbyte)Math.Sqrt(value.register.sbyte_7);
				value.register.sbyte_8 = (sbyte)Math.Sqrt(value.register.sbyte_8);
				value.register.sbyte_9 = (sbyte)Math.Sqrt(value.register.sbyte_9);
				value.register.sbyte_10 = (sbyte)Math.Sqrt(value.register.sbyte_10);
				value.register.sbyte_11 = (sbyte)Math.Sqrt(value.register.sbyte_11);
				value.register.sbyte_12 = (sbyte)Math.Sqrt(value.register.sbyte_12);
				value.register.sbyte_13 = (sbyte)Math.Sqrt(value.register.sbyte_13);
				value.register.sbyte_14 = (sbyte)Math.Sqrt(value.register.sbyte_14);
				value.register.sbyte_15 = (sbyte)Math.Sqrt(value.register.sbyte_15);
				return value;
			}
			if (typeof(T) == typeof(ushort))
			{
				value.register.uint16_0 = (ushort)Math.Sqrt((int)value.register.uint16_0);
				value.register.uint16_1 = (ushort)Math.Sqrt((int)value.register.uint16_1);
				value.register.uint16_2 = (ushort)Math.Sqrt((int)value.register.uint16_2);
				value.register.uint16_3 = (ushort)Math.Sqrt((int)value.register.uint16_3);
				value.register.uint16_4 = (ushort)Math.Sqrt((int)value.register.uint16_4);
				value.register.uint16_5 = (ushort)Math.Sqrt((int)value.register.uint16_5);
				value.register.uint16_6 = (ushort)Math.Sqrt((int)value.register.uint16_6);
				value.register.uint16_7 = (ushort)Math.Sqrt((int)value.register.uint16_7);
				return value;
			}
			if (typeof(T) == typeof(short))
			{
				value.register.int16_0 = (short)Math.Sqrt(value.register.int16_0);
				value.register.int16_1 = (short)Math.Sqrt(value.register.int16_1);
				value.register.int16_2 = (short)Math.Sqrt(value.register.int16_2);
				value.register.int16_3 = (short)Math.Sqrt(value.register.int16_3);
				value.register.int16_4 = (short)Math.Sqrt(value.register.int16_4);
				value.register.int16_5 = (short)Math.Sqrt(value.register.int16_5);
				value.register.int16_6 = (short)Math.Sqrt(value.register.int16_6);
				value.register.int16_7 = (short)Math.Sqrt(value.register.int16_7);
				return value;
			}
			if (typeof(T) == typeof(uint))
			{
				value.register.uint32_0 = (uint)Math.Sqrt(value.register.uint32_0);
				value.register.uint32_1 = (uint)Math.Sqrt(value.register.uint32_1);
				value.register.uint32_2 = (uint)Math.Sqrt(value.register.uint32_2);
				value.register.uint32_3 = (uint)Math.Sqrt(value.register.uint32_3);
				return value;
			}
			if (typeof(T) == typeof(int))
			{
				value.register.int32_0 = (int)Math.Sqrt(value.register.int32_0);
				value.register.int32_1 = (int)Math.Sqrt(value.register.int32_1);
				value.register.int32_2 = (int)Math.Sqrt(value.register.int32_2);
				value.register.int32_3 = (int)Math.Sqrt(value.register.int32_3);
				return value;
			}
			if (typeof(T) == typeof(ulong))
			{
				value.register.uint64_0 = (ulong)Math.Sqrt(value.register.uint64_0);
				value.register.uint64_1 = (ulong)Math.Sqrt(value.register.uint64_1);
				return value;
			}
			if (typeof(T) == typeof(long))
			{
				value.register.int64_0 = (long)Math.Sqrt(value.register.int64_0);
				value.register.int64_1 = (long)Math.Sqrt(value.register.int64_1);
				return value;
			}
			if (typeof(T) == typeof(float))
			{
				value.register.single_0 = (float)Math.Sqrt(value.register.single_0);
				value.register.single_1 = (float)Math.Sqrt(value.register.single_1);
				value.register.single_2 = (float)Math.Sqrt(value.register.single_2);
				value.register.single_3 = (float)Math.Sqrt(value.register.single_3);
				return value;
			}
			if (typeof(T) == typeof(double))
			{
				value.register.double_0 = Math.Sqrt(value.register.double_0);
				value.register.double_1 = Math.Sqrt(value.register.double_1);
				return value;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarEquals(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left == (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left == (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left == (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left == (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left == (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left == (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left == (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left == (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left == (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left == (double)(object)right;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarLessThan(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left < (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left < (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left < (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left < (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left < (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left < (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left < (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left < (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left < (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left < (double)(object)right;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarGreaterThan(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left > (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left > (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left > (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left > (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left > (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left > (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left > (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left > (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left > (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left > (double)(object)right;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarAdd(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left + (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left + (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left + (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left + (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left + (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left + (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left + (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left + (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left + (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left + (double)(object)right);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarSubtract(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left - (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left - (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left - (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left - (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left - (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left - (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left - (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left - (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left - (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left - (double)(object)right);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarMultiply(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left * (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left * (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left * (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left * (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left * (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left * (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left * (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left * (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left * (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left * (double)(object)right);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarDivide(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left / (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left / (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left / (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left / (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left / (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left / (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left / (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left / (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left / (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left / (double)(object)right);
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T GetOneValue()
		{
			if (typeof(T) == typeof(byte))
			{
				byte b = 1;
				return (T)(object)b;
			}
			if (typeof(T) == typeof(sbyte))
			{
				sbyte b2 = 1;
				return (T)(object)b2;
			}
			if (typeof(T) == typeof(ushort))
			{
				ushort num = 1;
				return (T)(object)num;
			}
			if (typeof(T) == typeof(short))
			{
				short num2 = 1;
				return (T)(object)num2;
			}
			if (typeof(T) == typeof(uint))
			{
				uint num3 = 1u;
				return (T)(object)num3;
			}
			if (typeof(T) == typeof(int))
			{
				int num4 = 1;
				return (T)(object)num4;
			}
			if (typeof(T) == typeof(ulong))
			{
				ulong num5 = 1uL;
				return (T)(object)num5;
			}
			if (typeof(T) == typeof(long))
			{
				long num6 = 1L;
				return (T)(object)num6;
			}
			if (typeof(T) == typeof(float))
			{
				float num7 = 1f;
				return (T)(object)num7;
			}
			if (typeof(T) == typeof(double))
			{
				double num8 = 1.0;
				return (T)(object)num8;
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T GetAllBitsSetValue()
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)ConstantHelper.GetByteWithAllBitsSet();
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)ConstantHelper.GetSByteWithAllBitsSet();
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)ConstantHelper.GetUInt16WithAllBitsSet();
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)ConstantHelper.GetInt16WithAllBitsSet();
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)ConstantHelper.GetUInt32WithAllBitsSet();
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)ConstantHelper.GetInt32WithAllBitsSet();
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)ConstantHelper.GetUInt64WithAllBitsSet();
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)ConstantHelper.GetInt64WithAllBitsSet();
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)ConstantHelper.GetSingleWithAllBitsSet();
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)ConstantHelper.GetDoubleWithAllBitsSet();
			}
			throw new NotSupportedException(System.SR.Arg_TypeNotSupported);
		}
	}
	[System.Runtime.CompilerServices.Intrinsic]
	internal static class Vector
	{
		public static bool IsHardwareAccelerated
		{
			[System.Runtime.CompilerServices.Intrinsic]
			get
			{
				return false;
			}
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<byte> source, out Vector<ushort> low, out Vector<ushort> high)
		{
			int count = Vector<byte>.Count;
			ushort* ptr = stackalloc ushort[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			ushort* ptr2 = stackalloc ushort[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<ushort>(ptr);
			high = new Vector<ushort>(ptr2);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<ushort> source, out Vector<uint> low, out Vector<uint> high)
		{
			int count = Vector<ushort>.Count;
			uint* ptr = stackalloc uint[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			uint* ptr2 = stackalloc uint[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<uint>(ptr);
			high = new Vector<uint>(ptr2);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<uint> source, out Vector<ulong> low, out Vector<ulong> high)
		{
			int count = Vector<uint>.Count;
			ulong* ptr = stackalloc ulong[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			ulong* ptr2 = stackalloc ulong[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<ulong>(ptr);
			high = new Vector<ulong>(ptr2);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<sbyte> source, out Vector<short> low, out Vector<short> high)
		{
			int count = Vector<sbyte>.Count;
			short* ptr = stackalloc short[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			short* ptr2 = stackalloc short[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<short>(ptr);
			high = new Vector<short>(ptr2);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<short> source, out Vector<int> low, out Vector<int> high)
		{
			int count = Vector<short>.Count;
			int* ptr = stackalloc int[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			int* ptr2 = stackalloc int[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<int>(ptr);
			high = new Vector<int>(ptr2);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<int> source, out Vector<long> low, out Vector<long> high)
		{
			int count = Vector<int>.Count;
			long* ptr = stackalloc long[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			long* ptr2 = stackalloc long[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<long>(ptr);
			high = new Vector<long>(ptr2);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static void Widen(Vector<float> source, out Vector<double> low, out Vector<double> high)
		{
			int count = Vector<float>.Count;
			double* ptr = stackalloc double[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			double* ptr2 = stackalloc double[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = new Vector<double>(ptr);
			high = new Vector<double>(ptr2);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<byte> Narrow(Vector<ushort> low, Vector<ushort> high)
		{
			int count = Vector<byte>.Count;
			byte* ptr = stackalloc byte[(int)(uint)count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (byte)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (byte)high[j];
			}
			return new Vector<byte>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<ushort> Narrow(Vector<uint> low, Vector<uint> high)
		{
			int count = Vector<ushort>.Count;
			ushort* ptr = stackalloc ushort[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (ushort)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (ushort)high[j];
			}
			return new Vector<ushort>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<uint> Narrow(Vector<ulong> low, Vector<ulong> high)
		{
			int count = Vector<uint>.Count;
			uint* ptr = stackalloc uint[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (uint)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (uint)high[j];
			}
			return new Vector<uint>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<sbyte> Narrow(Vector<short> low, Vector<short> high)
		{
			int count = Vector<sbyte>.Count;
			sbyte* ptr = stackalloc sbyte[(int)(uint)count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (sbyte)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (sbyte)high[j];
			}
			return new Vector<sbyte>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<short> Narrow(Vector<int> low, Vector<int> high)
		{
			int count = Vector<short>.Count;
			short* ptr = stackalloc short[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (short)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (short)high[j];
			}
			return new Vector<short>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<int> Narrow(Vector<long> low, Vector<long> high)
		{
			int count = Vector<int>.Count;
			int* ptr = stackalloc int[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (int)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (int)high[j];
			}
			return new Vector<int>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<float> Narrow(Vector<double> low, Vector<double> high)
		{
			int count = Vector<float>.Count;
			float* ptr = stackalloc float[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (float)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (float)high[j];
			}
			return new Vector<float>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<float> ConvertToSingle(Vector<int> value)
		{
			int count = Vector<float>.Count;
			float* ptr = stackalloc float[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return new Vector<float>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<float> ConvertToSingle(Vector<uint> value)
		{
			int count = Vector<float>.Count;
			float* ptr = stackalloc float[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return new Vector<float>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<double> ConvertToDouble(Vector<long> value)
		{
			int count = Vector<double>.Count;
			double* ptr = stackalloc double[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return new Vector<double>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<double> ConvertToDouble(Vector<ulong> value)
		{
			int count = Vector<double>.Count;
			double* ptr = stackalloc double[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return new Vector<double>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<int> ConvertToInt32(Vector<float> value)
		{
			int count = Vector<int>.Count;
			int* ptr = stackalloc int[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (int)value[i];
			}
			return new Vector<int>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<uint> ConvertToUInt32(Vector<float> value)
		{
			int count = Vector<uint>.Count;
			uint* ptr = stackalloc uint[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (uint)value[i];
			}
			return new Vector<uint>(ptr);
		}

		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<long> ConvertToInt64(Vector<double> value)
		{
			int count = Vector<long>.Count;
			long* ptr = stackalloc long[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (long)value[i];
			}
			return new Vector<long>(ptr);
		}

		[CLSCompliant(false)]
		[System.Runtime.CompilerServices.Intrinsic]
		public unsafe static Vector<ulong> ConvertToUInt64(Vector<double> value)
		{
			int count = Vector<ulong>.Count;
			ulong* ptr = stackalloc ulong[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (ulong)value[i];
			}
			return new Vector<ulong>(ptr);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<float> ConditionalSelect(Vector<int> condition, Vector<float> left, Vector<float> right)
		{
			return Vector<float>.ConditionalSelect((Vector<float>)condition, left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<double> ConditionalSelect(Vector<long> condition, Vector<double> left, Vector<double> right)
		{
			return Vector<double>.ConditionalSelect((Vector<double>)condition, left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> ConditionalSelect<T>(Vector<T> condition, Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.ConditionalSelect(condition, left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Equals<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> Equals(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> Equals(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> Equals(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> Equals(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EqualsAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left == right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EqualsAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !Vector<T>.Equals(left, right).Equals(Vector<T>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> LessThan<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> LessThan(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> LessThan(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> LessThan(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> LessThan(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.LessThan(left, right)).Equals(Vector<int>.AllOnes);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.LessThan(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> LessThanOrEqual<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> LessThanOrEqual(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> LessThanOrEqual(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> LessThanOrEqual(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> LessThanOrEqual(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanOrEqualAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.LessThanOrEqual(left, right)).Equals(Vector<int>.AllOnes);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanOrEqualAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.LessThanOrEqual(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> GreaterThan<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> GreaterThan(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> GreaterThan(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> GreaterThan(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> GreaterThan(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.GreaterThan(left, right)).Equals(Vector<int>.AllOnes);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.GreaterThan(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> GreaterThanOrEqual<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> GreaterThanOrEqual(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> GreaterThanOrEqual(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> GreaterThanOrEqual(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> GreaterThanOrEqual(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanOrEqualAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.GreaterThanOrEqual(left, right)).Equals(Vector<int>.AllOnes);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanOrEqualAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.GreaterThanOrEqual(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Abs<T>(Vector<T> value) where T : struct
		{
			return Vector<T>.Abs(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Min<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Min(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Max<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Max(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T Dot<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.DotProduct(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> SquareRoot<T>(Vector<T> value) where T : struct
		{
			return Vector<T>.SquareRoot(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Add<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left + right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Subtract<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left - right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Multiply<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Multiply<T>(Vector<T> left, T right) where T : struct
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Multiply<T>(T left, Vector<T> right) where T : struct
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Divide<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left / right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Negate<T>(Vector<T> value) where T : struct
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> BitwiseAnd<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left & right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> BitwiseOr<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left | right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> OnesComplement<T>(Vector<T> value) where T : struct
		{
			return ~value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Xor<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left ^ right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> AndNot<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left & ~right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<byte> AsVectorByte<T>(Vector<T> value) where T : struct
		{
			return (Vector<byte>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<sbyte> AsVectorSByte<T>(Vector<T> value) where T : struct
		{
			return (Vector<sbyte>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<ushort> AsVectorUInt16<T>(Vector<T> value) where T : struct
		{
			return (Vector<ushort>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<short> AsVectorInt16<T>(Vector<T> value) where T : struct
		{
			return (Vector<short>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<uint> AsVectorUInt32<T>(Vector<T> value) where T : struct
		{
			return (Vector<uint>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> AsVectorInt32<T>(Vector<T> value) where T : struct
		{
			return (Vector<int>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<ulong> AsVectorUInt64<T>(Vector<T> value) where T : struct
		{
			return (Vector<ulong>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> AsVectorInt64<T>(Vector<T> value) where T : struct
		{
			return (Vector<long>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<float> AsVectorSingle<T>(Vector<T> value) where T : struct
		{
			return (Vector<float>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<double> AsVectorDouble<T>(Vector<T> value) where T : struct
		{
			return (Vector<double>)value;
		}
	}
}
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;
		}
	}
}