the_tavern-AutogenRundown Source

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

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using AIGraph;
using Agents;
using AmorLib.API;
using AmorLib.Dependencies;
using AmorLib.Events;
using AmorLib.Utils;
using AmorLib.Utils.Extensions;
using AmorLib.Utils.JsonElementConverters;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CullingSystem;
using GTFO.API;
using GTFO.API.Extensions;
using GTFO.API.JSON;
using GTFO.API.Utilities;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using InjectLib.JsonNETInjection.Supports;
using LevelGeneration;
using Localization;
using MTFO.Ext.PartialData;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using SemanticVersioning;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AmorLib")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b41318f3ac2a7407b947876732694101ea94314d")]
[assembly: AssemblyProduct("AmorLib")]
[assembly: AssemblyTitle("AmorLib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace AmorLib
{
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	internal sealed class CallConstructorOnLoadAttribute : Attribute
	{
	}
	[BepInPlugin("Amor.AmorLib", "AmorLib", "1.2.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal sealed class EntryPoint : BasePlugin
	{
		public override void Load()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("Amor.AmorLib").PatchAll();
			CallAllAutoConstructors();
			Logger.Info("AmorLib is done loading!");
		}

		private void CallAllAutoConstructors()
		{
			foreach (Type item in from t in AccessTools.GetTypesFromAssembly(((object)this).GetType().Assembly)
				where t.IsDefined(typeof(CallConstructorOnLoadAttribute), inherit: false)
				select t)
			{
				RuntimeHelpers.RunClassConstructor(item.TypeHandle);
			}
		}
	}
	internal static class Logger
	{
		private static readonly ManualLogSource MLS;

		static Logger()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			MLS = new ManualLogSource("AmorLib");
			Logger.Sources.Add((ILogSource)(object)MLS);
		}

		public static void Info(BepInExInfoLogInterpolatedStringHandler handler)
		{
			MLS.LogInfo(handler);
		}

		public static void Info(string str)
		{
			MLS.LogMessage((object)str);
		}

		public static void Debug(BepInExDebugLogInterpolatedStringHandler handler)
		{
			MLS.LogDebug(handler);
		}

		public static void Debug(string str)
		{
			MLS.LogDebug((object)str);
		}

		public static void Error(BepInExErrorLogInterpolatedStringHandler handler)
		{
			MLS.LogError(handler);
		}

		public static void Error(string str)
		{
			MLS.LogError((object)str);
		}

		public static void Warn(BepInExWarningLogInterpolatedStringHandler handler)
		{
			MLS.LogWarning(handler);
		}

		public static void Warn(string str)
		{
			MLS.LogWarning((object)str);
		}
	}
}
namespace AmorLib.Utils
{
	[CallConstructorOnLoad]
	public static class CourseNodeUtil
	{
		private class DimensionMap
		{
			private const float IndexSize = 4f;

			public List<AIG_CourseNode>?[,] BuildNodeMap;

			public AIG_CourseNode[,][] NodeMap;

			public (int x, int z) MinCellBound;

			public (int x, int z) MaxCellBound;

			public (int x, int z) MapSize;

			internal DimensionMap()
			{
				BuildNodeMap = null;
				NodeMap = null;
				MapSize = (0, 0);
				MinCellBound = (int.MaxValue, int.MaxValue);
				MaxCellBound = (int.MinValue, int.MinValue);
			}

			internal void UpdateBounds(Vector3 position)
			{
				//IL_0000: 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)
				int val = (int)(position.x / 4f);
				int val2 = (int)(position.z / 4f);
				MinCellBound = (Math.Min(val, MinCellBound.x), Math.Min(val2, MinCellBound.z));
				MaxCellBound = (Math.Max(val, MaxCellBound.x), Math.Max(val2, MaxCellBound.z));
			}

			internal void CreateNodeMap()
			{
				MapSize = (MaxCellBound.x - MinCellBound.x + 1, MaxCellBound.z - MinCellBound.z + 1);
				BuildNodeMap = new List<AIG_CourseNode>[MapSize.x, MapSize.z];
				NodeMap = new AIG_CourseNode[MapSize.x, MapSize.z][];
			}

			internal (int x, int z) GetMapPos(Vector3 position)
			{
				//IL_0000: 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)
				return (Math.Clamp((int)(position.x / 4f) - MinCellBound.x, 0, MapSize.x - 1), Math.Clamp((int)(position.z / 4f) - MinCellBound.z, 0, MapSize.z - 1));
			}

			internal List<AIG_CourseNode> GetBuildNodeList(Vector3 position)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				(int x, int z) mapPos = GetMapPos(position);
				int item = mapPos.x;
				int item2 = mapPos.z;
				List<AIG_CourseNode> list = BuildNodeMap[item, item2];
				if (list == null)
				{
					list = (BuildNodeMap[item, item2] = new List<AIG_CourseNode>());
				}
				return list;
			}

			internal void FinishBuild()
			{
				for (int i = 0; i < MapSize.x; i++)
				{
					for (int j = 0; j < MapSize.z; j++)
					{
						NodeMap[i, j] = BuildNodeMap[i, j]?.ToArray();
					}
				}
				BuildNodeMap = null;
			}

			public AIG_CourseNode[] GetNodes(Vector3 position)
			{
				//IL_0001: 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_015d: Expected O, but got Unknown
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				var (num, num2) = GetMapPos(position);
				if (NodeMap[num, num2] != null)
				{
					return NodeMap[num, num2];
				}
				float num3 = Math.Max(MapSize.x, MapSize.z);
				for (int i = 1; (float)i < num3; i++)
				{
					int num4 = Math.Max(num - i, 0);
					int num5 = Math.Min(num + i, MapSize.x - 1);
					int num6 = Math.Max(num2 - i, 0);
					int num7 = Math.Min(num2 + i, MapSize.z - 1);
					for (int j = num4; j <= num5; j++)
					{
						if (NodeMap[j, num6] != null)
						{
							return NodeMap[j, num6];
						}
						if (NodeMap[j, num7] != null)
						{
							return NodeMap[j, num7];
						}
					}
					for (int k = num6 + 1; k <= num7 - 1; k++)
					{
						if (NodeMap[num4, k] != null)
						{
							return NodeMap[num4, k];
						}
						if (NodeMap[num5, k] != null)
						{
							return NodeMap[num5, k];
						}
					}
				}
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(66, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to get any node for (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Vector3>(position);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")! How are you even playing the game?!");
				}
				Logger.Error(val);
				return null;
			}
		}

		private static readonly Dictionary<eDimensionIndex, DimensionMap> _maps;

		static CourseNodeUtil()
		{
			_maps = new Dictionary<eDimensionIndex, DimensionMap>();
			LevelAPI.OnAfterBuildBatch += OnAfterBuildBatch;
		}

		private static void OnAfterBuildBatch(BatchName batch)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0051: 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_0099: 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_0177: Unknown result type (might be due to invalid IL or missing references)
			if ((int)batch != 38)
			{
				return;
			}
			_maps.Clear();
			Enumerator<AIG_NodeCluster> enumerator = AIG_NodeCluster.AllNodeClusters.GetEnumerator();
			while (enumerator.MoveNext())
			{
				AIG_NodeCluster current = enumerator.Current;
				object obj;
				if (current == null)
				{
					obj = null;
				}
				else
				{
					AIG_CourseNode courseNode = current.m_courseNode;
					obj = ((courseNode != null) ? courseNode.m_dimension : null);
				}
				if (obj != null)
				{
					if (!_maps.TryGetValue(current.m_courseNode.m_dimension.DimensionIndex, out DimensionMap value))
					{
						_maps.Add(current.m_courseNode.m_dimension.DimensionIndex, value = new DimensionMap());
					}
					Enumerator<AIG_INode> enumerator2 = current.m_nodes.GetEnumerator();
					while (enumerator2.MoveNext())
					{
						AIG_INode current2 = enumerator2.Current;
						value.UpdateBounds(current2.Position);
					}
				}
			}
			foreach (DimensionMap value2 in _maps.Values)
			{
				value2.CreateNodeMap();
			}
			enumerator = AIG_NodeCluster.AllNodeClusters.GetEnumerator();
			while (enumerator.MoveNext())
			{
				AIG_NodeCluster current3 = enumerator.Current;
				object obj2;
				if (current3 == null)
				{
					obj2 = null;
				}
				else
				{
					AIG_CourseNode courseNode2 = current3.m_courseNode;
					obj2 = ((courseNode2 != null) ? courseNode2.m_dimension : null);
				}
				if (obj2 == null)
				{
					continue;
				}
				DimensionMap dimensionMap = _maps[current3.m_courseNode.m_dimension.DimensionIndex];
				int id = current3.CourseNode.NodeID;
				Enumerator<AIG_INode> enumerator2 = current3.m_nodes.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					AIG_INode current4 = enumerator2.Current;
					List<AIG_CourseNode> buildNodeList = dimensionMap.GetBuildNodeList(current4.Position);
					if (!buildNodeList.Any((AIG_CourseNode node) => id == node.NodeID))
					{
						buildNodeList.Add(current3.CourseNode);
					}
				}
			}
			foreach (DimensionMap value3 in _maps.Values)
			{
				value3.FinishBuild();
			}
		}

		private static bool TryGetClosestNodeInCluster(AIG_NodeCluster cluster, Vector3 position, out AIG_INode node)
		{
			//IL_000d: 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_001a: 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_00b1: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			AIG_VoxelNodeVolume voxelNodeVolume = cluster.m_nodeVolume.m_voxelNodeVolume;
			if (voxelNodeVolume.TryGetCloseVoxelNode_Safe(position, position.y - 0.5f, position.y + 0.5f, ref node, false))
			{
				return true;
			}
			int num = default(int);
			int num2 = default(int);
			voxelNodeVolume.GetGridPosition(position, ref num, ref num2);
			num = Mathf.Clamp(num, 0, voxelNodeVolume.m_countX - 1);
			num2 = Mathf.Clamp(num2, 0, voxelNodeVolume.m_countZ - 1);
			float num3 = float.MaxValue;
			AIG_VoxelNode val = null;
			AIG_VoxelNodePillar val2 = default(AIG_VoxelNodePillar);
			for (int i = -1; i < 2; i++)
			{
				for (int j = -1; j < 2; j++)
				{
					if (!voxelNodeVolume.TryGetPillar(num + i, num2 + j, ref val2))
					{
						continue;
					}
					Enumerator<AIG_VoxelNode> enumerator = val2.m_nodes.GetEnumerator();
					while (enumerator.MoveNext())
					{
						AIG_VoxelNode current = enumerator.Current;
						if (current.ClusterID != cluster.ID)
						{
							continue;
						}
						Vector3 val3 = current.Position - position;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						if (sqrMagnitude < num3)
						{
							val = current;
							num3 = sqrMagnitude;
							if (num3 < 0.55f)
							{
								node = ((Il2CppObjectBase)val).Cast<AIG_INode>();
								return true;
							}
						}
					}
				}
			}
			if (val != null)
			{
				node = ((Il2CppObjectBase)val).Cast<AIG_INode>();
				return true;
			}
			return false;
		}

		public static AIG_CourseNode ResolveCourseNode(AIG_CourseNode[] list, Vector3 position)
		{
			//IL_0030: 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_00b1: 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_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_00cb: Unknown result type (might be due to invalid IL or missing references)
			if (list == null)
			{
				return null;
			}
			if (list.Length == 1)
			{
				return list[0];
			}
			(AIG_CourseNode, AIG_INode)[] array = new(AIG_CourseNode, AIG_INode)[list.Length];
			int num = 0;
			foreach (AIG_CourseNode val in list)
			{
				if (!TryGetClosestNodeInCluster(val.m_nodeCluster, position, out AIG_INode node))
				{
					node = val.m_nodeCluster.m_nodes[0];
				}
				array[num++] = (val, node);
			}
			bool flag = false;
			float num2 = float.MaxValue;
			AIG_CourseNode result = null;
			(AIG_CourseNode, AIG_INode)[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				var (val2, val3) = array2[i];
				if (val3 != null)
				{
					bool flag2 = val3.Position.y - 0.25f <= position.y;
					Vector3 val4 = position - val3.Position;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if ((!flag && flag2) || (flag == flag2 && sqrMagnitude < num2))
					{
						flag = flag2;
						num2 = sqrMagnitude;
						result = val2;
					}
				}
			}
			return result;
		}

		public static AIG_CourseNode GetCourseNode(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			? val = position;
			Dimension dimensionFromPos = Dimension.GetDimensionFromPos(position);
			int num;
			if (dimensionFromPos == null)
			{
				num = 0;
				val = num;
				num = (int)val;
			}
			else
			{
				val = dimensionFromPos.DimensionIndex;
				num = (int)val;
			}
			return GetCourseNode((Vector3)num, (eDimensionIndex)val);
		}

		public static AIG_CourseNode GetCourseNode(Vector3 position, eDimensionIndex dimensionIndex)
		{
			//IL_0005: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!_maps.TryGetValue(dimensionIndex, out DimensionMap value))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No Position-To-Node map for dimension ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eDimensionIndex>(dimensionIndex);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("!");
				}
				Logger.Error(val);
				return null;
			}
			return ResolveCourseNode(value.GetNodes(position), position);
		}

		public static AIG_CourseNode[] GetCourseNodes(Vector3 position, eDimensionIndex dimensionIndex)
		{
			//IL_0005: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!_maps.TryGetValue(dimensionIndex, out DimensionMap value))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No Position-To-Node map for dimension ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eDimensionIndex>(dimensionIndex);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("!");
				}
				Logger.Error(val);
				return null;
			}
			return value.GetNodes(position);
		}
	}
	public static class DataBlockUtil
	{
		public static bool TryGetBlock<T>(string name, [MaybeNullWhen(false)] out T block) where T : GameDataBlockBase<T>
		{
			if (PData_Wrapper.TryGetGUID(name, out var guid))
			{
				return DataBlockUtil.TryGetBlock<T>(guid, out block);
			}
			block = GameDataBlockBase<T>.GetBlock(name);
			if (block != null)
			{
				return ((GameDataBlockBase<T>)block).internalEnabled;
			}
			return false;
		}

		public static bool TryGetBlock<T>(uint id, [MaybeNullWhen(false)] out T block) where T : GameDataBlockBase<T>
		{
			block = GameDataBlockBase<T>.GetBlock(id);
			if (block != null)
			{
				return ((GameDataBlockBase<T>)block).internalEnabled;
			}
			return false;
		}
	}
	public abstract class GlobalBase
	{
		private eDimensionIndex _dimIndex;

		private LG_LayerType _layerType;

		private eLocalZoneIndex _localIndex;

		private GlobalZoneIndex _struct;

		private (int dim, int layer, int zone) _tuple;

		public Dimension? Dimension;

		public LG_Zone? Zone;

		private bool _isDirty = true;

		[JsonPropertyOrder(-10)]
		public eDimensionIndex DimensionIndex
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _dimIndex;
			}
			set
			{
				//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)
				_dimIndex = value;
				MarkDirty();
			}
		}

		[JsonPropertyOrder(-10)]
		public LG_LayerType Layer
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _layerType;
			}
			set
			{
				//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)
				_layerType = value;
				MarkDirty();
			}
		}

		[JsonPropertyOrder(-10)]
		public eLocalZoneIndex LocalIndex
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _localIndex;
			}
			set
			{
				//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)
				_localIndex = value;
				MarkDirty();
			}
		}

		[JsonIgnore]
		public GlobalZoneIndex GlobalZoneIndex
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				Refresh();
				return _struct;
			}
		}

		[JsonIgnore]
		public (int dimension, int layer, int zone) IntTuple
		{
			get
			{
				Refresh();
				return _tuple;
			}
		}

		protected GlobalBase()
		{
			Refresh();
			LevelAPI.OnAfterBuildBatch += OnAfterBuildBatch;
			LevelAPI.OnLevelCleanup += OnLevelCleanup;
		}

		private void OnAfterBuildBatch(BatchName batch)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if ((int)batch == 8)
			{
				Dimension val = default(Dimension);
				Dimension = (Dimension.GetDimension(_dimIndex, ref val) ? val : null);
				Zone = (_tuple.TryGetZone(out LG_Zone zone) ? zone : null);
			}
		}

		private void OnLevelCleanup()
		{
			Dimension = null;
			Zone = null;
		}

		private void MarkDirty()
		{
			_isDirty = true;
		}

		private void Refresh()
		{
			//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_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_0028: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			if (_isDirty)
			{
				_struct = GlobalIndexUtil.ToStruct(DimensionIndex, Layer, LocalIndex);
				_tuple = GlobalIndexUtil.ToIntTuple(DimensionIndex, Layer, LocalIndex);
				_isDirty = false;
			}
		}

		public override string ToString()
		{
			//IL_0018: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			return $"({DimensionIndex}, {Layer}, {LocalIndex})";
		}
	}
	public static class GlobalIndexUtil
	{
		public static (int dimension, int layer, int zone) ToIntTuple(this LG_Zone zone)
		{
			//IL_0001: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			return ToIntTuple(zone.DimensionIndex, zone.Layer.m_type, zone.LocalIndex);
		}

		public static (int dimension, int layer, int zone) ToIntTuple(this GlobalZoneIndex globalIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_000c: 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)
			return ToIntTuple(globalIndex.Dimension, globalIndex.Layer, globalIndex.Zone);
		}

		public static (int dimension, int layer, int zone) ToIntTuple(eDimensionIndex dimension, LG_LayerType layer, eLocalZoneIndex zone)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected I4, but got Unknown
			//IL_0008: Expected I4, but got Unknown
			//IL_0008: Expected I4, but got Unknown
			return ((int)dimension, (int)layer, (int)zone);
		}

		public static GlobalZoneIndex ToStruct(this LG_Zone zone)
		{
			//IL_0001: 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_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)
			return ToStruct(zone.DimensionIndex, zone.Layer.m_type, zone.LocalIndex);
		}

		public static GlobalZoneIndex ToStruct(eDimensionIndex dimension, LG_LayerType layer, eLocalZoneIndex zone)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new GlobalZoneIndex(dimension, layer, zone);
		}

		public static bool TryGetZone(this (int, int, int) index, [MaybeNullWhen(false)] out LG_Zone zone)
		{
			return TryGetZone((eDimensionIndex)index.Item1, (LG_LayerType)(byte)index.Item2, (eLocalZoneIndex)index.Item3, out zone);
		}

		public static bool TryGetZone(this GlobalZoneIndex index, [MaybeNullWhen(false)] out LG_Zone zone)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_000c: 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)
			return TryGetZone(index.Dimension, index.Layer, index.Zone, out zone);
		}

		public static bool TryGetZone(eDimensionIndex dimension, LG_LayerType layer, eLocalZoneIndex localIndex, out LG_Zone? zone)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_001b: Expected O, but got Unknown
			//IL_002a: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			if (!Builder.CurrentFloor.TryGetZoneByLocalIndex(dimension, layer, localIndex, ref zone))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(66, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to find zone in level! (Dimension: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eDimensionIndex>(dimension);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", Layer: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<LG_LayerType>(layer);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", LocalIndex: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eLocalZoneIndex>(localIndex);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
				}
				Logger.Error(val);
				return false;
			}
			return true;
		}
	}
	public static class JsonSerializerUtil
	{
		public static JsonSerializerOptions CreateDefaultSettings(bool useLocalizedText = true, bool usePartialData = false, bool useInjectLib = false)
		{
			JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(useLocalizedText ? JsonSerializer.DefaultSerializerSettingsWithLocalizedText : JsonSerializer.DefaultSerializerSettings);
			if (usePartialData && PData_Wrapper.IsLoaded)
			{
				jsonSerializerOptions.Converters.Add(PData_Wrapper.PersistentIDConverter);
			}
			if (useInjectLib && InjectLib_Wrapper.IsLoaded)
			{
				jsonSerializerOptions.Converters.Add(InjectLib_Wrapper.InjectLibConverter);
			}
			return jsonSerializerOptions;
		}
	}
	public sealed class ZoneNode
	{
		public readonly LG_Zone Zone;

		private readonly Dictionary<ushort, int> _groups = new Dictionary<ushort, int>();

		public AreaNode[] Areas { get; private set; }

		public IReadOnlyCollection<ushort> Groups => _groups.Keys;

		public ZoneNode(LG_Zone zone)
		{
			Zone = zone;
		}

		internal void OnNodesCreated()
		{
			List<AreaNode> list = new List<AreaNode>(Zone.m_areas.Count);
			Enumerator<LG_Area> enumerator = Zone.m_areas.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LG_Area current = enumerator.Current;
				list.Add(ZoneGraphUtil.GetAreaNode(current));
			}
			Areas = list.ToArray();
		}

		public bool IsReachable(ushort group)
		{
			return _groups.ContainsKey(group);
		}

		public bool IsReachable()
		{
			return _groups.Count > 0;
		}

		internal void Reset()
		{
			_groups.Clear();
		}

		internal void OnAreaReachable(ushort newGroup, ushort oldGroup)
		{
			if (_groups.TryGetValue(oldGroup, out var value) && --value == 0)
			{
				_groups.Remove(oldGroup);
			}
			if (newGroup != 0)
			{
				value = _groups.GetValueOrDefault(newGroup);
				_groups[newGroup] = value + 1;
			}
		}
	}
	public sealed class AreaNode
	{
		public class AreaEdge
		{
			public readonly LG_Gate Gate;

			public readonly AreaNode Neighbor;

			public bool IsOpen { get; private set; }

			public AreaEdge(LG_Gate gate, AreaNode area)
			{
				Gate = gate;
				Neighbor = area;
				UpdateOpen();
			}

			internal void UpdateOpen()
			{
				IsOpen = Gate.IsTraversable;
			}
		}

		public readonly LG_Area Area;

		public ushort Group { get; private set; }

		public ZoneNode Zone { get; private set; }

		public AreaEdge[] Edges { get; private set; }

		public AreaNode(LG_Area area)
		{
			Area = area;
		}

		public bool IsReachable(ushort group)
		{
			if (Group == group)
			{
				return group > 0;
			}
			return false;
		}

		public bool IsReachable()
		{
			return Group != 0;
		}

		internal void OnNodesCreated()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			Zone = ZoneGraphUtil.GetZoneNode(Area.m_zone);
			List<AreaEdge> list = new List<AreaEdge>();
			Enumerator<LG_Gate> enumerator = Area.m_gates.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LG_Gate current = enumerator.Current;
				LG_Area val = ((LG_ZoneExpander)current).m_linksFrom;
				if (!((Object)(object)val == (Object)null))
				{
					if (val.UID == Area.UID)
					{
						val = ((LG_ZoneExpander)current).m_linksTo;
					}
					if (!((Object)(object)val == (Object)null) && (int)((LG_ZoneExpander)current).ExpanderStatus != 2)
					{
						list.Add(new AreaEdge(current, ZoneGraphUtil.GetAreaNode(val)));
					}
				}
			}
			Edges = list.ToArray();
		}

		internal void Reset()
		{
			Group = 0;
		}

		internal void SetGroup(ushort group)
		{
			Zone.OnAreaReachable(group, Group);
			Group = group;
		}

		internal void UpdateEdges()
		{
			AreaEdge[] edges = Edges;
			for (int i = 0; i < edges.Length; i++)
			{
				edges[i].UpdateOpen();
			}
		}
	}
	[CallConstructorOnLoad]
	public sealed class ZoneGraphUtil
	{
		public const ushort NoGroup = 0;

		internal static readonly ZoneGraphUtil Current;

		private readonly Dictionary<int, ZoneNode> _zoneToNode = new Dictionary<int, ZoneNode>();

		private readonly Dictionary<int, AreaNode> _areaToNode = new Dictionary<int, AreaNode>();

		private readonly Dictionary<int, ushort> _playerToGroup = new Dictionary<int, ushort>();

		private ushort _lastGroup;

		public static bool IsReady { get; private set; }

		public static event Action? OnReachableUpdate;

		public static ZoneNode GetZoneNode(Agent agent)
		{
			return GetZoneNode(agent.CourseNode.m_zone);
		}

		public static ZoneNode GetZoneNode(AIG_CourseNode courseNode)
		{
			return GetZoneNode(courseNode.m_zone);
		}

		public static ZoneNode GetZoneNode(LG_Zone zone)
		{
			return Current._zoneToNode[zone.ID];
		}

		public static AreaNode GetAreaNode(Agent agent)
		{
			return GetAreaNode(agent.CourseNode.m_area);
		}

		public static AreaNode GetAreaNode(AIG_CourseNode courseNode)
		{
			return GetAreaNode(courseNode.m_area);
		}

		public static AreaNode GetAreaNode(LG_Area area)
		{
			return Current._areaToNode[area.UID];
		}

		public static ushort GetPlayerGroup(PlayerAgent player)
		{
			return Current._playerToGroup.GetValueOrDefault(player.PlayerSlotIndex);
		}

		public static bool IsReachable(PlayerAgent player, AIG_CourseNode courseNode)
		{
			return GetAreaNode(courseNode).IsReachable(GetPlayerGroup(player));
		}

		public static bool IsReachable(PlayerAgent player, LG_Area area)
		{
			return GetAreaNode(area).IsReachable(GetPlayerGroup(player));
		}

		public static bool IsReachable(PlayerAgent player, LG_Zone zone)
		{
			return GetZoneNode(zone).IsReachable(GetPlayerGroup(player));
		}

		public static bool IsReachable(AIG_CourseNode courseNode)
		{
			return GetAreaNode(courseNode).IsReachable();
		}

		public static bool IsReachable(LG_Area area)
		{
			return GetAreaNode(area).IsReachable();
		}

		public static bool IsReachable(LG_Zone zone)
		{
			return GetZoneNode(zone).IsReachable();
		}

		static ZoneGraphUtil()
		{
			IsReady = false;
			Current = new ZoneGraphUtil();
			LevelAPI.OnBuildStart += delegate
			{
				LG_Area.s_areaUIDCounter = 0;
			};
			LevelAPI.OnBuildDone += Current.BuildZoneGraph;
			LevelAPI.OnLevelCleanup += Current.Cleanup;
			SNetEvents.OnCheckpointReload += Current.RefreshOnCheckpoint;
		}

		private void BuildZoneGraph()
		{
			Enumerator<LG_Zone> enumerator = Builder.CurrentFloor.allZones.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LG_Zone current = enumerator.Current;
				_zoneToNode.TryAdd(current.ID, new ZoneNode(current));
				Enumerator<LG_Area> enumerator2 = current.m_areas.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					LG_Area current2 = enumerator2.Current;
					_areaToNode.TryAdd(current2.UID, new AreaNode(current2));
				}
			}
			foreach (ZoneNode value in _zoneToNode.Values)
			{
				value.OnNodesCreated();
			}
			foreach (AreaNode value2 in _areaToNode.Values)
			{
				value2.OnNodesCreated();
			}
			IsReady = true;
		}

		private void Cleanup()
		{
			_zoneToNode.Clear();
			_areaToNode.Clear();
			_playerToGroup.Clear();
			_lastGroup = 0;
			IsReady = false;
		}

		private void RefreshOnCheckpoint()
		{
			foreach (AreaNode value in _areaToNode.Values)
			{
				value.UpdateEdges();
			}
			RefreshGraph();
		}

		private void RefreshGraph()
		{
			foreach (ZoneNode value in _zoneToNode.Values)
			{
				value.Reset();
			}
			foreach (AreaNode value2 in _areaToNode.Values)
			{
				value2.Reset();
			}
			_playerToGroup.Clear();
			_lastGroup = 0;
			Enumerator<PlayerAgent> enumerator3 = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
			while (enumerator3.MoveNext())
			{
				PlayerAgent current = enumerator3.Current;
				if (((Agent)current).CourseNode != null)
				{
					UpdateOrCreateGroup(current);
				}
			}
			ZoneGraphUtil.OnReachableUpdate?.Invoke();
		}

		private ushort UpdateOrCreateGroup(PlayerAgent player)
		{
			int playerSlotIndex = player.PlayerSlotIndex;
			AreaNode areaNode = GetAreaNode((Agent)(object)player);
			if (areaNode.IsReachable())
			{
				return _playerToGroup[playerSlotIndex] = areaNode.Group;
			}
			_playerToGroup[playerSlotIndex] = ++_lastGroup;
			PropogateGroup(areaNode, _lastGroup);
			return _lastGroup;
		}

		private void PropogateGroup(AreaNode areaNode, ushort group)
		{
			areaNode.SetGroup(group);
			AreaNode.AreaEdge[] edges = areaNode.Edges;
			foreach (AreaNode.AreaEdge areaEdge in edges)
			{
				if (areaEdge.IsOpen && areaEdge.Neighbor.Group != group)
				{
					PropogateGroup(areaEdge.Neighbor, group);
				}
			}
		}

		internal void Internal_OnPlayerNodeChanged(PlayerAgent player, AIG_CourseNode oldNode)
		{
			if (!IsReady)
			{
				return;
			}
			ushort group = UpdateOrCreateGroup(player);
			if (oldNode != null)
			{
				AreaNode areaNode = GetAreaNode(oldNode.m_area);
				if (areaNode.IsReachable(group))
				{
					return;
				}
				foreach (ushort value in _playerToGroup.Values)
				{
					if (areaNode.IsReachable(value))
					{
						ZoneGraphUtil.OnReachableUpdate?.Invoke();
						return;
					}
				}
				PropogateGroup(areaNode, 0);
			}
			ZoneGraphUtil.OnReachableUpdate?.Invoke();
		}

		internal void Internal_OnDoorStateChanged(LG_Gate gate, bool isOpen)
		{
			if (!IsReady)
			{
				return;
			}
			AreaNode areaNode = GetAreaNode(((LG_ZoneExpander)gate).m_linksFrom);
			AreaNode areaNode2 = GetAreaNode(((LG_ZoneExpander)gate).m_linksTo);
			areaNode.UpdateEdges();
			areaNode2.UpdateEdges();
			int key;
			ushort value;
			if (!isOpen)
			{
				if (areaNode.IsReachable())
				{
					RefreshGraph();
				}
			}
			else if (areaNode.IsReachable())
			{
				KeyValuePair<int, ushort>[] array = _playerToGroup.ToArray();
				foreach (KeyValuePair<int, ushort> keyValuePair in array)
				{
					keyValuePair.Deconstruct(out key, out value);
					int key2 = key;
					if (value == areaNode2.Group)
					{
						_playerToGroup[key2] = areaNode.Group;
					}
				}
				PropogateGroup(areaNode2, areaNode.Group);
				ZoneGraphUtil.OnReachableUpdate?.Invoke();
			}
			else
			{
				if (!areaNode2.IsReachable())
				{
					return;
				}
				KeyValuePair<int, ushort>[] array = _playerToGroup.ToArray();
				foreach (KeyValuePair<int, ushort> keyValuePair in array)
				{
					keyValuePair.Deconstruct(out key, out value);
					int key3 = key;
					if (value == areaNode.Group)
					{
						_playerToGroup[key3] = areaNode2.Group;
					}
				}
				PropogateGroup(areaNode, areaNode2.Group);
				ZoneGraphUtil.OnReachableUpdate?.Invoke();
			}
		}
	}
}
namespace AmorLib.Utils.JsonElementConverters
{
	[JsonConverter(typeof(BoolBaseConverter))]
	public struct BoolBase
	{
		public BoolMode Mode;

		public static readonly BoolBase False = new BoolBase(BoolMode.False);

		public static readonly BoolBase True = new BoolBase(BoolMode.True);

		public static readonly BoolBase Unchanged = new BoolBase(BoolMode.Unchanged);

		public BoolBase(bool mode)
		{
			Mode = (mode ? BoolMode.True : BoolMode.False);
		}

		public BoolBase(BoolMode mode)
		{
			Mode = mode;
		}

		public readonly bool GetValue(bool originalValue)
		{
			return Mode switch
			{
				BoolMode.True => true, 
				BoolMode.False => false, 
				_ => originalValue, 
			};
		}
	}
	public enum BoolMode
	{
		False,
		True,
		Unchanged
	}
	public sealed class BoolBaseConverter : JsonConverter<BoolBase>
	{
		public override bool HandleNull => false;

		public override bool CanConvert(Type objectType)
		{
			return objectType == typeof(BoolBase);
		}

		public override BoolBase Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			switch (reader.TokenType)
			{
			case JsonTokenType.String:
			{
				string text = reader.GetString()?.Trim();
				if (string.IsNullOrEmpty(text))
				{
					throw new JsonException("BoolBase string value is null or empty!");
				}
				if (text.EqualsAny(true, "Unchanged", "Ignore", "Keep", "Original", "KeepOriginal"))
				{
					return BoolBase.Unchanged;
				}
				if (bool.TryParse(text, out var result))
				{
					return new BoolBase(result);
				}
				throw new JsonException("Cannot parse BoolBase string: " + text + "! Are you sure it's in right format?");
			}
			case JsonTokenType.True:
				return BoolBase.True;
			case JsonTokenType.False:
				return BoolBase.False;
			default:
				throw new JsonException($"BoolBaseJson type: {reader.TokenType} is not implemented!");
			}
		}

		public override void Write(Utf8JsonWriter writer, BoolBase value, JsonSerializerOptions options)
		{
			switch (value.Mode)
			{
			case BoolMode.True:
				writer.WriteBooleanValue(value: true);
				break;
			case BoolMode.False:
				writer.WriteBooleanValue(value: false);
				break;
			case BoolMode.Unchanged:
				writer.WriteStringValue("Unchanged");
				break;
			}
			writer.WriteCommentValue("BoolBase");
		}
	}
	[JsonConverter(typeof(LocaleTextConverter))]
	public struct LocaleText : IEquatable<LocaleText>
	{
		public uint ID;

		public string RawText;

		public static readonly LocaleText Empty = new LocaleText(string.Empty);

		private readonly string TextFallback
		{
			get
			{
				if (ID != 0)
				{
					return Text.Get(ID);
				}
				return RawText;
			}
		}

		public LocaleText(LocalizedText baseText)
		{
			RawText = ((Object)baseText).ToString();
			ID = baseText.Id;
		}

		public LocaleText(string text)
		{
			if (PData_Wrapper.TryGetGUID(text, out var guid))
			{
				RawText = string.Empty;
				ID = guid;
			}
			else
			{
				RawText = text;
				ID = 0u;
			}
		}

		public LocaleText(uint id)
		{
			RawText = string.Empty;
			ID = id;
		}

		public readonly LocalizedText ToLocalizedText()
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return new LocalizedText
			{
				Id = ID,
				UntranslatedText = TextFallback
			};
		}

		public static explicit operator LocaleText(LocalizedText localizedText)
		{
			return new LocaleText(localizedText);
		}

		public static explicit operator LocaleText(string text)
		{
			return new LocaleText(text);
		}

		public static implicit operator LocalizedText(LocaleText localeText)
		{
			return localeText.ToLocalizedText();
		}

		public static implicit operator string(LocaleText localeText)
		{
			return localeText.ToString();
		}

		public override readonly string ToString()
		{
			return TextFallback;
		}

		public readonly bool Equals(LocaleText other)
		{
			if (ID == other.ID)
			{
				return string.Equals(RawText, other.RawText, StringComparison.Ordinal);
			}
			return false;
		}

		public override readonly bool Equals(object? obj)
		{
			if (obj is LocaleText other)
			{
				return Equals(other);
			}
			return false;
		}

		public override readonly int GetHashCode()
		{
			return HashCode.Combine(ID, RawText);
		}

		public static bool operator ==(LocaleText left, LocaleText right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(LocaleText left, LocaleText right)
		{
			return !(left == right);
		}
	}
	public class LocaleTextConverter : JsonConverter<LocaleText>
	{
		public override bool HandleNull => true;

		public override LocaleText Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			return reader.TokenType switch
			{
				JsonTokenType.String => new LocaleText(reader.GetString()), 
				JsonTokenType.Number => new LocaleText(reader.GetUInt32()), 
				JsonTokenType.Null => LocaleText.Empty, 
				_ => throw new JsonException($"LocaleTextJson type: {reader.TokenType} is not implemented!"), 
			};
		}

		public override void Write(Utf8JsonWriter writer, LocaleText value, JsonSerializerOptions options)
		{
			if (value.ID != 0)
			{
				writer.WriteNumberValue(value.ID);
			}
			else
			{
				writer.WriteStringValue(value.RawText);
			}
		}
	}
	[JsonConverter(typeof(ValueBaseConverter))]
	public struct ValueBase
	{
		public float Value;

		public ValueMode Mode;

		public bool FromDefault;

		public static readonly ValueBase Unchanged = new ValueBase(1f, ValueMode.Rel, fromDefault: true);

		public static readonly ValueBase Zero = new ValueBase(0f, ValueMode.Abs, fromDefault: false);

		public ValueBase(float value = 1f, ValueMode mode = ValueMode.Rel, bool fromDefault = true)
		{
			Value = value;
			Mode = mode;
			FromDefault = fromDefault;
		}

		public readonly float GetAbsValue(float maxValue, float currentValue)
		{
			if (Mode == ValueMode.Rel)
			{
				if (!FromDefault)
				{
					return maxValue * Value;
				}
				return currentValue * Value;
			}
			return Value;
		}

		public readonly float GetAbsValue(float baseValue)
		{
			if (Mode != ValueMode.Abs)
			{
				return baseValue * Value;
			}
			return Value;
		}

		public readonly int GetAbsValue(int maxValue, int currentValue)
		{
			return (int)Math.Round(GetAbsValue((float)maxValue, (float)currentValue));
		}

		public readonly int GetAbsValue(int baseValue)
		{
			return (int)Math.Round(GetAbsValue((float)baseValue));
		}

		public override readonly string ToString()
		{
			return $"[Mode: {Mode}, Value: {Value}]";
		}
	}
	public enum ValueMode
	{
		Rel,
		Abs
	}
	public sealed class ValueBaseConverter : JsonConverter<ValueBase>
	{
		public override bool HandleNull => false;

		public override bool CanConvert(Type objectType)
		{
			return objectType == typeof(ValueBase);
		}

		public override ValueBase Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			switch (reader.TokenType)
			{
			case JsonTokenType.Number:
				return new ValueBase(reader.GetSingle(), ValueMode.Abs);
			case JsonTokenType.StartObject:
			{
				ValueBase result3 = default(ValueBase);
				while (reader.Read())
				{
					if (reader.TokenType == JsonTokenType.EndObject)
					{
						return result3;
					}
					if (reader.TokenType != JsonTokenType.PropertyName)
					{
						throw new JsonException("Expected PropertyName token");
					}
					string? @string = reader.GetString();
					reader.Read();
					switch (@string.ToLowerInvariant())
					{
					case "value":
						result3.Value = reader.GetSingle();
						break;
					case "mode":
					{
						if (Enum.TryParse<ValueMode>(reader.GetString(), out var result4))
						{
							result3.Mode = result4;
						}
						break;
					}
					case "fromdefault":
						result3.FromDefault = reader.GetBoolean();
						break;
					}
				}
				throw new JsonException("Expected EndObject token");
			}
			case JsonTokenType.String:
			{
				string text = reader.GetString()?.Trim();
				if (string.IsNullOrEmpty(text))
				{
					throw new JsonException("ValueBase string value is null or empty!");
				}
				bool fromDefault = false;
				if (text.EndsWith("of default", StringComparison.OrdinalIgnoreCase))
				{
					fromDefault = true;
					string text2 = text;
					text = text2.Substring(0, text2.Length - 10).TrimEnd();
				}
				if (text.EndsWith("%", StringComparison.InvariantCulture))
				{
					string text2 = text;
					if (float.TryParse(text2.Substring(0, text2.Length - 1).TrimEnd(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out var result))
					{
						return new ValueBase(result / 100f, ValueMode.Rel, fromDefault);
					}
				}
				if (text.EqualsAny(true, "Unchanged", "Ignore", "Keep", "Original", "KeepOriginal"))
				{
					return new ValueBase(1f, ValueMode.Rel, fromDefault: false);
				}
				if (float.TryParse(text, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out var result2))
				{
					return new ValueBase(result2, ValueMode.Abs);
				}
				throw new JsonException("Cannot parse ValueBase string: " + text + "! Are you sure it's in right format?");
			}
			default:
				throw new JsonException($"ValueBaseJson type: {reader.TokenType} is not implemented!");
			}
		}

		public override void Write(Utf8JsonWriter writer, ValueBase value, JsonSerializerOptions options)
		{
			switch (value.Mode)
			{
			case ValueMode.Rel:
			{
				if (Mathf.Approximately(value.Value, 1f))
				{
					writer.WriteStringValue("Unchanged");
					break;
				}
				string format = (value.FromDefault ? "{0}% of default" : "{0}%");
				writer.WriteStringValue(string.Format(format, value.Value * 100f));
				break;
			}
			case ValueMode.Abs:
				writer.WriteStringValue(value.Value.ToString());
				break;
			}
			writer.WriteCommentValue("ValueBase");
		}
	}
}
namespace AmorLib.Utils.Extensions
{
	public static class CollectionExtensions
	{
		public static TValue GetOrAddNew<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key) where TValue : new()
		{
			if (!dict.TryGetValue(key, out TValue value))
			{
				value = (dict[key] = new TValue());
			}
			return value;
		}

		public static void ForEachValue<TKey, TValue>(this IDictionary<TKey, TValue> dict, Action<TValue> action) where TKey : notnull
		{
			foreach (TValue value in dict.Values)
			{
				action(value);
			}
		}

		public static bool AnyAllValues<TKey, TCollection, TValue>(this IDictionary<TKey, TCollection> dict, Func<TValue, bool> predicate) where TCollection : IEnumerable<TValue>
		{
			foreach (TCollection value in dict.Values)
			{
				if (value.Any(predicate))
				{
					return true;
				}
			}
			return false;
		}

		public static TValue? FirstOrDefaultAllValues<TKey, TCollection, TValue>(this IDictionary<TKey, TCollection> dict, Func<TValue, bool> predicate) where TCollection : IEnumerable<TValue>
		{
			foreach (TCollection value in dict.Values)
			{
				foreach (TValue item in value)
				{
					if (predicate(item))
					{
						return item;
					}
				}
			}
			return default(TValue);
		}
	}
	public static class GameObjectPlusExtensions
	{
		public static bool TryAndGetComponent<T>(this GameObject go, out T component)
		{
			component = go.GetComponent<T>();
			return component != null;
		}

		public static T AddOrGetComponent<T>(this GameObject go) where T : Component
		{
			if (!go.TryAndGetComponent<T>(out var component))
			{
				return go.AddComponent<T>();
			}
			return component;
		}

		public static string GetFullPath(this GameObject go)
		{
			StringBuilder stringBuilder = new StringBuilder(((Object)go).name);
			Transform parent = go.transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				stringBuilder.Insert(0, ((Object)parent).name + "/");
				parent = parent.parent;
			}
			return stringBuilder.ToString();
		}

		public static GameObject ClonePrefabSpawners(this GameObject original, Vector3 position, Quaternion rotation, Transform parent)
		{
			//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_002e: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(original, position, rotation, parent);
			foreach (LG_PrefabSpawner componentsInChild in val.GetComponentsInChildren<LG_PrefabSpawner>())
			{
				try
				{
					GameObject val2 = Object.Instantiate<GameObject>(componentsInChild.m_prefab, ((Component)componentsInChild).transform.position, ((Component)componentsInChild).transform.rotation, ((Component)componentsInChild).transform.parent);
					if (componentsInChild.m_disableCollision)
					{
						foreach (Collider componentsInChild2 in val2.GetComponentsInChildren<Collider>())
						{
							componentsInChild2.enabled = false;
						}
					}
					if (componentsInChild.m_applyScale)
					{
						val2.transform.localScale = ((Component)componentsInChild).transform.localScale;
					}
					val2.transform.SetParent(((Component)componentsInChild).transform);
				}
				catch
				{
				}
			}
			return val;
		}

		public static uint PostWithCleanup(this CellSoundPlayer soundPlayer, uint eventID, Vector3 pos, uint in_uFlags = 1u)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return soundPlayer.Post(eventID, pos, in_uFlags, EventCallback.op_Implicit((Action<Object, AkCallbackType, AkCallbackInfo>)SoundDoneCallback), (Object)(object)soundPlayer);
		}

		private static void SoundDoneCallback(Object in_pCookie, AkCallbackType in_type, AkCallbackInfo callbackInfo)
		{
			CellSoundPlayer obj = ((Il2CppObjectBase)in_pCookie).Cast<CellSoundPlayer>();
			if (obj != null)
			{
				obj.Recycle();
			}
		}

		public static bool IsWithinSqrDistance(this Vector3 a, Vector3 b, float sqrThreshold, out float sqrDistance)
		{
			//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_0003: 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)
			Vector3 val = a - b;
			sqrDistance = ((Vector3)(ref val)).sqrMagnitude;
			return sqrDistance <= sqrThreshold;
		}

		public static bool IsWithinSqrDistance(this Vector3 a, Vector3 b, float sqrThreshold)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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)
			Vector3 val = a - b;
			return ((Vector3)(ref val)).sqrMagnitude <= sqrThreshold;
		}
	}
	public static class PluginInfoExtensions
	{
		public static bool VersionEquals(this PluginInfo pluginInfo, string verison)
		{
			int? num = CompareVersion(pluginInfo, verison);
			if (num.HasValue)
			{
				return num.GetValueOrDefault() == 0;
			}
			return false;
		}

		public static bool VersionExceeds(this PluginInfo pluginInfo, string version)
		{
			int? num = CompareVersion(pluginInfo, version);
			if (num.HasValue)
			{
				return num.GetValueOrDefault() > 0;
			}
			return false;
		}

		public static bool VersionAtLeast(this PluginInfo pluginInfo, string version)
		{
			int? num = CompareVersion(pluginInfo, version);
			if (num.HasValue)
			{
				return num.GetValueOrDefault() >= 0;
			}
			return false;
		}

		private static int? CompareVersion(PluginInfo pluginInfo, string verison)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			object obj;
			if (pluginInfo == null)
			{
				obj = null;
			}
			else
			{
				BepInPlugin metadata = pluginInfo.Metadata;
				obj = ((metadata != null) ? metadata.Version : null);
			}
			if ((Version)obj == (Version)null)
			{
				Logger.Error("PluginInfo or Version.Metadata is null");
				return null;
			}
			Match match = Regex.Match(verison, "^(\\d+)\\.(\\d+)\\.(\\d+)$");
			if (!match.Success)
			{
				Logger.Error("Version string format is incorrect");
				return null;
			}
			int num = int.Parse(match.Groups[1].Value);
			int num2 = int.Parse(match.Groups[2].Value);
			int num3 = int.Parse(match.Groups[3].Value);
			return pluginInfo.Metadata.Version.CompareTo(new Version(num, num2, num3, (string)null, (string)null));
		}
	}
	public static class StringExtensions
	{
		public static bool EqualsAny(this string input, bool ignoreCase = false, params string[] args)
		{
			StringComparison comparisonType = (ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
			foreach (string value in args)
			{
				if (input.Equals(value, comparisonType))
				{
					return true;
				}
			}
			return false;
		}

		public static LocaleText ToLocaleText(this string input)
		{
			return new LocaleText(input);
		}
	}
}
namespace AmorLib.Patches.SNet
{
	[HarmonyPatch(typeof(CheckpointManager), "OnStateChange")]
	internal static class Patch_CheckpointState
	{
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		public static void Post_CheckpointStateChange(pCheckpointState newState)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)newState.lastInteraction == 2)
			{
				SNetEvents.CheckpointReloaded();
			}
		}
	}
	[HarmonyPatch(typeof(SNet_SyncManager), "OnRecallDone")]
	internal static class Patch_OnRecallDone
	{
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Post_RecallDone()
		{
			SNetEvents.RecallDone();
		}
	}
	[HarmonyPatch(typeof(SNet_Capture))]
	internal static class Patch_SNet_Capture
	{
		[HarmonyPatch("TriggerCapture")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void Pre_TriggerCapture(SNet_Capture __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SNetEvents.BufferCaptured(__instance.PrimedBufferType);
		}

		[HarmonyPatch("RecallBuffer")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Post_RecallBuffer(SNet_Capture __instance, eBufferType bufferType)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.IsRecalling)
			{
				SNetEvents.BufferRecalled(bufferType);
			}
		}
	}
}
namespace AmorLib.Patches.LevelGen
{
	[HarmonyPatch]
	internal static class BuilderPatches
	{
		[HarmonyPatch(typeof(Builder), "BuildDone")]
		[HarmonyPostfix]
		[HarmonyBefore(new string[] { "dev.gtfomodding.gtfo-api" })]
		[HarmonyWrapSafe]
		private static void BuildDone_Early()
		{
			LevelEvents.BuildDoneEarly();
		}

		[HarmonyPatch(typeof(Builder), "BuildDone")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "dev.gtfomodding.gtfo-api" })]
		[HarmonyWrapSafe]
		private static void BuildDone_Late()
		{
			LevelEvents.BuildDoneLate();
		}
	}
	[HarmonyPatch(typeof(LG_BuildZoneLightsJob), "Build")]
	internal static class LightsPatches
	{
		[HarmonyPrefix]
		[HarmonyPriority(600)]
		[HarmonyWrapSafe]
		private static void Pre_ZoneBuild(LG_BuildZoneLightsJob __instance, out List<LightWorker>? __state)
		{
			LG_Zone zone = __instance.m_zone;
			if ((Object)(object)zone == (Object)null)
			{
				__state = null;
				return;
			}
			__state = new List<LightWorker>();
			Enumerator<AIG_CourseNode> enumerator = zone.m_courseNodes.GetEnumerator();
			while (enumerator.MoveNext())
			{
				AIG_CourseNode current = enumerator.Current;
				foreach (LG_Light componentsInChild in ((Component)current.m_area).GetComponentsInChildren<LG_Light>(false))
				{
					__state.Add(new LightWorker(zone, current, componentsInChild, ((Object)componentsInChild).GetInstanceID(), componentsInChild.m_intensity));
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(600)]
		[HarmonyWrapSafe]
		private static void Post_ZoneBuild(LG_BuildZoneLightsJob __instance, bool __result, List<LightWorker>? __state)
		{
			if ((Object)(object)__instance.m_zone == (Object)null || !__result || __state == null)
			{
				return;
			}
			foreach (LightWorker item in __state)
			{
				item.Setup();
				LightAPI.AllLightsMap.TryAdd(item.InstanceID, item);
			}
		}
	}
	[HarmonyPatch]
	internal static class TerminalPatches
	{
		private static readonly Dictionary<(int, int, int), LG_ComputerTerminal> ReactorTerminals;

		static TerminalPatches()
		{
			ReactorTerminals = new Dictionary<(int, int, int), LG_ComputerTerminal>();
			LevelAPI.OnAfterBuildBatch += OnAfterBatchBuild;
			LevelAPI.OnLevelCleanup += OnLevelCleanup;
		}

		private static void OnAfterBatchBuild(BatchName batch)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)batch != 47)
			{
				return;
			}
			foreach (KeyValuePair<(int, int, int), LG_ComputerTerminal> kvp in ReactorTerminals)
			{
				if (kvp.Key.TryGetZone(out LG_Zone zone) && !ListExtensions.ToManaged<LG_ComputerTerminal>(zone.TerminalsSpawnedInZone).Any((LG_ComputerTerminal term) => term.SyncID == kvp.Value.SyncID))
				{
					zone.TerminalsSpawnedInZone.Add(kvp.Value);
					Logger.Debug("Appended reactor terminal to its TerminalsSpawnedInZone");
				}
			}
		}

		private static void OnLevelCleanup()
		{
			ReactorTerminals.Clear();
		}

		[HarmonyPatch(typeof(LG_ComputerTerminalCommandInterpreter), "ReceiveCommand")]
		[HarmonyPrefix]
		[HarmonyPriority(700)]
		[HarmonyWrapSafe]
		private static void HiddenCommandExecutionFix(LG_ComputerTerminalCommandInterpreter __instance, ref TERM_Command cmd)
		{
			//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_0013: Invalid comparison between Unknown and I4
			//IL_0020: 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_0025: Invalid comparison between Unknown and I4
			//IL_0015: 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_002a: Invalid comparison between Unknown and I4
			//IL_0018: 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_001c: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			if (((Il2CppArrayBase<TERM_Command>)(object)LG_ComputerTerminalCommandInterpreter.m_alwaysHiddenCommands).Contains(cmd))
			{
				return;
			}
			TERM_Command val = cmd;
			if ((int)val <= 6)
			{
				if ((int)val == 0 || val - 5 <= 1)
				{
					return;
				}
			}
			else if (val - 10 <= 1 || (int)val == 16 || (int)val == 31)
			{
				return;
			}
			if (__instance.m_terminal.CommandIsHidden(cmd))
			{
				cmd = (TERM_Command)10;
			}
		}

		[HarmonyPatch(typeof(LG_WardenObjective_Reactor), "Start")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void CustomReactorTerminalFix(LG_WardenObjective_Reactor __instance)
		{
			if (!((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("FlowGeos") && !((Object)(object)__instance.m_terminalPrefab != (Object)null))
			{
				Logger.Info("Resolving terminal prefab for reactor");
				GameObject loadedAsset = AssetAPI.GetLoadedAsset<GameObject>("Assets/AssetPrefabs/Complex/Generic/FunctionMarkers/Terminal_Floor.prefab");
				if ((Object)(object)loadedAsset == (Object)null)
				{
					Logger.Error("Failed to find terminal prefab loaded asset?");
				}
				else
				{
					__instance.m_terminalPrefab = loadedAsset;
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static bool ReactorTerminalSpawnNodeFix(LG_ComputerTerminal __instance, ref AIG_CourseNode __result)
		{
			if ((Object)(object)__instance.ConnectedReactor != (Object)null && __instance.m_terminalItem.SpawnNode == null)
			{
				__result = __instance.ConnectedReactor.SpawnNode;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(LG_WardenObjective_Reactor), "GenericObjectiveSetup")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void ReactorTerminalInZoneFix(LG_WardenObjective_Reactor __instance)
		{
			if (__instance.SpawnNode.m_zone.TerminalsSpawnedInZone != null && (Object)(object)__instance.m_terminal != (Object)null)
			{
				ReactorTerminals.Add(__instance.SpawnNode.m_zone.ToIntTuple(), __instance.m_terminal);
			}
		}
	}
	[HarmonyPatch]
	internal static class ZoneGraphPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void Pre_PlayerNodeSet(PlayerAgent __instance, ref AIG_CourseNode __state)
		{
			__state = ((Agent)__instance).CourseNode;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void Post_PlayerNodeSet(PlayerAgent __instance, AIG_CourseNode __state)
		{
			AIG_CourseNode courseNode = ((Agent)__instance).CourseNode;
			if (courseNode != null && __state != courseNode)
			{
				ZoneGraphUtil.Current.Internal_OnPlayerNodeChanged(__instance, __state);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void Pre_GateIsTraversable(LG_Gate __instance, ref bool __state)
		{
			__state = __instance.IsTraversable;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void Post_GateIsTraversable(LG_Gate __instance, bool __state)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if (__state != __instance.IsTraversable && (int)((LG_ZoneExpander)__instance).ExpanderStatus == 1)
			{
				ZoneGraphUtil.Current.Internal_OnDoorStateChanged(__instance, !__state);
			}
		}
	}
}
namespace AmorLib.Networking
{
	public struct LowResColor
	{
		public byte r;

		public byte g;

		public byte b;

		public byte a;

		private static Color _color = Color.black;

		public static implicit operator Color(LowResColor lowResColor)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			_color.r = (float)(int)lowResColor.r / 255f;
			_color.g = (float)(int)lowResColor.g / 255f;
			_color.b = (float)(int)lowResColor.b / 255f;
			_color.a = (float)(int)lowResColor.a / 255f;
			return _color;
		}

		public static implicit operator LowResColor(Color color)
		{
			//IL_000a: 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_0032: 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)
			LowResColor result = default(LowResColor);
			result.r = (byte)(color.r * 255f);
			result.g = (byte)(color.g * 255f);
			result.b = (byte)(color.b * 255f);
			result.a = (byte)(color.a * 255f);
			return result;
		}
	}
	public static class StateReplicatorManager
	{
		internal static readonly Dictionary<Type, HashSet<uint>> _reservedReplicators = new Dictionary<Type, HashSet<uint>>();

		public static void ReserveIDs<T>(params uint[] args)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			HashSet<uint> orAddNew = _reservedReplicators.GetOrAddNew(typeof(T));
			bool flag = default(bool);
			foreach (uint num in args)
			{
				if (orAddNew.Contains(num))
				{
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(41, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("StateReplicator ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Type>(typeof(T));
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" already has reserved ID ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(num);
					}
					Logger.Error(val);
				}
				else
				{
					orAddNew.Add(num);
				}
			}
		}

		public static void DeregisterIds<T>(params uint[] args)
		{
			if (_reservedReplicators.TryGetValue(typeof(T), out HashSet<uint> value))
			{
				foreach (uint item in args)
				{
					value.Remove(item);
				}
			}
		}
	}
	public abstract class SyncedEvent<S> where S : struct
	{
		public delegate void ReceiveHandler(S packet);

		public virtual string Prefix => string.Empty;

		public abstract string GUID { get; }

		public bool IsSetup { get; private set; }

		public string EventName { get; private set; } = string.Empty;


		public event ReceiveHandler? OnReceive;

		public event ReceiveHandler? OnReceiveLocal;

		public void Setup()
		{
			if (!IsSetup)
			{
				EventName = (Utility.IsNullOrWhiteSpace(Prefix) ? ("SE-" + GUID) : ("SE-" + Prefix + "-" + GUID));
				NetworkAPI.RegisterEvent<S>(EventName, (Action<ulong, S>)ReceiveClient_Callback);
				IsSetup = true;
			}
		}

		public void Send(S packetData, SNet_Player? target = null, SNet_ChannelType priority = 4)
		{
			//IL_0020: 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)
			if ((Object)(object)target != (Object)null)
			{
				NetworkAPI.InvokeEvent<S>(EventName, packetData, target, priority);
			}
			else
			{
				NetworkAPI.InvokeEvent<S>(EventName, packetData, priority);
			}
			ReceiveLocal_Callback(packetData);
		}

		private void ReceiveLocal_Callback(S packet)
		{
			ReceiveLocal(packet);
			this.OnReceiveLocal?.Invoke(packet);
		}

		private void ReceiveClient_Callback(ulong sender, S packet)
		{
			Receive(packet);
			this.OnReceive?.Invoke(packet);
		}

		protected virtual void ReceiveLocal(S packet)
		{
		}

		protected virtual void Receive(S packet)
		{
		}
	}
	public abstract class SyncedEventMasterOnly<S> : SyncedEvent<S> where S : struct
	{
		public void Send(S packet, SNet_ChannelType priority = 4)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!SNet.IsMaster)
			{
				Send(packet, SNet.Master, priority);
			}
			else
			{
				Receive(packet);
			}
		}
	}
}
namespace AmorLib.Networking.StateReplicators
{
	public interface IStateReplicatorHolder<S> where S : struct
	{
		StateReplicator<S>? Replicator { get; }

		void OnStateChange(S oldState, S state, bool isRecall);
	}
	public struct Packet
	{
		public uint replicatorID;

		public PacketAction action;
	}
	public enum PacketAction : byte
	{
		Created,
		Destroyed,
		SyncRequest
	}
	internal sealed class ReplicatorHandshake
	{
		public delegate void ClientRequestedSyncDel(SNet_Player requestedPlayer);

		private readonly Dictionary<uint, (bool SetupOnHost, bool SetupOnClient)> _lookup = new Dictionary<uint, (bool, bool)>();

		public string EventName { get; private set; }

		public bool IsReadyToSync { get; private set; }

		public event ClientRequestedSyncDel? OnClientSyncRequested;

		public ReplicatorHandshake(string eventName)
		{
			EventName = eventName;
			NetworkAPI.RegisterEvent<Packet>(EventName, (Action<ulong, Packet>)OnSyncAction);
			SNetEvents.OnRecallDone += OnRecallDone;
		}

		private void OnRecallDone()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			bool flag = default(bool);
			BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(42, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Handshake :: ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(EventName);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", Client sending sync request");
			}
			Logger.Warn(val);
			ClientSyncRequest();
		}

		private void ClientSyncRequest()
		{
			if (SNet.IsMaster)
			{
				return;
			}
			foreach (uint key in _lookup.Keys)
			{
				NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
				{
					replicatorID = key,
					action = PacketAction.SyncRequest
				}, SNet.Master, (SNet_ChannelType)2);
			}
		}

		public void Reset()
		{
			_lookup.Clear();
		}

		private void OnSyncAction(ulong sender, Packet packet)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			if (!SNet.IsMaster && sender == SNet.Master.Lookup)
			{
				if (packet.action != PacketAction.SyncRequest)
				{
					SetHostState(packet.replicatorID, packet.action == PacketAction.Created);
				}
				else
				{
					Logger.Warn("Handshake :: OnSyncAction host sync request has no implementation");
				}
			}
			else
			{
				if (!SNet.IsMaster)
				{
					return;
				}
				bool flag = default(bool);
				switch (packet.action)
				{
				case PacketAction.Created:
					SetClientState(packet.replicatorID, isSetup: true);
					break;
				case PacketAction.Destroyed:
					SetClientState(packet.replicatorID, isSetup: false);
					break;
				case PacketAction.SyncRequest:
				{
					SNet_Player requestedPlayer = default(SNet_Player);
					if (!SNet.TryGetPlayer(sender, ref requestedPlayer))
					{
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(45, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Handshake :: Cannot find player from sender: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(sender);
						}
						Logger.Error(val);
					}
					else
					{
						this.OnClientSyncRequested?.Invoke(requestedPlayer);
					}
					break;
				}
				default:
				{
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Handshake :: Unknown packet action ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<PacketAction>(packet.action);
					}
					Logger.Error(val);
					break;
				}
				}
			}
		}

		public void UpdateCreated(uint id)
		{
			if (SNet.IsInLobby)
			{
				if (SNet.IsMaster)
				{
					SetHostState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Created
					}, (SNet_ChannelType)2);
				}
				else if (SNet.HasMaster)
				{
					SetClientState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Created
					}, SNet.Master, (SNet_ChannelType)2);
				}
				else
				{
					Logger.Error("Handshake :: MASTER is NULL in lobby; this should NOT happen!!");
				}
			}
			else
			{
				Logger.Error("Handshake :: Session LifeTimeType StateReplicator cannot be created without lobby!");
			}
		}

		public void UpdateDestroyed(uint id)
		{
			if (SNet.IsInLobby)
			{
				if (SNet.IsMaster)
				{
					SetHostState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Destroyed
					}, (SNet_ChannelType)2);
				}
				else if (SNet.HasMaster)
				{
					SetClientState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Destroyed
					}, SNet.Master, (SNet_ChannelType)2);
				}
				else
				{
					Logger.Error("Handshake :: MASTER is NULL in lobby; this should NOT happen!!");
				}
			}
			else
			{
				Logger.Error("Handshake :: Session LifeTimeType StateReplicator cannot be created without lobby!");
			}
		}

		private void SetHostState(uint id, bool isSetup)
		{
			if (_lookup.TryGetValue(id, out (bool, bool) value))
			{
				value.Item1 = isSetup;
			}
			else
			{
				_lookup[id] = new(bool, bool)
				{
					Item1 = isSetup
				};
			}
			UpdateSyncState(id);
		}

		private void SetClientState(uint id, bool isSetup)
		{
			if (_lookup.TryGetValue(id, out (bool, bool) value))
			{
				value.Item2 = isSetup;
			}
			else
			{
				_lookup[id] = new(bool, bool)
				{
					Item2 = isSetup
				};
			}
			UpdateSyncState(id);
		}

		private void UpdateSyncState(uint id)
		{
			bool isReadyToSync = IsReadyToSync;
			IsReadyToSync = _lookup.TryGetValue(id, out (bool, bool) value) && value.Item1 && value.Item2;
			if (IsReadyToSync && IsReadyToSync != isReadyToSync && SNet.HasMaster && !SNet.IsMaster)
			{
				NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
				{
					replicatorID = id,
					action = PacketAction.SyncRequest
				}, SNet.Master, (SNet_ChannelType)2);
			}
		}
	}
	public enum Size
	{
		State4Byte = 4,
		State8Byte = 8,
		State16Byte = 16,
		State32Byte = 32,
		State48Byte = 48,
		State64Byte = 64,
		State80Byte = 80,
		State96Byte = 96,
		State128Byte = 128,
		State196Byte = 196,
		State256Byte = 256
	}
	internal delegate void OnReceiveDel<S>(ulong sender, uint replicatorID, S newState) where S : struct;
	internal interface IReplicatorEvent<S>
	{
		string EventName { get; }

		bool IsRegistered { get; }

		void Invoke(uint replicatorID, S data, SNet_Player? target = null, SNet_ChannelType priority = 2);
	}
	internal interface IStatePayload
	{
		uint ID { get; set; }

		S Get<S>(Size size) where S : struct;

		void Set<S>(S stateData, Size size) where S : struct;
	}
	internal class ReplicatorPayload<S, P> : IReplicatorEvent<S> where S : struct where P : struct, IStatePayload
	{
		private readonly Size _payloadSize;

		public string EventName { get; private set; } = string.Empty;


		public bool IsRegistered => NetworkAPI.IsEventRegistered(EventName);

		public ReplicatorPayload(Size size, string eventName, OnReceiveDel<S> onReceiveCallback)
		{
			OnReceiveDel<S> onReceiveCallback2 = onReceiveCallback;
			base..ctor();
			ReplicatorPayload<S, P> replicatorPayload = this;
			NetworkAPI.RegisterEvent<P>(eventName, (Action<ulong, P>)delegate(ulong sender, P payload)
			{
				onReceiveCallback2?.Invoke(sender, payload.ID, payload.Get<S>(replicatorPayload._payloadSize));
			});
			EventName = eventName;
			_payloadSize = size;
		}

		public void Invoke(uint replicatorID, S data, SNet_Player? target, SNet_ChannelType priority)
		{
			//IL_004a: 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)
			P val = new P
			{
				ID = replicatorID
			};
			val.Set(data, _payloadSize);
			if ((Object)(object)target != (Object)null)
			{
				NetworkAPI.InvokeEvent<P>(EventName, val, target, priority);
			}
			else
			{
				NetworkAPI.InvokeEvent<P>(EventName, val, priority);
			}
		}
	}
	internal struct StatePayloadBytes : IStatePayload
	{
		public unsafe fixed byte PayloadBytes[256];

		public uint ID { get; set; }

		public unsafe S Get<S>(Size size) where S : struct
		{
			byte[] array = new byte[(int)size];
			fixed (byte* ptr = PayloadBytes)
			{
				Marshal.Copy((IntPtr)ptr, array, 0, (int)size);
			}
			return FromBytes<S>(array);
		}

		public unsafe void Set<S>(S stateData, Size size) where S : struct
		{
			byte[] array = ToBytes(stateData);
			if (array.Length > (int)size)
			{
				throw new ArgumentException($"Data size {array.Length} exceeds payload size {size}, unable to serialize {"S"}!");
			}
			fixed (byte* ptr = PayloadBytes)
			{
				Marshal.Copy(array, 0, (IntPtr)ptr, array.Length);
				for (int i = array.Length; i < (int)size; i++)
				{
					ptr[i] = 0;
				}
			}
		}

		private static byte[] ToBytes<S>(S data) where S : struct
		{
			int num = Marshal.SizeOf<S>();
			byte[] array = new byte[num];
			IntPtr intPtr = Marshal.AllocHGlobal(num);
			try
			{
				Marshal.StructureToPtr(data, intPtr, fDeleteOld: false);
				Marshal.Copy(intPtr, array, 0, num);
				return array;
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		private static S FromBytes<S>(byte[] arr) where S : struct
		{
			IntPtr intPtr = Marshal.AllocHGlobal(arr.Length);
			try
			{
				Marshal.Copy(arr, 0, intPtr, arr.Length);
				return Marshal.PtrToStructure<S>(intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}
	}
	public enum LifeTimeType
	{
		Permanent,
		Session
	}
	public sealed class StateReplicator<S> where S : struct
	{
		internal readonly Dictionary<eBufferType, S> _recallStateSnapshots = new Dictionary<eBufferType, S>();

		public static readonly string Name;

		public static readonly string HashName;

		public static readonly string ClientRequestEventName;

		public static readonly string HostSetStateEventName;

		public static readonly string HostSetRecallStateEventName;

		public static readonly string HandshakeEventName;

		public static readonly int StateSize;

		public static readonly Size StateSizeType;

		private static readonly IReplicatorEvent<S>? _clientRequestEvent;

		private static readonly IReplicatorEvent<S>? _hostSetStateEvent;

		private static readonly IReplicatorEvent<S>? _hostSetRecallStateEvent;

		private static readonly ReplicatorHandshake? _handshake;

		internal static readonly Dictionary<uint, StateReplicator<S>> _replicators;

		public bool IsValid => ID != 0;

		public bool IsInvalid => ID == 0;

		public uint ID { get; private set; }

		public LifeTimeType LifeTime { get; private set; }

		public IStateReplicatorHolder<S>? Holder { get; private set; }

		public S State { get; private set; }

		public S LastState { get; private set; }

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


		public bool CanSendToClient
		{
			get
			{
				if (SNet.IsInLobby)
				{
					return SNet.IsMaster;
				}
				return false;
			}
		}

		public bool CanSendToHost
		{
			get
			{
				if (SNet.IsInLobby && !SNet.IsMaster && SNet.HasMaster)
				{
					return ClientSendStateAllowed;
				}
				return false;
			}
		}

		public event Action<S, S, bool>? OnStateChanged;

		public void SetState(S state)
		{
			if (!IsInvalid)
			{
				DoSync(state);
			}
		}

		public void SetStateUnsynced(S state)
		{
			if (!IsInvalid)
			{
				LastState = state;
				State = state;
			}
		}

		public void Unload()
		{
			if (IsValid)
			{
				_replicators.Remove(ID);
				_recallStateSnapshots.Clear();
				_handshake?.UpdateDestroyed(ID);
				ID = 0u;
			}
		}

		private void DoSync(S newState)
		{
			if (IsValid)
			{
				if (CanSendToClient)
				{
					_hostSetStateEvent?.Invoke(ID, newState, null, (SNet_ChannelType)2);
					Internal_ChangeState(newState, isRecall: false);
				}
				else if (CanSendToHost)
				{
					_clientRequestEvent?.Invoke(ID, newState, SNet.Master, (SNet_ChannelType)2);
				}
			}
		}

		private void Internal_ChangeState(S state, bool isRecall)
		{
			if (!IsInvalid)
			{
				S state2 = State;
				State = state;
				LastState = state2;
				this.OnStateChanged?.Invoke(state2, state, isRecall);
				Holder?.OnStateChange(state2, state, isRecall);
			}
		}

		private void SendDropInState(SNet_Player target)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (IsInvalid || (Object)(object)target == (Object)null)
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("IsInvalid: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(IsInvalid);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("SendDropInState");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" :: Target was null? ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>((Object)(object)target == (Object)null);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("?");
				}
				Logger.Error(val);
			}
			else
			{
				_hostSetRecallStateEvent?.Invoke(ID, State, target, (SNet_ChannelType)2);
			}
		}

		public void ClearAllRecallSnapshot()
		{
			if (!IsInvalid)
			{
				_recallStateSnapshots.Clear();
			}
		}

		private void SaveSnapshot(eBufferType type)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInvalid)
			{
				_recallStateSnapshots[type] = State;
			}
		}

		private void RestoreSnapshot(eBufferType type)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!IsValid || !CanSendToClient)
			{
				return;
			}
			if (_recallStateSnapshots.TryGetValue(type, out var value))
			{
				_hostSetRecallStateEvent?.Invoke(ID, value, null, (SNet_ChannelType)2);
				Internal_ChangeState(value, isRecall: true);
				return;
			}
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(31, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RestoreSnapshot");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" :: There was no snapshot for ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eBufferType>(type);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("?");
			}
			Logger.Error(val);
		}

		static StateReplicator()
		{
			_replicators = new Dictionary<uint, StateReplicator<S>>();
			Name = typeof(S).Name;
			StateSize = Marshal.SizeOf(typeof(S));
			StateSizeType = GetSizeType(StateSize);
			using MD5 mD = MD5.Create();
			HashName = Convert.ToBase64String(mD.ComputeHash(Encoding.UTF8.GetBytes(typeof(S).FullName)));
			ClientRequestEventName = "SRcr-" + Name + "-" + HashName;
			HostSetStateEventName = "SRhs-" + Name + "-" + HashName;
			HostSetRecallStateEventName = "SRre-" + Name + "-" + HashName;
			HandshakeEventName = "RH-" + Name + "-" + HashName;
			_clientRequestEvent = CreatePayloadEvent(ClientRequestEventName, ClientRequestEventCallback);
			_hostSetStateEvent = CreatePayloadEvent(HostSetStateEventName, HostSetStateEventCallback);
			_hostSetRecallStateEvent = CreatePayloadEvent(HostSetRecallStateEventName, HostSetRecallStateEventCallback);
			_handshake = CreateHandshakeEvent();
			SNetEvents.OnBufferCapture += BufferStored;
			SNetEvents.OnBufferRecall += BufferRecalled;
			LevelAPI.OnLevelCleanup += OnLevelCleanup;
		}

		public static StateReplicator<S>? Create(uint replicatorID, S startState, LifeTimeType lifeTime, IStateReplicatorHolder<S>? holder = null)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			if (replicatorID == 0)
			{
				Logger.Error("Replicator ID 0 is reserved for empty!");
				return null;
			}
			if (_replicators.ContainsKey(replicatorID))
			{
				Logger.Error("Replicator ID has already assigned!");
				return null;
			}
			StateReplicator<S> stateReplicator = new StateReplicator<S>
			{
				ID = replicatorID,
				LifeTime = lifeTime,
				Holder = holder,
				State = startState
			};
			switch (lifeTime)
			{
			case LifeTimeType.Permanent:
				Logger.Debug("LifeTime is Permanent :: Handshaking is disabled");
				break;
			case LifeTimeType.Session:
				_handshake?.UpdateCreated(replicatorID);
				break;
			default:
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(21, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("LifeTime ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<LifeTimeType>(lifeTime);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is invalid!");
				}
				Logger.Error(val);
				return null;
			}
			}
			_replicators[replicatorID] = stateReplicator;
			return stateReplicator;
		}

		public static Size GetSizeType(int stateSize)
		{
			Size size = Size.State8Byte;
			foreach (Size value in Enum.GetValues(typeof(Size)))
			{
				if (stateSize <= (int)value && size < value)
				{
					size = value;
					break;
				}
			}
			return size;
		}

		private static IReplicatorEvent<S>? CreatePayloadEvent(string name, OnReceiveDel<S> callback)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (NetworkAPI.IsEventRegistered(name))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(77, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ReplicatorPayload<");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(">.");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("callback");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" failed to initialize: Event name ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is already registered!");
				}
				Logger.Error(val);
				return null;
			}
			return new ReplicatorPayload<S, StatePayloadBytes>(StateSizeType, name, callback);
		}

		private static ReplicatorHandshake? CreateHandshakeEvent()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (NetworkAPI.IsEventRegistered(HandshakeEventName))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(78, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ReplicatorHandshake<");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("> failed to initialize: Event name ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(HandshakeEventName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is already registered!");
				}
				Logger.Error(val);
				return null;
			}
			ReplicatorHandshake replicatorHandshake = new ReplicatorHandshake(HandshakeEventName);
			replicatorHandshake.OnClientSyncRequested += ClientSyncRequested;
			return replicatorHandshake;
		}

		private static void ClientRequestEventCallback(ulong sender, uint replicatorID, S newState)
		{
			if (SNet.IsMaster && _replicators.TryGetValue(replicatorID, out StateReplicator<S> value))
			{
				value.SetState(newState);
			}
		}

		private static void HostSetStateEventCallback(ulong sender, uint replicatorID, S newState)
		{
			if (SNet.HasMaster && SNet.Master.Lookup == sender && _replicators.TryGetValue(replicatorID, out StateReplicator<S> value))
			{
				value.Internal_ChangeState(newState, isRecall: false);
			}
		}

		private static void HostSetRecallStateEventCallback(ulong sender, uint replicatorID, S newState)
		{
			if (SNet.HasMaster && SNet.Master.Lookup == sender && _replicators.TryGetValue(replicatorID, out StateReplicator<S> value))
			{
				value.Internal_ChangeState(newState, isRecall: true);
			}
		}

		private static void ClientSyncRequested(SNet_Player requestedPlayer)
		{
			foreach (StateReplicator<S> value in _replicators.Values)
			{
				if (value.IsValid)
				{
					value.SendDropInState(requestedPlayer);
				}
			}
		}

		private static void BufferStored(eBufferType type)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			foreach (StateReplicator<S> value in _replicators.Values)
			{
				if (value.IsValid)
				{
					value.SaveSnapshot(type);
				}
			}
		}

		private static void BufferRecalled(eBufferType type)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			foreach (StateReplicator<S> value in _replicators.Values)
			{
				if (value.IsValid)
				{
					value.RestoreSnapshot(type);
				}
			}
		}

		private static void OnLevelCleanup()
		{
			UnloadSessionReplicators();
		}

		public static void UnloadSessionReplicators()
		{
			List<uint> list = new List<uint>();
			foreach (StateReplicator<S> value in _replicators.Values)
			{
				if (value.LifeTime == LifeTimeType.Session)
				{
					list.Add(value.ID);
					value.Unload();
				}
			}
			foreach (uint item in list)
			{
				_replicators.Remove(item);
			}
			_handshake?.Reset();
		}
	}
}
namespace AmorLib.Events
{
	public static class LevelEvents
	{
		public static event Action? OnBuildDoneEarly;

		public static event Action? OnBuildDoneLate;

		internal static void BuildDoneEarly()
		{
			SafeInvoke.Invoke(LevelEvents.OnBuildDoneEarly);
		}

		internal static void BuildDoneLate()
		{
			SafeInvoke.Invoke(LevelEvents.OnBuildDoneLate);
		}
	}
	public static class SNetEvents
	{
		public static event Action<eBufferType>? OnBufferCapture;

		public static event Action<eBufferType>? OnBufferRecall;

		public static event Action? OnCheckpointReload;

		public static event Action? OnRecallDone;

		internal static void BufferCaptured(eBufferType bufferType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			SafeInvoke.Invoke<eBufferType>(SNetEvents.OnBufferCapture, bufferType);
		}

		internal static void BufferRecalled(eBufferType bufferType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			SafeInvoke.Invoke<eBufferType>(SNetEvents.OnBufferRecall, bufferType);
		}

		internal static void CheckpointReloaded()
		{
			SafeInvoke.Invoke(SNetEvents.OnCheckpointReload);
		}

		internal static void RecallDone()
		{
			SafeInvoke.Invoke(SNetEvents.OnRecallDone);
		}
	}
}
namespace AmorLib.Dependencies
{
	[CallConstructorOnLoad]
	public static class InjectLib_Wrapper
	{
		public const string PLUGIN_GUID = "GTFO.InjectLib";

		public static bool IsLoaded { get; private set; }

		public static JsonConverter? InjectLibConverter { get; private set; }

		static InjectLib_Wrapper()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("GTFO.InjectLib"))
			{
				IsLoaded = true;
				SetConverter();
			}
			bool flag = default(bool);
			BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(21, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("InjectLib is loaded: ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(IsLoaded);
			}
			Logger.Debug(val);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void SetConverter()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			InjectLibConverter = (JsonConverter?)new InjectLibConnector();
		}
	}
	[CallConstructorOnLoad]
	public static class PData_Wrapper
	{
		public const string PLUGIN_GUID = "MTFO.Extension.PartialBlocks";

		public static bool IsLoaded { get; private set; }

		public static bool IsMainBranch { get; private set; }

		public static JsonConverter? PersistentIDConverter { get; private set; }

		static PData_Wrapper()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			bool flag = default(bool);
			if (((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue("MTFO.Extension.PartialBlocks", out var value))
			{
				try
				{
					IsMainBranch = value.VersionAtLeast("1.5.2");
					Type type = AccessTools.TypeByName("MTFO.Ext.PartialData.JsonConverters.PersistentIDConverter");
					if (type != null && typeof(JsonConverter).IsAssignableFrom(type))
					{
						PersistentIDConverter = (JsonConverter)Activator.CreateInstance(type);
						IsLoaded = PersistentIDConverter != null;
					}
				}
				catch (Exception ex)
				{
					IsLoaded = false;
					IsMainBranch = false;
					PersistentIDConverter = null;
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(54, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Exception thrown while reading data from PartialData:\n");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
					}
					Logger.Error(val);
				}
			}
			BepInExDebugLogInterpolatedStringHandler val2 = new BepInExDebugLogInterpolatedStringHandler(57, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("PartialData is loaded: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<bool>(IsLoaded);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", Version >= 1.5.2 (main branch): ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<bool>(IsMainBranch);
			}
			Logger.Debug(val2);
			if (IsLoaded && !IsMainBranch)
			{
				Logger.Warn("AWOPartialDataFixer (PartialDataModCompatible) is deprecated, or older version! It will still work but it's recommended to switch to the main branch of PartialData");
			}
		}

		public static bool TryGetGUID(string text, out uint guid)
		{
			if (IsLoaded && IsMainBranch)
			{
				guid = GetGUID(text);
				return guid != 0;
			}
			guid = 0u;
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static uint GetGUID(string text)
		{
			uint result = default(uint);
			if (PersistentIDManager.TryGetId(text, ref result))
			{
				return result;
			}
			return 0u;
		}
	}
}
namespace AmorLib.API
{
	public interface ILightModifier
	{
		Color Color { get; set; }

		float Intensity { get; set; }

		bool Enabled { get; set; }

		int Priority { get; }

		bool Active { get; }

		void Set(Color color, float intensity, bool enabled)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Color = color;
			Intensity = intensity;
			Enabled = enabled;
		}

		bool Register();

		void Remove();
	}
	[CallConstructorOnLoad]
	public static class LightAPI
	{
		internal static readonly ConcurrentDictionary<int, LightWorker> AllLightsMap;

		static LightAPI()
		{
			AllLightsMap = new ConcurrentDictionary<int, LightWorker>();
			LevelAPI.OnAfterBuildBatch += OnAfterZoneLightsBatch;
			LevelAPI.OnLevelCleanup += OnLevelCleanup;
		}

		private static void OnLevelCleanup()
		{
			AllLightsMap.Clear();
		}

		private static void OnAfterZoneLightsBatch(BatchName batch)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((int)batch == 61)
			{
				bool flag = default(bool);
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(35, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("All LightWorkers are setup. Count: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(AllLightsMap.Count);
				}
				Logger.Debug(val);
			}
		}

		public static LightWorker? GetSpecificLightWorker(int instanceID)
		{
			if (!TryGetSpecificLightWorker(instanceID, out LightWorker worker))
			{
				return null;
			}
			return worker;
		}

		public static bool TryGetSpecificLightWorker(int instanceID, [NotNullWhen(true)] out LightWorker? worker)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			if (!AllLightsMap.TryGetValue(instanceID, out worker))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(65, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find LightWorker: no LG_Light exists with instance id ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(instanceID);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("!");
				}
				Logger.Error(val);
				return false;
			}
			return true;
		}

		public static void ForEachWorker(this IEnumerable<LightWorker> lightWorkers, Action<LightWorker> action)
		{
			foreach (LightWorker lightWorker in lightWorkers)
			{
				action(lightWorker);
			}
		}

		public static IEnumerable<ILightModifier> AddLightModifiers(this IEnumerable<LightWorker> lightWorkers, Color color, float intensity, bool enabled, int priority = 1000)
		{
			//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)
			return lightWorkers.Select((LightWorker worker) => worker.AddModifier(color, intensity, enabled, priority));
		}

		public static void ForEachMod(this IEnumerable<ILightModifier> lightModifiers, Action<ILightModifier> action)
		{
			foreac

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

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using AIGraph;
using AssetShards;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Hook;
using BepInEx.Unity.IL2CPP.Utils;
using GTFO.API.Attributes;
using GTFO.API.Components;
using GTFO.API.Extensions;
using GTFO.API.Impl;
using GTFO.API.JSON;
using GTFO.API.JSON.Converters;
using GTFO.API.Native;
using GTFO.API.Resources;
using GTFO.API.Utilities;
using GTFO.API.Utilities.Impl;
using GTFO.API.Wrappers;
using GameData;
using Gear;
using Globals;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppInterop.Runtime.Runtime;
using Il2CppInterop.Runtime.Runtime.VersionSpecific.Class;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using ItemSetup;
using LevelGeneration;
using Localization;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using UnityEngine;
using UnityEngine.Analytics;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("GTFO-API")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.0")]
[assembly: AssemblyInformationalVersion("0.5.0+gitcd77914-main.cd77914af9eee3a5d9106a4128c5fa3bc02d7ec0")]
[assembly: AssemblyProduct("GTFO-API")]
[assembly: AssemblyTitle("GTFO-API")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.0.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;
		}
	}
}
namespace GTFO.API
{
	internal static class APILogger
	{
		private static readonly ManualLogSource _logger;

		static APILogger()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			_logger = new ManualLogSource("GTFO-API");
			Logger.Sources.Add((ILogSource)(object)_logger);
		}

		private static string Format(string module, object msg)
		{
			return $"[{module}]: {msg}";
		}

		public static void Info(string module, object data)
		{
			_logger.LogMessage((object)Format(module, data));
		}

		public static void Verbose(string module, object data)
		{
		}

		public static void Debug(string module, object data)
		{
			_logger.LogDebug((object)Format(module, data));
		}

		public static void Warn(string module, object data)
		{
			_logger.LogWarning((object)Format(module, data));
		}

		public static void Error(string module, object data)
		{
			_logger.LogError((object)Format(module, data));
		}
	}
	[API("Asset")]
	public static class AssetAPI
	{
		internal static ConcurrentDictionary<string, Object> s_RegistryCache = new ConcurrentDictionary<string, Object>();

		public static ApiStatusInfo Status => APIStatus.Asset;

		public static event Action OnStartupAssetsLoaded;

		public static event Action OnAssetBundlesLoaded;

		public static event Action OnImplReady;

		public static bool ContainsAsset(string assetName)
		{
			string text = assetName.ToUpper();
			if (!APIStatus.Asset.Ready)
			{
				return s_RegistryCache.ContainsKey(text);
			}
			return AssetShardManager.s_loadedAssetsLookup.ContainsKey(text);
		}

		public static Object GetLoadedAsset(string path)
		{
			string text = path.ToUpper();
			APILogger.Verbose("Asset", "Requested Asset: " + text);
			try
			{
				if (!APIStatus.Asset.Ready && s_RegistryCache.TryGetValue(text, out var value))
				{
					return value;
				}
				return AssetShardManager.GetLoadedAsset(text, false);
			}
			catch
			{
				return null;
			}
		}

		public static TAsset GetLoadedAsset<TAsset>(string path) where TAsset : Object
		{
			Object loadedAsset = GetLoadedAsset(path);
			if (loadedAsset == null)
			{
				return default(TAsset);
			}
			return ((Il2CppObjectBase)loadedAsset).Cast<TAsset>();
		}

		public static void RegisterAsset(string name, Object gameObject)
		{
			string text = name.ToUpper();
			if (!APIStatus.Asset.Ready)
			{
				if (s_RegistryCache.ContainsKey(text))
				{
					throw new ArgumentException("The asset with " + text + " has already been registered.", "name");
				}
				s_RegistryCache.TryAdd(text, gameObject);
			}
			else
			{
				AssetAPI_Impl.Instance.RegisterAsset(text, gameObject);
			}
		}

		public static void RegisterAssetBundle(AssetBundle bundle)
		{
			string[] array = Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)bundle.AllAssetNames());
			APILogger.Verbose("Asset", "Bundle names: [" + string.Join(", ", array) + "]");
			string[] array2 = array;
			foreach (string text in array2)
			{
				Object val = bundle.LoadAsset(text);
				if (val != (Object)null)
				{
					RegisterAsset(text, val);
				}
				else
				{
					APILogger.Warn("Asset", "Skipping asset " + text);
				}
			}
		}

		public static void LoadAndRegisterAssetBundle(string pathToBundle)
		{
			AssetBundle obj = AssetBundle.LoadFromFile(pathToBundle);
			if ((Object)(object)obj == (Object)null)
			{
				throw new Exception("Failed to load asset bundle");
			}
			RegisterAssetBundle(obj);
		}

		public static void LoadAndRegisterAssetBundle(byte[] bundleBytes)
		{
			AssetBundle obj = AssetBundle.LoadFromMemory(Il2CppStructArray<byte>.op_Implicit(bundleBytes));
			if ((Object)(object)obj == (Object)null)
			{
				throw new Exception("Failed to load asset bundle");
			}
			RegisterAssetBundle(obj);
		}

		public static Object InstantiateAsset(string assetName, string copyName)
		{
			if (ContainsAsset(copyName))
			{
				throw new ArgumentException("The asset you're trying to copy into is already registered", "copyName");
			}
			RegisterAsset(copyName, Object.Instantiate(GetLoadedAsset(assetName) ?? throw new ArgumentException("Couldn't find an asset with the name '" + assetName + "'", "assetName")));
			return GetLoadedAsset(copyName);
		}

		public static TAsset InstantiateAsset<TAsset>(string assetName, string copyName) where TAsset : Object
		{
			Object obj = InstantiateAsset(assetName, copyName);
			if (obj == null)
			{
				return default(TAsset);
			}
			return ((Il2CppObjectBase)obj).Cast<TAsset>();
		}

		public static bool TryInstantiateAsset<TAsset>(string assetName, string copyName, out TAsset clonedObj) where TAsset : Object
		{
			Object obj = InstantiateAsset(assetName, copyName);
			clonedObj = ((obj != null) ? ((Il2CppObjectBase)obj).TryCast<TAsset>() : default(TAsset));
			return (Object)(object)clonedObj != (Object)null;
		}

		private static void OnAssetsLoaded()
		{
			if (!APIStatus.Asset.Created)
			{
				APIStatus.CreateApi<AssetAPI_Impl>("Asset");
			}
			SafeInvoke.Invoke(AssetAPI.OnStartupAssetsLoaded);
		}

		internal static void InvokeImplReady()
		{
			SafeInvoke.Invoke(AssetAPI.OnImplReady);
		}

		internal static void Setup()
		{
			EventAPI.OnAssetsLoaded += OnAssetsLoaded;
			OnImplReady += LoadAssetBundles;
		}

		private static void LoadAssetBundles()
		{
			string assetBundlesDir = Path.Combine(Paths.BepInExRootPath, "Assets", "AssetBundles");
			string assetBundlesDir2 = Path.Combine(Paths.ConfigPath, "Assets", "AssetBundles");
			if (LoadAssetBundles(assetBundlesDir) | LoadAssetBundles(assetBundlesDir2, outdated: true))
			{
				SafeInvoke.Invoke(AssetAPI.OnAssetBundlesLoaded);
			}
		}

		private static bool LoadAssetBundles(string assetBundlesDir, bool outdated = false)
		{
			if (outdated)
			{
				if (!Directory.Exists(assetBundlesDir))
				{
					return false;
				}
				APILogger.Warn("AssetAPI", "Storing asset bundles in the config path is deprecated and will be removed in a future version of GTFO-API. The path has been moved to 'BepInEx\\Assets\\AssetBundles'.");
			}
			if (!Directory.Exists(assetBundlesDir))
			{
				Directory.CreateDirectory(assetBundlesDir);
				return false;
			}
			string[] array = (from x in Directory.GetFiles(assetBundlesDir, "*", SearchOption.AllDirectories)
				where !x.EndsWith(".manifest", StringComparison.InvariantCultureIgnoreCase)
				select x).ToArray();
			if (array.Length == 0)
			{
				return false;
			}
			for (int i = 0; i < array.Length; i++)
			{
				try
				{
					LoadAndRegisterAssetBundle(array[i]);
				}
				catch (Exception ex)
				{
					APILogger.Warn("AssetAPI", $"Failed to load asset bundle '{array[i]}' ({ex.Message})");
				}
			}
			return true;
		}
	}
	[API("Event")]
	public static class EventAPI
	{
		public static ApiStatusInfo Status => APIStatus.Event;

		public static event Action OnManagersSetup;

		public static event Action OnExpeditionStarted;

		public static event Action OnAssetsLoaded;

		internal static void Setup()
		{
			Global.OnAllManagersSetup += Action.op_Implicit((Action)ManagersSetup);
			AssetShardManager.OnStartupAssetsLoaded += Action.op_Implicit((Action)AssetsLoaded);
			RundownManager.OnExpeditionGameplayStarted += Action.op_Implicit((Action)ExpeditionStarted);
		}

		private static void ManagersSetup()
		{
			SafeInvoke.Invoke(EventAPI.OnManagersSetup);
		}

		private static void ExpeditionStarted()
		{
			SafeInvoke.Invoke(EventAPI.OnExpeditionStarted);
		}

		private static void AssetsLoaded()
		{
			SafeInvoke.Invoke(EventAPI.OnAssetsLoaded);
		}
	}
	[API("GameData")]
	public class GameDataAPI
	{
		public static ApiStatusInfo Status => APIStatus.GameData;

		public static event Action OnGameDataInitialized;

		static GameDataAPI()
		{
			Status.Created = true;
			Status.Ready = true;
		}

		internal static void InvokeGameDataInit()
		{
			SafeInvoke.Invoke(GameDataAPI.OnGameDataInitialized);
		}
	}
	[API("Il2Cpp")]
	public static class Il2CppAPI
	{
		public static ApiStatusInfo Status => APIStatus.Il2Cpp;

		static Il2CppAPI()
		{
			Status.Created = true;
			Status.Ready = true;
		}

		public unsafe static void InjectWithInterface<T>() where T : Il2CppObjectBase
		{
			//IL_007e: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			List<INativeClassStruct> list = new List<INativeClassStruct>();
			foreach (Il2CppInterfaceAttribute item in GetCustomAttributesInType<T, Il2CppInterfaceAttribute>())
			{
				Il2CppClass* ptr = (Il2CppClass*)(void*)(IntPtr)typeof(Il2CppClassPointerStore<>).MakeGenericType(item.Type).GetField("NativeClassPtr").GetValue(null);
				IL2CPP.il2cpp_runtime_class_init((IntPtr)ptr);
				list.Add(UnityVersionHandler.Wrap(ptr));
			}
			RegisterTypeOptions val = new RegisterTypeOptions();
			val.set_LogSuccess(true);
			val.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(list.ToArray()));
			ClassInjector.RegisterTypeInIl2Cpp<T>(val);
		}

		public unsafe static void* GetIl2CppMethod<T>(string methodName, string returnTypeName, bool isGeneric, params string[] argTypes) where T : Il2CppObjectBase
		{
			void** ptr = (void**)IL2CPP.GetIl2CppMethod(Il2CppClassPointerStore<T>.NativeClassPtr, isGeneric, methodName, returnTypeName, argTypes).ToPointer();
			if (ptr == null)
			{
				return ptr;
			}
			return *ptr;
		}

		public unsafe static TDelegate GetIl2CppMethod<T, TDelegate>(string methodName, string returnTypeName, bool isGeneric, params string[] argTypes) where T : Il2CppObjectBase where TDelegate : Delegate
		{
			void* il2CppMethod = GetIl2CppMethod<T>(methodName, returnTypeName, isGeneric, argTypes);
			if (il2CppMethod == null)
			{
				return null;
			}
			return Marshal.GetDelegateForFunctionPointer<TDelegate>((IntPtr)il2CppMethod);
		}

		public unsafe static INativeDetour CreateGenericDetour<TClass, TDelegate>(string methodName, string returnType, string[] paramTypes, Type[] genericArguments, TDelegate to, out TDelegate original) where TClass : Object where TDelegate : Delegate
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			IntPtr nativeClassPtr = Il2CppClassPointerStore<TClass>.NativeClassPtr;
			if (nativeClassPtr == IntPtr.Zero)
			{
				throw new ArgumentException(typeof(TClass).Name + " does not exist in il2cpp domain");
			}
			return INativeDetour.CreateAndApply<TDelegate>(UnityVersionHandler.Wrap((Il2CppMethodInfo*)(void*)IL2CPP.il2cpp_method_get_from_reflection(((Il2CppObjectBase)new MethodInfo(IL2CPP.il2cpp_method_get_object(IL2CPP.GetIl2CppMethod(nativeClassPtr, true, methodName, returnType, paramTypes), nativeClassPtr)).MakeGenericMethod(((IEnumerable<Type>)genericArguments).Select((Func<Type, Type>)Il2CppType.From).ToArray())).Pointer)).MethodPointer, to, ref original);
		}

		private static IEnumerable<TAttribute> GetCustomAttributesInType<T, TAttribute>() where TAttribute : Attribute
		{
			Type attributeType = typeof(TAttribute);
			return typeof(T).GetCustomAttributes(attributeType, inherit: true).Union(typeof(T).GetInterfaces().SelectMany((Type interfaceType) => interfaceType.GetCustomAttributes(attributeType, inherit: true))).Distinct()
				.Cast<TAttribute>();
		}
	}
	[API("Interop")]
	public static class InteropAPI
	{
		private static readonly Dictionary<string, Func<object[], object>> s_CallLookup = new Dictionary<string, Func<object[], object>>();

		public static ApiStatusInfo Status => APIStatus.Interop;

		public static bool PluginExists(string pluginGUID, out PluginInfo pluginInfo)
		{
			return ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue(pluginGUID, out pluginInfo);
		}

		public static void ExecuteWhenPluginExists(string pluginGUID, Action<PluginInfo> action)
		{
			if (action != null && PluginExists(pluginGUID, out var pluginInfo))
			{
				action(pluginInfo);
			}
		}

		public static void ExecuteWhenPluginNotExists(string pluginGUID, Action action)
		{
			if (action != null && !PluginExists(pluginGUID, out var _))
			{
				action();
			}
		}

		public static void RegisterCall(string callName, Func<object[], object> callback)
		{
			Func<object[], object> value;
			if (callback == null)
			{
				APILogger.Warn("Interop", $"'{callName}' was requested to registed without valid {"callback"} parameter given! This will be ignored!");
			}
			else if (s_CallLookup.TryGetValue(callName, out value))
			{
				APILogger.Error("Interop", callName + " is already occupied by other mods!");
			}
			else
			{
				s_CallLookup[callName] = callback;
				APILogger.Verbose("Interop", callName + " has successfully registered.");
			}
		}

		public static object Call(string callName, params object[] parameters)
		{
			if (s_CallLookup.TryGetValue(callName, out var value))
			{
				return value?.Invoke(parameters) ?? null;
			}
			return null;
		}
	}
	public delegate void LevelDataUpdateEvent(ActiveExpedition activeExp, ExpeditionInTierData expData);
	public delegate void LevelSelectedEvent(eRundownTier expTier, int expIndexInTier, ExpeditionInTierData expData);
	[API("Level")]
	public static class LevelAPI
	{
		private static eRundownTier s_LatestExpTier = (eRundownTier)99;

		private static int s_LatestExpIndex = -1;

		public static ApiStatusInfo Status => APIStatus.Level;

		public static event LevelDataUpdateEvent OnLevelDataUpdated;

		public static event LevelSelectedEvent OnLevelSelected;

		public static event Action OnBuildStart;

		public static event Action OnBuildDone;

		public static event Action OnEnterLevel;

		public static event Action OnLevelCleanup;

		public static event Action OnFactoryStart;

		public static event Action OnFactoryDone;

		public static event Action<BatchName> OnBeforeBuildBatch;

		public static event Action<BatchName> OnAfterBuildBatch;

		internal static void Setup()
		{
			Status.Created = true;
			Status.Ready = true;
			EventAPI.OnExpeditionStarted += EnterLevel;
		}

		internal static void ExpeditionUpdated(pActiveExpedition activeExp, ExpeditionInTierData expData)
		{
			//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_0048: 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_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)
			ActiveExpedition activeExpData = ActiveExpedition.CreateFrom(activeExp);
			SafeInvoke.InvokeDelegate(LevelAPI.OnLevelDataUpdated, delegate(LevelDataUpdateEvent del)
			{
				del(activeExpData, expData);
			});
			eRundownTier tier = activeExp.tier;
			int index = activeExp.expeditionIndex;
			if (tier != s_LatestExpTier || index != s_LatestExpIndex)
			{
				SafeInvoke.InvokeDelegate(LevelAPI.OnLevelSelected, delegate(LevelSelectedEvent del)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					del(tier, index, expData);
				});
				s_LatestExpTier = tier;
				s_LatestExpIndex = index;
			}
		}

		internal static void BuildStart()
		{
			SafeInvoke.Invoke(LevelAPI.OnBuildStart);
		}

		internal static void BuildDone()
		{
			SafeInvoke.Invoke(LevelAPI.OnBuildDone);
		}

		internal static void EnterLevel()
		{
			SafeInvoke.Invoke(LevelAPI.OnEnterLevel);
		}

		internal static void LevelCleanup()
		{
			SafeInvoke.Invoke(LevelAPI.OnLevelCleanup);
		}

		internal static void FactoryStart()
		{
			SafeInvoke.Invoke(LevelAPI.OnFactoryStart);
		}

		internal static void FactoryFinished()
		{
			SafeInvoke.Invoke(LevelAPI.OnFactoryDone);
		}

		internal static void BeforeBuildBatch(BatchName batchName)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			SafeInvoke.Invoke(LevelAPI.OnBeforeBuildBatch, batchName);
		}

		internal static void AfterBuildBatch(BatchName batchName)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			SafeInvoke.Invoke(LevelAPI.OnAfterBuildBatch, batchName);
		}
	}
	public struct ActiveExpedition
	{
		public pPlayer player;

		public eRundownKey rundownType;

		public string rundownKey;

		public eRundownTier tier;

		public int expeditionIndex;

		public int hostIDSeed;

		public int sessionSeed;

		public static ActiveExpedition CreateFrom(pActiveExpedition pActiveExp)
		{
			ActiveExpedition result = default(ActiveExpedition);
			result.CopyFrom(pActiveExp);
			return result;
		}

		public void CopyFrom(pActiveExpedition pActiveExp)
		{
			//IL_0002: 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_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)
			//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)
			player = pActiveExp.player;
			rundownType = pActiveExp.rundownType;
			rundownKey = pActiveExp.rundownKey.data;
			tier = pActiveExp.tier;
			expeditionIndex = pActiveExp.expeditionIndex;
			hostIDSeed = pActiveExp.hostIDSeed;
			sessionSeed = pActiveExp.sessionSeed;
		}
	}
	[API("Localization")]
	public static class LocalizationAPI
	{
		private sealed class Entry
		{
			private readonly string?[] m_ValuesByLanguage = new string[12];

			private TextDBOptions m_Options;

			public uint? TextBlockId { get; private set; }

			private bool TryGetStringInAnyLanguage([NotNullWhen(true)] out string? value)
			{
				for (int i = 0; i < m_ValuesByLanguage.Length; i++)
				{
					value = m_ValuesByLanguage[i];
					if (value != null)
					{
						return true;
					}
				}
				value = null;
				return false;
			}

			private bool TryGetStringInLanguage(Language language, [NotNullWhen(true)] out string? value)
			{
				//IL_0000: 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_0004: Expected I4, but got Unknown
				int num = language - 1;
				value = m_ValuesByLanguage[num];
				return value != null;
			}

			public bool TryGetString(Language language, FallbackValueOptions options, [NotNullWhen(true)] out string? value)
			{
				//IL_0001: 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)
				if (TryGetStringInLanguage(language, out value))
				{
					return true;
				}
				if (options.UseFallbackLanguage && TryGetStringInLanguage(options.FallbackLanguage.Value, out value))
				{
					return true;
				}
				if (options.UseAnyLanguage && TryGetStringInAnyLanguage(out value))
				{
					return true;
				}
				value = null;
				return false;
			}

			private string GetStringForTextDB(Language language, string key, FallbackValueOptions options)
			{
				//IL_0001: 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)
				if (TryGetString(language, options, out string value))
				{
					return value;
				}
				ValidateUseKey(key, language, options, "GenerateTextDB");
				return key;
			}

			[MemberNotNull("TextBlockId")]
			public void GenerateTextDataBlock(string key, TextDBOptions options, bool force = false)
			{
				m_Options = options;
				GenerateTextDataBlock(key, force);
			}

			[MemberNotNull("TextBlockId")]
			public void GenerateTextDataBlock(string key, bool force = false)
			{
				//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_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_0069: 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)
				//IL_0077: 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_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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_00cd: 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_00f5: 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_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: 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_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Expected O, but got Unknown
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Expected O, but got Unknown
				//IL_018e: Expected O, but got Unknown
				if (!TextBlockId.HasValue || force)
				{
					FallbackValueOptions options = m_Options.FallbackOptions ?? FallbackValueOptions.AnyLangOrKey;
					TextDataBlock val = new TextDataBlock
					{
						CharacterMetaData = (m_Options.CharacterMetadataId ?? 1)
					};
					((GameDataBlockBase<TextDataBlock>)val).internalEnabled = true;
					val.ExportVersion = 1;
					val.ImportVersion = 1;
					val.Description = string.Empty;
					val.English = GetStringForTextDB((Language)1, key, options);
					val.French = LanguageData.op_Implicit(GetStringForTextDB((Language)2, key, options));
					val.Italian = LanguageData.op_Implicit(GetStringForTextDB((Language)3, key, options));
					val.German = LanguageData.op_Implicit(GetStringForTextDB((Language)4, key, options));
					val.Spanish = LanguageData.op_Implicit(GetStringForTextDB((Language)5, key, options));
					val.Russian = LanguageData.op_Implicit(GetStringForTextDB((Language)6, key, options));
					val.Portuguese_Brazil = LanguageData.op_Implicit(GetStringForTextDB((Language)7, key, options));
					val.Polish = LanguageData.op_Implicit(GetStringForTextDB((Language)8, key, options));
					val.Japanese = LanguageData.op_Implicit(GetStringForTextDB((Language)9, key, options));
					val.Korean = LanguageData.op_Implicit(GetStringForTextDB((Language)10, key, options));
					val.Chinese_Traditional = LanguageData.op_Implicit(GetStringForTextDB((Language)11, key, options));
					val.Chinese_Simplified = LanguageData.op_Implicit(GetStringForTextDB((Language)12, key, options));
					((GameDataBlockBase<TextDataBlock>)val).name = key;
					val.MachineTranslation = false;
					val.SkipLocalization = false;
					((GameDataBlockBase<TextDataBlock>)val).persistentID = 0u;
					TextDataBlock val2 = val;
					GameDataBlockBase<TextDataBlock>.AddBlock(val2, -1);
					TextBlockId = ((GameDataBlockBase<TextDataBlock>)(object)val2).persistentID;
				}
			}

			public bool TryGetString(Language language, string key, FallbackValueOptions options, out string? value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (TryGetString(language, options, out value))
				{
					return true;
				}
				if (options.UseKey)
				{
					value = key;
					return true;
				}
				value = null;
				return false;
			}

			public string GetString(Language language, string key, FallbackValueOptions options)
			{
				//IL_0001: 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)
				if (TryGetString(language, options, out string value))
				{
					return value;
				}
				ValidateUseKey(key, language, options, "GetString");
				return key;
			}

			public string FormatString(Language language, string key, FallbackValueOptions options, object?[] args)
			{
				//IL_0001: 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)
				if (TryGetString(language, options, out string value))
				{
					return string.Format(value, args);
				}
				ValidateUseKey(key, language, options, "FormatString");
				return key;
			}

			public bool HasValueInLanguage(Language language)
			{
				//IL_0000: 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_0013: Unknown result type (might be due to invalid IL or missing references)
				ValidateLanguage(language, "language");
				return m_ValuesByLanguage[language - 1] != null;
			}

			public void AddValue(Language language, string value, bool force = false)
			{
				//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_000f: Expected I4, but got Unknown
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				ArgumentNullException.ThrowIfNull(value, "value");
				int num = language - 1;
				if (num < 0 || num >= m_ValuesByLanguage.Length)
				{
					throw new ArgumentOutOfRangeException("language");
				}
				ref string reference = ref m_ValuesByLanguage[num];
				if (reference != null && !force)
				{
					return;
				}
				reference = value;
				if (TextBlockId.HasValue)
				{
					TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock(TextBlockId.Value);
					if (block != null)
					{
						UpdateTextDataBlock(block, language, reference);
					}
				}
			}
		}

		[Flags]
		public enum FallbackValueFlags
		{
			None = 0,
			FallbackLanguage = 1,
			AnyLanguage = 2,
			Key = 4,
			FallbackOrAnyLanguage = 3,
			FallbackLanguageOrKey = 5,
			AnyLanguageOrKey = 6,
			FallbackOrAnyLanguageOrKey = 7
		}

		public readonly struct FallbackValueOptions : IEquatable<FallbackValueOptions>
		{
			public static readonly FallbackValueOptions None = default(FallbackValueOptions);

			public static readonly FallbackValueOptions Key = new FallbackValueOptions(FallbackValueFlags.Key);

			public static readonly FallbackValueOptions AnyLang = new FallbackValueOptions(FallbackValueFlags.AnyLanguage);

			public static readonly FallbackValueOptions AnyLangOrKey = new FallbackValueOptions(FallbackValueFlags.AnyLanguageOrKey);

			public FallbackValueFlags Flags { get; }

			public Language? FallbackLanguage { get; }

			public bool UseKey => Flags.HasFlag(FallbackValueFlags.Key);

			[MemberNotNullWhen(true, "FallbackLanguage")]
			public bool UseFallbackLanguage
			{
				[MemberNotNullWhen(true, "FallbackLanguage")]
				get
				{
					return Flags.HasFlag(FallbackValueFlags.FallbackLanguage);
				}
			}

			public bool UseAnyLanguage => Flags.HasFlag(FallbackValueFlags.AnyLanguage);

			public FallbackValueOptions(FallbackValueFlags flags, Language? fallbackLanguage = null)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				if (flags.HasFlag(FallbackValueFlags.FallbackLanguage))
				{
					if (!fallbackLanguage.HasValue)
					{
						throw new ArgumentNullException("fallbackLanguage", "A fallback language is required if specifying the flag FallbackLanguage");
					}
					ValidateLanguage(fallbackLanguage.Value, "fallbackLanguage");
				}
				Flags = flags;
				FallbackLanguage = fallbackLanguage;
			}

			public override int GetHashCode()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				return HashCode.Combine<FallbackValueFlags, Language>(Flags, FallbackLanguage.GetValueOrDefault());
			}

			public override bool Equals([NotNullWhen(true)] object? obj)
			{
				if (obj is FallbackValueOptions other)
				{
					return Equals(other);
				}
				return false;
			}

			public bool Equals(FallbackValueOptions other)
			{
				//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)
				if (Flags == other.Flags)
				{
					return FallbackLanguage == other.FallbackLanguage;
				}
				return false;
			}

			public FallbackValueOptions IncludeKey()
			{
				return new FallbackValueOptions(Flags | FallbackValueFlags.Key, FallbackLanguage);
			}

			public FallbackValueOptions ExcludeKey()
			{
				return new FallbackValueOptions(Flags & ~FallbackValueFlags.Key, FallbackLanguage);
			}

			public FallbackValueOptions IncludeFallbackLanguage(Language language)
			{
				//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)
				ValidateLanguage(language, "language");
				return new FallbackValueOptions(Flags | FallbackValueFlags.FallbackLanguage, language);
			}

			public FallbackValueOptions ExcludeFallbackLanguage()
			{
				return new FallbackValueOptions(Flags & ~FallbackValueFlags.FallbackLanguage);
			}

			public FallbackValueOptions IncludeAnyLanguage()
			{
				return new FallbackValueOptions(Flags | FallbackValueFlags.AnyLanguage, FallbackLanguage);
			}

			public FallbackValueOptions ExcludeAnyLanguage()
			{
				return new FallbackValueOptions(Flags & ~FallbackValueFlags.AnyLanguage, FallbackLanguage);
			}

			public FallbackValueOptions Combine(FallbackValueOptions other)
			{
				return new FallbackValueOptions(Flags | other.Flags, FallbackLanguage ?? other.FallbackLanguage);
			}

			public static bool operator ==(FallbackValueOptions left, FallbackValueOptions right)
			{
				return left.Equals(right);
			}

			public static bool operator !=(FallbackValueOptions left, FallbackValueOptions right)
			{
				return !(left == right);
			}

			public static FallbackValueOptions FallbackLang(Language fallbackLanguage)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return new FallbackValueOptions(FallbackValueFlags.FallbackLanguage, fallbackLanguage);
			}

			public static FallbackValueOptions FallbackOrAnyLang(Language fallbackLanguage)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return new FallbackValueOptions(FallbackValueFlags.FallbackOrAnyLanguage, fallbackLanguage);
			}

			public static FallbackValueOptions FallbackLangOrKey(Language fallbackLanguage)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return new FallbackValueOptions(FallbackValueFlags.FallbackLanguageOrKey, fallbackLanguage);
			}

			public static FallbackValueOptions FallbackOrAnyLangOrKey(Language fallbackLanguage)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return new FallbackValueOptions(FallbackValueFlags.FallbackOrAnyLanguageOrKey, fallbackLanguage);
			}
		}

		public struct TextDBOptions
		{
			private FallbackValueOptions? m_FallbackOptions;

			private uint? m_CharacterMetadataId;

			public uint? CharacterMetadataId
			{
				readonly get
				{
					return m_CharacterMetadataId;
				}
				set
				{
					m_CharacterMetadataId = value;
				}
			}

			public FallbackValueOptions? FallbackOptions
			{
				readonly get
				{
					return m_FallbackOptions;
				}
				set
				{
					m_FallbackOptions = value;
				}
			}
		}

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

		private static readonly List<string> s_EntriesToGenerateTextDBs = new List<string>();

		private static bool s_GameDataInitialized = false;

		private static readonly string STR_NoValueFoundExceptionMsg = "No localization value exists for key '{1}' in language '{0}'.";

		private static readonly string STR_UseKeyGeneric = "{2}: No localization value exists for key '{1}' in language '{0}', defaulting to key.";

		public static ApiStatusInfo Status => APIStatus.Localization;

		public static Language CurrentLanguage => Text.TextLocalizationService.CurrentLanguage;

		public static event Action? OnLanguageChange;

		internal static void Setup()
		{
			GameDataAPI.OnGameDataInitialized += OnGameDataInitialized;
			EventAPI.OnAssetsLoaded += OnGameAssetsLoaded;
			Status.Created = true;
		}

		internal static void OnGameDataInitialized()
		{
			s_GameDataInitialized = true;
			foreach (string s_EntriesToGenerateTextDB in s_EntriesToGenerateTextDBs)
			{
				if (s_Entries.TryGetValue(s_EntriesToGenerateTextDB, out Entry value))
				{
					value.GenerateTextDataBlock(s_EntriesToGenerateTextDB, force: true);
				}
			}
		}

		internal static void OnGameAssetsLoaded()
		{
			Status.Ready = true;
		}

		internal static void LanguageChanged()
		{
			SafeInvoke.Invoke(LocalizationAPI.OnLanguageChange);
		}

		public static string FormatString(string key, params object?[] args)
		{
			return FormatString(key, FallbackValueOptions.None, args);
		}

		public static string FormatString(string key, Language fallbackLanguage, params object?[] args)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FormatString(key, FallbackValueOptions.FallbackLang(fallbackLanguage), args);
		}

		public static string FormatString(string key, FallbackValueOptions options, params object?[] args)
		{
			//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_0030: 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)
			ValidateLocalizationKey(key, "key");
			Language currentLanguage = CurrentLanguage;
			if (!s_Entries.TryGetValue(key, out Entry value))
			{
				ValidateUseKey(key, currentLanguage, options, "FormatString");
				return key;
			}
			return value.FormatString(currentLanguage, key, options, args);
		}

		public static string GetString(string key)
		{
			return GetString(key, FallbackValueOptions.None);
		}

		public static string GetString(string key, Language fallbackLanguage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return GetString(key, FallbackValueOptions.FallbackLang(fallbackLanguage));
		}

		public static string GetString(string key, FallbackValueOptions options)
		{
			//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_0030: 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)
			ValidateLocalizationKey(key, "key");
			Language currentLanguage = CurrentLanguage;
			if (!s_Entries.TryGetValue(key, out Entry value))
			{
				ValidateUseKey(key, currentLanguage, options, "GetString");
				return key;
			}
			return value.GetString(currentLanguage, key, options);
		}

		public static bool TryGetString(string key, [NotNullWhen(true)] out string? value)
		{
			return TryGetString(key, FallbackValueOptions.None, out value);
		}

		public static bool TryGetString(string key, Language fallbackLanguage, [NotNullWhen(true)] out string? value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return TryGetString(key, FallbackValueOptions.FallbackLang(fallbackLanguage), out value);
		}

		public static bool TryGetString(string key, FallbackValueOptions options, [NotNullWhen(true)] out string? value)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			ValidateLocalizationKey(key, "key");
			if (!s_Entries.TryGetValue(key, out Entry value2))
			{
				if (options.UseKey)
				{
					value = key;
					return false;
				}
				value = null;
				return false;
			}
			return value2.TryGetString(CurrentLanguage, key, options, out value);
		}

		public static bool HasKey([NotNullWhen(true)] string? key)
		{
			if (!string.IsNullOrWhiteSpace(key))
			{
				return s_Entries.ContainsKey(key);
			}
			return false;
		}

		public static bool HasLocalizedValue([NotNullWhen(true)] string? key, Language language)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(key) && s_Entries.TryGetValue(key, out Entry value))
			{
				return value.HasValueInLanguage(language);
			}
			return false;
		}

		public static uint GenerateTextBlock(string key, TextDBOptions? textDataBlockOptions = null)
		{
			ValidateLocalizationKey(key, "key");
			Entry entry = s_Entries[key];
			if (entry.TextBlockId.HasValue)
			{
				return entry.TextBlockId.Value;
			}
			if (textDataBlockOptions.HasValue)
			{
				entry.GenerateTextDataBlock(key, textDataBlockOptions.Value);
			}
			else
			{
				entry.GenerateTextDataBlock(key);
			}
			s_EntriesToGenerateTextDBs.Add(key);
			return entry.TextBlockId.Value;
		}

		public static bool TryGetTextBlockId(string key, out uint blockId)
		{
			ValidateLocalizationKey(key, "key");
			if (!s_Entries.TryGetValue(key, out Entry value) || !value.TextBlockId.HasValue)
			{
				blockId = 0u;
				return false;
			}
			blockId = value.TextBlockId.Value;
			return true;
		}

		public static void AddEntry(string key, Language language, string value, TextDBOptions? textDataBlockOptions = null)
		{
			//IL_000b: 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)
			ValidateLocalizationKey(key, "key");
			ValidateLanguage(language, "language");
			if (value == null)
			{
				value = string.Empty;
			}
			bool exists;
			ref Entry valueRefOrAddDefault = ref CollectionsMarshal.GetValueRefOrAddDefault(s_Entries, key, out exists);
			if (valueRefOrAddDefault == null)
			{
				valueRefOrAddDefault = new Entry();
			}
			valueRefOrAddDefault.AddValue(language, value);
			if (textDataBlockOptions.HasValue && !exists)
			{
				s_EntriesToGenerateTextDBs.Add(key);
				if (s_GameDataInitialized)
				{
					valueRefOrAddDefault.GenerateTextDataBlock(key, textDataBlockOptions.Value);
				}
			}
		}

		public static void LoadFromResources(string baseName, TextDBOptions? textDataBlockOptions = null)
		{
			LoadFromResources(baseName, Assembly.GetCallingAssembly(), textDataBlockOptions);
		}

		public static void LoadFromResources(string baseName, Assembly assembly, TextDBOptions? textDataBlockOptions = null)
		{
			//IL_002c: 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_0033: 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)
			ResourceManager resourceManager = new ResourceManager(baseName, assembly);
			List<Exception> list = new List<Exception>();
			CultureInfo[] cultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
			foreach (CultureInfo cultureInfo in cultures)
			{
				bool isNeutralCulture = cultureInfo.IsNeutralCulture;
				Language language = GetLanguage(cultureInfo);
				if ((int)language == 0)
				{
					continue;
				}
				ResourceSet resourceSet;
				try
				{
					resourceSet = resourceManager.GetResourceSet(cultureInfo, createIfNotExists: true, tryParents: true);
				}
				catch (MissingManifestResourceException)
				{
					continue;
				}
				catch (Exception item)
				{
					list.Add(item);
					continue;
				}
				if (resourceSet == null)
				{
					continue;
				}
				foreach (DictionaryEntry item2 in resourceSet)
				{
					if (!(item2.Key is string text) || !(item2.Value is string value))
					{
						continue;
					}
					bool exists;
					ref Entry valueRefOrAddDefault = ref CollectionsMarshal.GetValueRefOrAddDefault(s_Entries, text, out exists);
					if (valueRefOrAddDefault == null)
					{
						valueRefOrAddDefault = new Entry();
					}
					valueRefOrAddDefault.AddValue(language, value, isNeutralCulture);
					if (textDataBlockOptions.HasValue && !exists)
					{
						s_EntriesToGenerateTextDBs.Add(text);
						if (s_GameDataInitialized)
						{
							valueRefOrAddDefault.GenerateTextDataBlock(text, textDataBlockOptions.Value);
						}
					}
				}
			}
			resourceManager.ReleaseAllResources();
			if (list.Count > 0)
			{
				throw new AggregateException(list);
			}
		}

		private static void ValidateLocalizationKey([NotNull] string key, [CallerArgumentExpression("key")] string? paramName = null)
		{
			ArgumentNullException.ThrowIfNull(key, paramName);
			if (string.IsNullOrWhiteSpace(paramName))
			{
				throw new ArgumentException("Localization key cannot be empty/whitespace", paramName ?? "key");
			}
		}

		private static void ValidateLanguage(Language language, [CallerArgumentExpression("language")] string? paramName = null)
		{
			//IL_0000: 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)
			if (!Enum.IsDefined<Language>(language))
			{
				throw new ArgumentException($"'{language}' is not a valid language", paramName ?? "language");
			}
		}

		private static void ValidateUseKey(string key, Language language, FallbackValueOptions options, string useCategory)
		{
			//IL_002a: 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)
			if (!options.UseKey)
			{
				throw new KeyNotFoundException(string.Format(STR_NoValueFoundExceptionMsg, language, key));
			}
			APILogger.Warn("LocalizationAPI", string.Format(STR_UseKeyGeneric, language, key, useCategory));
		}

		private static Language GetLanguage(CultureInfo info)
		{
			//IL_01af: 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_019c: 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)
			//IL_01a6: 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)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_0183: 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_01ab: 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)
			while (!info.IsNeutralCulture)
			{
				info = info.Parent;
				if (string.IsNullOrEmpty(info.Name))
				{
					return (Language)0;
				}
			}
			return (Language)(info.Name switch
			{
				"en" => 1, 
				"fr" => 2, 
				"it" => 3, 
				"de" => 4, 
				"es" => 5, 
				"ru" => 6, 
				"pt" => 7, 
				"pl" => 8, 
				"ja" => 9, 
				"ko" => 10, 
				"zh-Hans" => 12, 
				"zh-Hant" => 11, 
				_ => 0, 
			});
		}

		private static void UpdateTextDataBlock(TextDataBlock block, Language language, string text)
		{
			//IL_0000: 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_0038: Expected I4, but got Unknown
			switch (language - 1)
			{
			case 0:
				block.English = text;
				break;
			case 1:
				block.French = LanguageData.op_Implicit(text);
				break;
			case 2:
				block.Italian = LanguageData.op_Implicit(text);
				break;
			case 3:
				block.German = LanguageData.op_Implicit(text);
				break;
			case 4:
				block.Spanish = LanguageData.op_Implicit(text);
				break;
			case 5:
				block.Russian = LanguageData.op_Implicit(text);
				break;
			case 6:
				block.Portuguese_Brazil = LanguageData.op_Implicit(text);
				break;
			case 7:
				block.Polish = LanguageData.op_Implicit(text);
				break;
			case 8:
				block.Japanese = LanguageData.op_Implicit(text);
				break;
			case 9:
				block.Korean = LanguageData.op_Implicit(text);
				break;
			case 10:
				block.Chinese_Traditional = LanguageData.op_Implicit(text);
				break;
			case 11:
				block.Chinese_Simplified = LanguageData.op_Implicit(text);
				break;
			}
		}
	}
	[API("Network")]
	public static class NetworkAPI
	{
		internal class CachedEvent
		{
			public string EventName { get; set; }

			public Type PayloadType { get; set; }

			public object OnReceive { get; set; }

			public bool IsFreeSize { get; set; }
		}

		internal static ConcurrentDictionary<string, CachedEvent> s_EventCache = new ConcurrentDictionary<string, CachedEvent>();

		public static ApiStatusInfo Status => APIStatus.Network;

		public static bool IsEventRegistered(string eventName)
		{
			return NetworkAPI_Impl.Instance.EventExists(eventName);
		}

		public static void RegisterEvent<T>(string eventName, Action<ulong, T> onReceive) where T : struct
		{
			if (!APIStatus.Network.Ready)
			{
				if (s_EventCache.ContainsKey(eventName))
				{
					throw new ArgumentException("An event with the name " + eventName + " has already been registered.", "eventName");
				}
				s_EventCache.TryAdd(eventName, new CachedEvent
				{
					EventName = eventName,
					PayloadType = typeof(T),
					OnReceive = onReceive,
					IsFreeSize = false
				});
			}
			else
			{
				NetworkAPI_Impl.Instance.RegisterEvent(eventName, onReceive);
			}
		}

		public static void InvokeEvent<T>(string eventName, T payload, SNet_ChannelType channelType = 2) where T : struct
		{
			//IL_0019: 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)
			SNet_SendGroup val = default(SNet_SendGroup);
			SNet_SendQuality val2 = default(SNet_SendQuality);
			int num = default(int);
			SNet.GetSendSettings(ref channelType, ref val, ref val2, ref num);
			SNet.Core.SendBytes(MakeBytes(eventName, payload), val, val2, num);
		}

		public static void InvokeEvent<T>(string eventName, T payload, SNet_Player target, SNet_ChannelType channelType = 2) where T : struct
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			SNet_SendGroup val = default(SNet_SendGroup);
			SNet_SendQuality val2 = default(SNet_SendQuality);
			int num = default(int);
			SNet.GetSendSettings(ref channelType, ref val, ref val2, ref num);
			SNet.Core.SendBytes(MakeBytes(eventName, payload), val2, num, target);
		}

		public static void InvokeEvent<T>(string eventName, T payload, List<SNet_Player> targets, SNet_ChannelType channelType = 2) where T : struct
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			SNet_SendGroup val = default(SNet_SendGroup);
			SNet_SendQuality val2 = default(SNet_SendQuality);
			int num = default(int);
			SNet.GetSendSettings(ref channelType, ref val, ref val2, ref num);
			SNet.Core.SendBytes(MakeBytes(eventName, payload), val2, num, targets.ToIl2Cpp());
		}

		public static void RegisterFreeSizedEvent(string eventName, Action<ulong, byte[]> onReceiveBytes)
		{
			if (!APIStatus.Network.Ready)
			{
				if (s_EventCache.ContainsKey(eventName))
				{
					throw new ArgumentException("An event with the name " + eventName + " has already been registered.", "eventName");
				}
				s_EventCache.TryAdd(eventName, new CachedEvent
				{
					EventName = eventName,
					PayloadType = null,
					OnReceive = onReceiveBytes,
					IsFreeSize = true
				});
			}
			else
			{
				NetworkAPI_Impl.Instance.RegisterFreeSizedEvent(eventName, onReceiveBytes);
			}
		}

		public static void InvokeFreeSizedEvent(string eventName, byte[] payload, SNet_ChannelType channelType = 2)
		{
			//IL_0019: 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)
			SNet_SendGroup val = default(SNet_SendGroup);
			SNet_SendQuality val2 = default(SNet_SendQuality);
			int num = default(int);
			SNet.GetSendSettings(ref channelType, ref val, ref val2, ref num);
			SNet.Core.SendBytes(MakeBytes(eventName, payload), val, val2, num);
		}

		public static void InvokeFreeSizedEvent(string eventName, byte[] payload, SNet_Player target, SNet_ChannelType channelType = 2)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			SNet_SendGroup val = default(SNet_SendGroup);
			SNet_SendQuality val2 = default(SNet_SendQuality);
			int num = default(int);
			SNet.GetSendSettings(ref channelType, ref val, ref val2, ref num);
			SNet.Core.SendBytes(MakeBytes(eventName, payload), val2, num, target);
		}

		public static void InvokeFreeSizedEvent(string eventName, byte[] payload, IEnumerable<SNet_Player> targets, SNet_ChannelType channelType = 2)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			SNet_SendGroup val = default(SNet_SendGroup);
			SNet_SendQuality val2 = default(SNet_SendQuality);
			int num = default(int);
			SNet.GetSendSettings(ref channelType, ref val, ref val2, ref num);
			SNet.Core.SendBytes(MakeBytes(eventName, payload), val2, num, targets.ToList().ToIl2Cpp());
		}

		private static Il2CppStructArray<byte> MakeBytes<T>(string eventName, T payload) where T : struct
		{
			return Il2CppStructArray<byte>.op_Implicit(NetworkAPI_Impl.Instance.MakePacketBytes(eventName, payload));
		}

		private static Il2CppStructArray<byte> MakeBytes(string eventName, byte[] payload)
		{
			return Il2CppStructArray<byte>.op_Implicit(NetworkAPI_Impl.Instance.MakeFreeSizedPacketBytes(eventName, payload));
		}
	}
	[API("Prefab")]
	public static class PrefabAPI
	{
		private static Shader s_CustomGearShader;

		private static readonly Dictionary<uint, Action<SyringeFirstPerson>> s_SyringeActions = new Dictionary<uint, Action<SyringeFirstPerson>>();

		public static ApiStatusInfo Status => APIStatus.Prefab;

		private static Shader CustomGearShader
		{
			get
			{
				if ((Object)(object)s_CustomGearShader == (Object)null)
				{
					s_CustomGearShader = Shader.Find("Cell/Player/CustomGearShader");
				}
				return s_CustomGearShader;
			}
		}

		public static void CreateConsumable(string assetName, bool enableEmissive = false)
		{
			Object loadedAsset = AssetAPI.GetLoadedAsset(assetName);
			GameObject val = ((loadedAsset != null) ? ((Il2CppObjectBase)loadedAsset).TryCast<GameObject>() : null) ?? null;
			if ((Object)(object)val == (Object)null)
			{
				throw new ArgumentException("Couldn't find a game object asset with the name " + assetName, "assetName");
			}
			ItemEquippable obj = val.AddComponent<ItemEquippable>();
			obj.m_isFirstPerson = false;
			((Item)obj).m_itemModelHolder = val.transform;
			ReplaceShaderInAssetMaterials(val, CustomGearShader, enableEmissive ? "ENABLE_EMISSIVE" : null);
		}

		public static void CreateConsumablePickup(string assetName, bool enableEmissive = false)
		{
			Object loadedAsset = AssetAPI.GetLoadedAsset(assetName);
			GameObject val = ((loadedAsset != null) ? ((Il2CppObjectBase)loadedAsset).TryCast<GameObject>() : null) ?? null;
			if ((Object)(object)val == (Object)null)
			{
				throw new ArgumentException("Couldn't find a game object asset with the name " + assetName, "assetName");
			}
			BoxCollider componentInChildren = val.GetComponentInChildren<BoxCollider>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				throw new Exception("The Consumable Pickup prefab doesn't contain a BoxCollider for interaction");
			}
			GameObject gameObject = ((Component)componentInChildren).gameObject;
			gameObject.layer = LayerMask.NameToLayer("Interaction");
			Interact_Pickup_PickupItem val2 = gameObject.AddComponent<Interact_Pickup_PickupItem>();
			((Interact_Base)val2).m_colliderToOwn = (Collider)(object)componentInChildren;
			ConsumablePickup_Core obj = val.AddComponent<ConsumablePickup_Core>();
			obj.m_syncComp = (Component)(object)val.AddComponent<LG_PickupItem_Sync>();
			obj.m_interactComp = (Component)(object)val2;
			ReplaceShaderInAssetMaterials(val, CustomGearShader, enableEmissive ? "ENABLE_EMISSIVE" : null);
		}

		public static void CreateConsumableInstance<T>(string assetName) where T : ConsumableInstance
		{
			Object loadedAsset = AssetAPI.GetLoadedAsset(assetName);
			GameObject obj = ((loadedAsset != null) ? ((Il2CppObjectBase)loadedAsset).TryCast<GameObject>() : null) ?? null;
			if ((Object)(object)obj == (Object)null)
			{
				throw new ArgumentException("Couldn't find a game object asset with the name " + assetName, "assetName");
			}
			if (!ClassInjector.IsTypeRegisteredInIl2Cpp<T>())
			{
				ClassInjector.RegisterTypeInIl2Cpp<T>();
			}
			obj.layer = LayerMask.NameToLayer("Debris");
			Rigidbody component = obj.GetComponent<Rigidbody>();
			obj.AddComponent<ColliderMaterial>().PhysicsBody = component ?? throw new Exception("The Consumable Instance prefab doesn't contain a Rigidbody");
			obj.AddComponent<T>();
		}

		public static void CreateGearComponent(string assetName, bool enableEmissive = false)
		{
			Object loadedAsset = AssetAPI.GetLoadedAsset(assetName);
			GameObject obj = ((loadedAsset != null) ? ((Il2CppObjectBase)loadedAsset).TryCast<GameObject>() : null) ?? null;
			if ((Object)(object)obj == (Object)null)
			{
				throw new ArgumentException("Couldnt find a game object asset with the name " + assetName, "assetName");
			}
			obj.layer = LayerMask.NameToLayer("FirstPersonItem");
			ReplaceShaderInAssetMaterials(obj, CustomGearShader, "ENABLE_FPS_RENDERING", enableEmissive ? "ENABLE_EMISSIVE" : null);
		}

		public static void CreateSyringe(uint itemPersistentId, Action<SyringeFirstPerson> onUse)
		{
			if (s_SyringeActions.ContainsKey(itemPersistentId))
			{
				throw new ArgumentException($"{itemPersistentId} is already registered with a syringe action.");
			}
			s_SyringeActions.Add(itemPersistentId, onUse);
		}

		internal static bool OnSyringeUsed(SyringeFirstPerson syringe)
		{
			if (s_SyringeActions.TryGetValue(((GameDataBlockBase<ItemDataBlock>)(object)((Item)syringe).ItemDataBlock).persistentID, out var value))
			{
				value(syringe);
				return true;
			}
			return false;
		}

		private static void ReplaceShaderInAssetMaterials(GameObject asset, Shader newShader, params string[] addedKeywords)
		{
			addedKeywords = addedKeywords.Where((string x) => !string.IsNullOrEmpty(x)).ToArray();
			foreach (MeshRenderer componentsInChild in asset.GetComponentsInChildren<MeshRenderer>(true))
			{
				foreach (Material item in (Il2CppArrayBase<Material>)(object)((Renderer)componentsInChild).materials)
				{
					item.shader = newShader;
					if (addedKeywords.Length != 0)
					{
						string[] array = Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)item.shaderKeywords);
						int num = array.Length;
						Array.Resize(ref array, array.Length + addedKeywords.Length);
						for (int i = 0; i < addedKeywords.Length; i++)
						{
							array[num + i] = addedKeywords[i];
						}
						item.shaderKeywords = Il2CppStringArray.op_Implicit(array);
					}
				}
			}
		}
	}
	[API("SoundBank")]
	public static class SoundBankAPI
	{
		public static ApiStatusInfo Status => APIStatus.SoundBank;

		public static event Action OnSoundBanksLoaded;

		internal static void Setup()
		{
			EventAPI.OnManagersSetup += OnLoadSoundBanks;
		}

		private static void OnLoadSoundBanks()
		{
			FileInfo[] array = (from file in Directory.CreateDirectory(Path.Combine(Paths.BepInExRootPath, "Assets", "SoundBank")).EnumerateFiles()
				where file.Extension.Contains(".bnk")
				select file).ToArray();
			CollectionExtensions.Do<FileInfo>((IEnumerable<FileInfo>)array, (Action<FileInfo>)LoadBank);
			if (array.Any())
			{
				SafeInvoke.Invoke(SoundBankAPI.OnSoundBanksLoaded);
			}
		}

		private unsafe static void LoadBank(FileInfo file)
		{
			//IL_0048: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			using FileStream fileStream = file.OpenRead();
			uint num = (uint)fileStream.Length;
			byte[] array = new byte[num];
			if (fileStream.Read(array, 0, (int)num) != 0)
			{
				void* ptr = NativeMemory.AlignedAlloc(num, 16u);
				Unsafe.CopyBlock(ref Unsafe.AsRef<byte>(ptr), ref array[0], num);
				uint value = default(uint);
				AKRESULT val = AkSoundEngine.LoadBank((IntPtr)(nint)ptr, num, ref value);
				if ((int)val == 1)
				{
					APILogger.Info("SoundBankAPI", $"Loaded sound bank '{file.Name}' (bankId: {value:X2})");
				}
				else
				{
					APILogger.Error("SoundBankAPI", $"Error while loading sound bank '{file.Name}' ({val})");
					NativeMemory.AlignedFree(ptr);
				}
			}
		}
	}
	[BepInPlugin("dev.gtfomodding.gtfo-api", "GTFO-API", "0.5.0")]
	internal class EntryPoint : BasePlugin
	{
		private Harmony m_Harmony;

		public override void Load()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			APILogger.Verbose("Core", "Registering API Implementations");
			ClassInjector.RegisterTypeInIl2Cpp<NetworkAPI_Impl>();
			ClassInjector.RegisterTypeInIl2Cpp<AssetAPI_Impl>();
			APILogger.Verbose("Core", "Registering Wrappers");
			ClassInjector.RegisterTypeInIl2Cpp<ItemWrapped>();
			APILogger.Verbose("Core", "Registering Utilities Implementations");
			ClassInjector.RegisterTypeInIl2Cpp<ThreadDispatcher_Impl>();
			ClassInjector.RegisterTypeInIl2Cpp<CoroutineDispatcher_Impl>();
			APILogger.Verbose("Core", "Applying Patches");
			m_Harmony = new Harmony("dev.gtfomodding.gtfo-api");
			m_Harmony.PatchAll();
			EventAPI.Setup();
			AssetAPI.Setup();
			SoundBankAPI.Setup();
			LevelAPI.Setup();
			LocalizationAPI.Setup();
			APILogger.Verbose("Core", "Plugin Load Complete");
			APILogger.Warn("GTFO-API", "Syringes are currently disabled in this version");
		}
	}
	[GeneratedCode("VersionInfoGenerator", "2.0.0+git50a4b1a-master")]
	[CompilerGenerated]
	internal static class VersionInfo
	{
		public const string RootNamespace = "GTFO.API";

		public const string Version = "0.5.0";

		public const string VersionPrerelease = null;

		public const string VersionMetadata = "gitcd77914-main";

		public const string SemVer = "0.5.0+gitcd77914-main";

		public const string GitRevShort = "cd77914";

		public const string GitRevLong = "cd77914af9eee3a5d9106a4128c5fa3bc02d7ec0";

		public const string GitBranch = "main";

		public const string GitTag = "0.4.0";

		public const bool GitIsDirty = false;
	}
}
namespace GTFO.API.Wrappers
{
	public class ItemWrapped : Item
	{
		private static readonly Item__Get_pItemData Get_pItemDataBase = Il2CppAPI.GetIl2CppMethod<Item, Item__Get_pItemData>("Get_pItemData", "Player.pItemData", isGeneric: false, Array.Empty<string>());

		private static readonly Item__Set_pItemData Set_pItemDataBase = Il2CppAPI.GetIl2CppMethod<Item, Item__Set_pItemData>("Set_pItemData", "System.Void", isGeneric: false, new string[1] { "Player.pItemData" });

		private static readonly Item__GetCustomData GetCustomDataBase = Il2CppAPI.GetIl2CppMethod<Item, Item__GetCustomData>("GetCustomData", "Player.pItemData_Custom", isGeneric: false, Array.Empty<string>());

		private static readonly Item__SetCustomData SetCustomDataBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SetCustomData>("SetCustomData", "System.Void", isGeneric: false, new string[2] { "Player.pItemData_Custom", "System.Boolean" });

		private static readonly Item__OnCustomDataUpdated OnCustomDataUpdatedBase = Il2CppAPI.GetIl2CppMethod<Item, Item__OnCustomDataUpdated>("OnCustomDataUpdated", "System.Void", isGeneric: false, new string[1] { "Player.pItemData_Custom" });

		private static readonly Item__Awake AwakeBase = Il2CppAPI.GetIl2CppMethod<Item, Item__Awake>("Awake", "System.Void", isGeneric: false, Array.Empty<string>());

		private static readonly Item__OnDespawn OnDespawnBase = Il2CppAPI.GetIl2CppMethod<Item, Item__OnDespawn>("OnDespawn", "System.Void", isGeneric: false, Array.Empty<string>());

		private static readonly Item__Setup SetupBase = Il2CppAPI.GetIl2CppMethod<Item, Item__Setup>("Setup", "System.Void", isGeneric: false, new string[1] { "GameData.ItemDataBlock" });

		private static readonly Item__OnGearSpawnComplete OnGearSpawnCompleteBase = Il2CppAPI.GetIl2CppMethod<Item, Item__OnGearSpawnComplete>("OnGearSpawnComplete", "System.Void", isGeneric: false, Array.Empty<string>());

		private static readonly Item__OnPickUp OnPickUpBase = Il2CppAPI.GetIl2CppMethod<Item, Item__OnPickUp>("OnPickUp", "System.Void", isGeneric: false, new string[1] { "Player.PlayerAgent" });

		private static readonly Item__SetupBaseModel SetupBaseModelBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SetupBaseModel>("SetupBaseModel", "System.Void", isGeneric: false, new string[1] { "ItemSetup.ItemModelSetup" });

		private static readonly Item__SyncedTurnOn SyncedTurnOnBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedTurnOn>("SyncedTurnOn", "System.Void", isGeneric: false, new string[2] { "Player.PlayerAgent", "AIGraph.AIG_CourseNode" });

		private static readonly Item__SyncedTurnOff SyncedTurnOffBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedTurnOff>("SyncedTurnOff", "System.Void", isGeneric: false, new string[1] { "Player.PlayerAgent" });

		private static readonly Item__SyncedTrigger SyncedTriggerBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedTrigger>("SyncedTrigger", "System.Void", isGeneric: false, new string[1] { "Player.PlayerAgent" });

		private static readonly Item__SyncedTriggerSecondary SyncedTriggerSecondaryBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedTriggerSecondary>("SyncedTriggerSecondary", "System.Void", isGeneric: false, new string[1] { "Player.PlayerAgent" });

		private static readonly Item__SyncedThrow SyncedThrowBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedThrow>("SyncedThrow", "System.Void", isGeneric: false, new string[1] { "Player.PlayerAgent" });

		private static readonly Item__SyncedPickup SyncedPickupBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedPickup>("SyncedPickup", "System.Void", isGeneric: false, new string[1] { "Player.PlayerAgent" });

		private static readonly Item__SyncedSetKeyValue SyncedSetKeyValueBase = Il2CppAPI.GetIl2CppMethod<Item, Item__SyncedSetKeyValue>("SyncedSetKeyValue", "System.Void", isGeneric: false, new string[2] { "System.Int32", "System.Single" });

		private static readonly Item__GetPickupInteraction GetPickupInteractionBase = Il2CppAPI.GetIl2CppMethod<Item, Item__GetPickupInteraction>("GetPickupInteraction", "Interact_Base", isGeneric: false, Array.Empty<string>());

		private static readonly Item__GetItem GetItemBase = Il2CppAPI.GetIl2CppMethod<Item, Item__GetItem>("GetItem", "Item", isGeneric: false, Array.Empty<string>());

		public ItemWrapped(IntPtr hdl)
			: base(hdl)
		{
		}

		public unsafe override pItemData Get_pItemData()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			pItemData* retstr = (pItemData*)stackalloc pItemData[1];
			return *Get_pItemDataBase(retstr, ((Il2CppObjectBase)this).Pointer.ToPointer());
		}

		public unsafe override void Set_pItemData(pItemData data)
		{
			Set_pItemDataBase(((Il2CppObjectBase)this).Pointer.ToPointer(), &data);
		}

		public unsafe override pItemData_Custom GetCustomData()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return *GetCustomDataBase(((Il2CppObjectBase)this).Pointer.ToPointer());
		}

		public unsafe override void SetCustomData(pItemData_Custom custom, bool sync)
		{
			SetCustomDataBase(((Il2CppObjectBase)this).Pointer.ToPointer(), &custom, sync);
		}

		public unsafe override void OnCustomDataUpdated(pItemData_Custom customDataCopy)
		{
			OnCustomDataUpdatedBase(((Il2CppObjectBase)this).Pointer.ToPointer(), &customDataCopy);
		}

		public unsafe override void Awake()
		{
			AwakeBase(((Il2CppObjectBase)this).Pointer.ToPointer());
		}

		public unsafe override void OnDespawn()
		{
			OnDespawnBase(((Il2CppObjectBase)this).Pointer.ToPointer());
		}

		public unsafe override void Setup(ItemDataBlock data)
		{
			SetupBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)data).Pointer.ToPointer());
		}

		public unsafe override void OnGearSpawnComplete()
		{
			OnGearSpawnCompleteBase(((Il2CppObjectBase)this).Pointer.ToPointer());
		}

		public unsafe override void OnPickUp(PlayerAgent player)
		{
			OnPickUpBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)player).Pointer.ToPointer());
		}

		public unsafe override void SetupBaseModel(ItemModelSetup setup)
		{
			SetupBaseModelBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)setup).Pointer.ToPointer());
		}

		public unsafe override void SyncedTurnOn(PlayerAgent agent, AIG_CourseNode courseNode)
		{
			SyncedTurnOnBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)agent).Pointer.ToPointer(), ((Il2CppObjectBase)courseNode).Pointer.ToPointer());
		}

		public unsafe override void SyncedTurnOff(PlayerAgent agent)
		{
			SyncedTurnOffBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)agent).Pointer.ToPointer());
		}

		public unsafe override void SyncedTrigger(PlayerAgent agent)
		{
			SyncedTriggerBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)agent).Pointer.ToPointer());
		}

		public unsafe override void SyncedTriggerSecondary(PlayerAgent agent)
		{
			SyncedTriggerSecondaryBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)agent).Pointer.ToPointer());
		}

		public unsafe override void SyncedThrow(PlayerAgent agent)
		{
			SyncedThrowBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)agent).Pointer.ToPointer());
		}

		public unsafe override void SyncedPickup(PlayerAgent agent)
		{
			SyncedPickupBase(((Il2CppObjectBase)this).Pointer.ToPointer(), ((Il2CppObjectBase)agent).Pointer.ToPointer());
		}

		public unsafe override void SyncedSetKeyValue(int key, float value)
		{
			SyncedSetKeyValueBase(((Il2CppObjectBase)this).Pointer.ToPointer(), key, value);
		}

		public unsafe override Interact_Base GetPickupInteraction()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			return new Interact_Base((IntPtr)GetPickupInteractionBase(((Il2CppObjectBase)this).Pointer.ToPointer()));
		}

		public unsafe override Item GetItem()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			return new Item((IntPtr)GetItemBase(((Il2CppObjectBase)this).Pointer.ToPointer()));
		}
	}
	public unsafe delegate pItemData* Item__Get_pItemData(pItemData* retstr, void* _this);
	public unsafe delegate void Item__Set_pItemData(void* _this, void* data);
	public unsafe delegate pItemData_Custom* Item__GetCustomData(void* _this);
	public unsafe delegate void Item__SetCustomData(void* _this, pItemData_Custom* custom, bool sync);
	public unsafe delegate void Item__OnCustomDataUpdated(void* _this, pItemData_Custom* customDataCopy);
	public unsafe delegate void Item__Awake(void* _this);
	public unsafe delegate void Item__OnDespawn(void* _this);
	public unsafe delegate void Item__Setup(void* _this, void* data);
	public unsafe delegate void Item__OnGearSpawnComplete(void* _this);
	public unsafe delegate void Item__OnPickUp(void* _this, void* player);
	public unsafe delegate void Item__SetupBaseModel(void* _this, void* setup);
	public unsafe delegate void Item__SyncedTurnOn(void* _this, void* agent, void* courseNode);
	public unsafe delegate void Item__SyncedTurnOff(void* _this, void* agent);
	public unsafe delegate void Item__SyncedTrigger(void* _this, void* agent);
	public unsafe delegate void Item__SyncedTriggerSecondary(void* _this, void* agent);
	public unsafe delegate void Item__SyncedThrow(void* _this, void* agent);
	public unsafe delegate void Item__SyncedPickup(void* _this, void* agent);
	public unsafe delegate void Item__SyncedSetKeyValue(void* _this, int key, float value);
	public unsafe delegate void* Item__GetPickupInteraction(void* _this);
	public unsafe delegate void* Item__GetItem(void* _this);
	[Il2CppInterface(typeof(iTerminalItem))]
	public interface iTerminalItemWrapper
	{
		uint TerminalItemId { get; set; }

		string TerminalItemKey { get; set; }

		string OverrideCode { get; set; }

		Vector3 LocatorBeaconPosition { get; set; }

		AIG_CourseNode SpawnNode { get; set; }

		bool ShowInFloorInventory { get; set; }

		string FloorItemLocation { get; set; }

		eFloorInventoryObjectType FloorItemType { get; set; }

		eFloorInventoryObjectStatus FloorItemStatus { get; set; }

		Func<List<string>, List<string>> OnWantDetailedInfo { get; set; }

		void Setup(string key);

		List<string> GetDetailedInfo(List<string> defaultDetails);

		void PlayPing();
	}
	[Il2CppInterface(typeof(iResourcePackReceiver))]
	public interface iResourcePackReceiverWrapper
	{
		bool IsLocallyOwned { get; }

		string InteractionName { get; }

		bool NeedHealth();

		bool NeedDisinfection();

		bool NeedWeaponAmmo();

		bool NeedToolAmmo();

		void GiveAmmoRel(float ammoStandardRel, float ammoSpecialRel, float ammoClassRel);

		void GiveHealth(float health);

		void GiveDisinfection(float disinfection);
	}
	[Il2CppInterface(typeof(iPlayerPingTarget))]
	public interface iPlayerPingTargetWrapper
	{
		eNavMarkerStyle PingTargetStyle { get; set; }
	}
	[Il2CppInterface(typeof(iWardenObjectiveItem))]
	public interface iWardenObjectiveItemWrapper
	{
		LG_LayerType OriginLayer { get; }

		AIG_CourseNode SpawnNode { get; }

		string PublicName { get; }

		Transform transform { get; }

		bool ObjectiveItemSolved { get; }

		ePickupItemStatus PickupItemStatus { get; }

		PlayerAgent PickedUpByPlayer { get; }

		void ActivateWardenObjectiveItem();

		void DeactivateWardenObjectiveItem();
	}
}
namespace GTFO.API.Utilities
{
	public static class CoroutineDispatcher
	{
		public static Coroutine StartCoroutine(IEnumerator routine)
		{
			return CoroutineDispatcher_Impl.Instance.RunCoroutine(routine);
		}

		public static Coroutine StartInLevelCoroutine(IEnumerator routine)
		{
			return CoroutineDispatcher_Impl.Instance.RunInLevelCoroutine(routine);
		}
	}
	public delegate void LiveEditEventHandler(LiveEditEventArgs e);
	public class LiveEditEventArgs
	{
		public LiveEditEventType Type { get; set; }

		public string FullPath { get; set; }

		public string FileName { get; set; }
	}
	public enum LiveEditEventType
	{
		Created,
		Deleted,
		Renamed,
		Changed
	}
	public static class LiveEdit
	{
		internal const int RETRY_COUNT = 5;

		internal const float RETRY_INTERVAL = 0.1f;

		internal static readonly List<LiveEditListener> s_Listeners = new List<LiveEditListener>();

		public static LiveEditListener CreateListener(string path, string filter, bool includeSubDir)
		{
			LiveEditListener liveEditListener = new LiveEditListener(path, filter, includeSubDir);
			s_Listeners.Add(liveEditListener);
			return liveEditListener;
		}

		public static void TryReadFileContent(string filepath, Action<string> onReaded)
		{
			CoroutineDispatcher.StartCoroutine(GetFileStream(filepath, 5, 0.1f, delegate(FileStream stream)
			{
				try
				{
					using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8);
					onReaded?.Invoke(streamReader.ReadToEnd());
				}
				catch
				{
				}
			}));
		}

		private static IEnumerator GetFileStream(string filepath, int retryCount, float retryInterval, Action<FileStream> onFileStreamOpened)
		{
			retryCount = Math.Max(retryCount, 1);
			retryInterval = Math.Max(retryInterval, 0f);
			WaitForSecondsRealtime wait = new WaitForSecondsRealtime(retryInterval);
			for (int i = 0; i < retryCount; i++)
			{
				try
				{
					FileStream fileStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
					onFileStreamOpened?.Invoke(fileStream);
					fileStream.Close();
					break;
				}
				catch
				{
				}
				yield return wait;
			}
		}
	}
	public sealed class LiveEditListener : IDisposable
	{
		private FileSystemWatcher m_Watcher;

		private bool m_Allocated = true;

		private float m_ChangedCooldownTimer;

		public float FileChangedEventCooldown { get; set; } = 0.05f;


		public event LiveEditEventHandler FileChanged;

		public event LiveEditEventHandler FileDeleted;

		public event LiveEditEventHandler FileCreated;

		public event LiveEditEventHandler FileRenamed;

		private LiveEditListener()
		{
		}

		internal LiveEditListener(string path, string filter, bool includeSubDir)
		{
			LiveEditListener liveEditListener = this;
			m_Watcher = new FileSystemWatcher
			{
				Path = path,
				Filter = filter,
				IncludeSubdirectories = includeSubDir,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime)
			};
			m_Watcher.Deleted += delegate(object sender, FileSystemEventArgs e)
			{
				FileSystemEventArgs e5 = e;
				ThreadDispatcher.Dispatch(delegate
				{
					liveEditListener.FileDeleted?.Invoke(CreateArgs(e5, LiveEditEventType.Deleted));
				});
			};
			m_Watcher.Created += delegate(object sender, FileSystemEventArgs e)
			{
				FileSystemEventArgs e4 = e;
				ThreadDispatcher.Dispatch(delegate
				{
					liveEditListener.FileCreated?.Invoke(CreateArgs(e4, LiveEditEventType.Created));
				});
			};
			m_Watcher.Renamed += delegate(object sender, RenamedEventArgs e)
			{
				RenamedEventArgs e3 = e;
				ThreadDispatcher.Dispatch(delegate
				{
					liveEditListener.FileRenamed?.Invoke(CreateArgs(e3, LiveEditEventType.Renamed));
				});
			};
			m_Watcher.Changed += delegate(object sender, FileSystemEventArgs e)
			{
				FileSystemEventArgs e2 = e;
				ThreadDispatcher.Dispatch(delegate
				{
					float time = Time.time;
					if (!(liveEditListener.m_ChangedCooldownTimer > time))
					{
						liveEditListener.m_ChangedCooldownTimer = time + liveEditListener.FileChangedEventCooldown;
						liveEditListener.FileChanged?.Invoke(CreateArgs(e2, LiveEditEventType.Changed));
					}
				});
			};
			m_Watcher.Error += delegate(object sender, ErrorEventArgs e)
			{
				APILogger.Error("LiveEdit", $"Path: {path} error reported! - {e.GetException()}");
			};
			StartListen();
		}

		private static LiveEditEventArgs CreateArgs(FileSystemEventArgs args, LiveEditEventType type)
		{
			return new LiveEditEventArgs
			{
				FullPath = args.FullPath,
				FileName = Path.GetFileName(args.FullPath),
				Type = type
			};
		}

		public void Dispose()
		{
			if (m_Allocated)
			{
				LiveEdit.s_Listeners.Remove(this);
				m_Allocated = false;
			}
			if (m_Watcher != null)
			{
				StopListen();
				this.FileChanged = null;
				this.FileDeleted = null;
				this.FileCreated = null;
				this.FileRenamed = null;
				m_Watcher.Dispose();
			}
			m_Watcher = null;
		}

		public void StopListen()
		{
			if (m_Watcher != null)
			{
				m_Watcher.EnableRaisingEvents = false;
			}
		}

		public void StartListen()
		{
			if (m_Watcher != null)
			{
				m_Watcher.EnableRaisingEvents = true;
			}
		}
	}
	internal static class MemoryUtils
	{
		private static byte[] _trampolineShellcode = new byte[12]
		{
			72, 184, 0, 0, 0, 0, 0, 0, 0, 0,
			255, 208
		};

		public unsafe static void* FindSignatureInBlock(void* block, ulong blockSize, string pattern, string mask, ulong sigOffset = 0uL)
		{
			return FindSignatureInBlock(block, blockSize, pattern.ToCharArray(), mask.ToCharArray(), sigOffset);
		}

		public unsafe static void* FindSignatureInBlock(void* block, ulong blockSize, char[] pattern, char[] mask, ulong sigOffset = 0uL)
		{
			for (ulong num = 0uL; num < blockSize; num++)
			{
				bool flag = true;
				for (uint num2 = 0u; num2 < mask.Length; num2++)
				{
					if (*(byte*)((long)num + (long)block + num2) != (byte)pattern[num2] && mask[num2] != '?')
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return (void*)((ulong)((long)num + (long)block) + sigOffset);
				}
			}
			return null;
		}

		public unsafe static byte[] MakeTrampoline(void* destination)
		{
			byte[] array = new byte[_trampolineShellcode.Length];
			Array.Copy(_trampolineShellcode, 0, array, 0, _trampolineShellcode.Length);
			fixed (byte* ptr = array)
			{
				*(long*)(ptr + 2) = (long)destination;
			}
			return array;
		}

		public unsafe static void CreateTrampolineBetween(void* start, void* end, void* destination)
		{
			ulong num = (ulong)end - (ulong)start;
			if (num < (ulong)_trampolineShellcode.Length)
			{
				throw new Exception("Trampoline block size is not enough to create.");
			}
			uint flNewProtect = default(uint);
			if (!Kernel32.VirtualProtect(start, num, 64u, &flNewProtect))
			{
				throw new Exception("Failed to change protection of trampoline block.");
			}
			APILogger.Verbose("MemoryUtils", "NOPing trampoline block");
			for (ulong num2 = 0uL; num2 < num; num2++)
			{
				*(sbyte*)((ulong)start + num2) = -112;
			}
			APILogger.Verbose("MemoryUtils", "Creating trampoline shellcode");
			byte[] array = MakeTrampoline(destination);
			APILogger.Verbose("MemoryUtils", "Writing trampoline shellcode");
			for (ulong num3 = 0uL; num3 < (ulong)array.Length; num3++)
			{
				*(byte*)((ulong)start + num3) = array[num3];
			}
			if (!Kernel32.VirtualProtect(start, num, flNewProtect, &flNewProtect))
			{
				throw new Exception("Failed to revert trampoline block protection.");
			}
		}
	}
	public class PersistentData<T> where T : PersistentData<T>, new()
	{
		private const string VERSION_REGEX = "\"PersistentDataVersion\": \"(.+?)\"";

		private static T s_CurrentData;

		public static T CurrentData
		{
			get
			{
				if (s_CurrentData != null)
				{
					return s_CurrentData;
				}
				s_CurrentData = Load();
				return s_CurrentData;
			}
			set
			{
				s_CurrentData = value;
			}
		}

		protected static string persistentPath => Path.Combine(Paths.BepInExRootPath, "GameData", "PersistentData", typeof(T).Assembly.GetName().Name, typeof(T).Name + ".json");

		public virtual string PersistentDataVersion { get; set; } = "1.0.0";


		public static T Load()
		{
			return Load(persistentPath);
		}

		public static T Load(string path)
		{
			T val = new T();
			if (File.Exists(path))
			{
				string text = File.ReadAllText(path);
				T val2;
				try
				{
					val2 = GTFO.API.JSON.JsonSerializer.Deserialize<T>(text);
				}
				catch (JsonException)
				{
					APILogger.Warn("JSON", "Failed to deserialize " + typeof(T).Name + ", replacing with default");
					string text2 = "FAILED";
					Match match = Regex.Match(text, "\"PersistentDataVersion\": \"(.+?)\"");
					if (match.Success)
					{
						text2 = match.Groups[1].Value + "-FAILED";
					}
					File.WriteAllText(Path.ChangeExtension(path, null) + "-" + text2 + ".json", text);
					val2 = new T();
					val2.Save(path);
				}
				if (val2.PersistentDataVersion != val.PersistentDataVersion)
				{
					val2.Save(Path.ChangeExtension(path, null) + "-" + val2.PersistentDataVersion + ".json");
					val.Save(path);
				}
				else
				{
					val = val2;
				}
			}
			else
			{
				val.Save(path);
			}
			return val;
		}

		public void Save()
		{
			Save(persistentPath);
		}

		public void Save(string path)
		{
			string contents = GTFO.API.JSON.JsonSerializer.Serialize((T)this);
			string directoryName = Path.GetDirectoryName(path);
			if (!Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			File.WriteAllText(path, contents);
		}
	}
	public static class RegexUtils
	{
		private static readonly Regex s_VectorRegex = new Regex("-?[0-9.]+");

		public static bool TryParseVectorString(string input, out float[] vectorArray)
		{
			try
			{
				MatchCollection matchCollection = s_VectorRegex.Matches(input);
				int count = matchCollection.Count;
				if (count < 1)
				{
					throw new Exception();
				}
				vectorArray = new float[count];
				for (int i = 0; i < count; i++)
				{
					Match match = matchCollection[i];
					vectorArray[i] = float.Parse(match.Value, CultureInfo.InvariantCulture);
				}
				return true;
			}
			catch
			{
				vectorArray = null;
				return false;
			}
		}
	}
	public static class SafeInvoke
	{
		public static void Invoke(Action actionToInvoke)
		{
			if (actionToInvoke == null)
			{
				return;
			}
			foreach (Action item in actionToInvoke.GetInvocationList().Cast<Action>())
			{
				try
				{
					item();
				}
				catch (Exception value)
				{
					APILogger.Error("GTFO-API", $"Exception occured while invoking events!\n{value}");
				}
			}
		}

		public static void Invoke<T>(Action<T> actionToInvoke, T arg0)
		{
			if (actionToInvoke == null)
			{
				return;
			}
			foreach (Action<T> item in actionToInvoke.GetInvocationList().Cast<Action<T>>())
			{
				try
				{
					item(arg0);
				}
				catch (Exception value)
				{
					APILogger.Error("GTFO-API", $"Exception occured while invoking events!\n{value}");
				}
			}
		}

		public static void Invoke<T0, T1>(Action<T0, T1> actionToInvoke, T0 arg0, T1 arg1)
		{
			if (actionToInvoke == null)
			{
				return;
			}
			foreach (Action<T0, T1> item in actionToInvoke.GetInvocationList().Cast<Action<T0, T1>>())
			{
				try
				{
					item(arg0, arg1);
				}
				catch (Exception value)
				{
					APILogger.Error("GTFO-API", $"Exception occured while invoking events!\n{value}");
				}
			}
		}

		public static void Invoke<T0, T1, T2>(Action<T0, T1, T2> actionToInvoke, T0 arg0, T1 arg1, T2 arg2)
		{
			if (actionToInvoke == null)
			{
				return;
			}
			foreach (Action<T0, T1, T2> item in actionToInvoke.GetInvocationList().Cast<Action<T0, T1, T2>>())
			{
				try
				{
					item(arg0, arg1, arg2);
				}
				catch (Exception value)
				{
					APILogger.Error("GTFO-API", $"Exception occured while invoking events!\n{value}");
				}
			}
		}

		public static void InvokeDelegate<D>(Delegate delegateToInvoke, Action<D> invoke) where D : Delegate
		{
			if ((object)delegateToInvoke == null)
			{
				return;
			}
			foreach (D item in delegateToInvoke.GetInvocationList().Cast<D>())
			{
				try
				{
					invoke(item);
				}
				catch (Exception value)
				{
					APILogger.Error("GTFO-API", $"Exception occured while invoking events!\n{value}");
				}
			}
		}
	}
	public static class StringUtils
	{
		private static readonly uint[] _lookup32 = ((Func<uint[]>)delegate
		{
			uint[] array = new uint[256];
			for (int i = 0; i < 256; i++)
			{
				string text = i.ToString("X2");
				if (BitConverter.IsLittleEndian)
				{
					array[i] = text[0] + ((uint)text[1] << 16);
				}
				else
				{
					array[i] = text[1] + ((uint)text[0] << 16);
				}
			}
			return array;
		})();

		private unsafe static readonly uint* _lookup32Ptr = (uint*)(void*)GCHandle.Alloc(_lookup32, GCHandleType.Pinned).AddrOfPinnedObject();

		public unsafe static string FromByteArrayAsHex(byte[] bytes)
		{
			char[] array = new char[bytes.Length * 2];
			fixed (byte* ptr3 = bytes)
			{
				fixed (char* ptr = array)
				{
					uint* ptr2 = (uint*)ptr;
					for (int i = 0; i < bytes.Length; i++)
					{
						ptr2[i] = _lookup32Ptr[(int)ptr3[i]];
					}
				}
			}
			return new string(array);
		}
	}
	public static class ThreadDispatcher
	{
		public static void Dispatch(Action action)
		{
			ThreadDispatcher_Impl.Instance.EnqueueAction(action);
		}
	}
}
namespace GTFO.API.Utilities.Impl
{
	internal class CoroutineDispatcher_Impl : MonoBehaviour
	{
		private bool m_HasInLevelCoroutines;

		private readonly List<Coroutine> m_InLevelCoroutines = new List<Coroutine>();

		private static CoroutineDispatcher_Impl s_Instance;

		public static CoroutineDispatcher_Impl Instance
		{
			get
			{
				if ((Object)(object)s_Instance == (Object)null)
				{
					CoroutineDispatcher_Impl coroutineDispatcher_Impl = Object.FindObjectOfType<CoroutineDispatcher_Impl>();
					if ((Object)(object)coroutineDispatcher_Impl != (Object)null)
					{
						s_Instance = coroutineDispatcher_Impl;
					}
				}
				return s_Instance;
			}
		}

		static CoroutineDispatcher_Impl()
		{
			AssetAPI.OnStartupAssetsLoaded += OnAssetsLoaded;
		}

		private static void OnAssetsLoaded()
		{
			//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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (!((Object)(object)s_Instance != (Object)null))
			{
				GameObject val = new GameObject();
				CoroutineDispatcher_Impl coroutineDispatcher_Impl = val.AddComponent<CoroutineDispatcher_Impl>();
				((Object)val).name = "GTFO-API Coroutine Dispatcher";
				((Object)val).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)val);
				s_Instance = coroutineDispatcher_Impl;
			}
		}

		private void Update()
		{
			if (m_HasInLevelCoroutines && !GameStateManager.IsInExpedition)
			{
				m_InLevelCoroutines.ForEach(delegate(Coroutine coroutine)
				{
					((MonoBehaviour)this).StopCoroutine(coroutine);
				});
				m_InLevelCoroutines.Clear();
				m_HasInLevelCoroutines = false;
			}
		}

		[HideFromIl2Cpp]
		internal Coroutine RunCoroutine(IEnumerator routine)
		{
			return MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)this, routine);
		}

		[HideFromIl2Cpp]
		internal Coroutine RunInLevelCoroutine(IEnumerator routine)
		{
			if (!GameStateManager.IsInExpedition)
			{
				APILogger.Error("CoroutineDispatcher", "Cannot run InLevelCoroutine while you're not in level!");
				return null;
			}
			Coroutine val = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)this, routine);
			m_InLevelCoroutines.Add(val);
			m_HasInLevelCoroutines = true;
			return val;
		}
	}
	internal class ThreadDispatcher_Impl : MonoBehaviour
	{
		private readonly Queue<Action> s_ActionQueue = new Queue<Action>();

		private static ThreadDispatcher_Impl s_Instance;

		public static ThreadDispatcher_Impl Instance
		{
			get
			{
				if ((Object)(object)s_Instance == (Object)null)
				{
					ThreadDispatcher_Impl threadDispatcher_Impl = Object.FindObjectOfType<ThreadDispatcher_Impl>();
					if ((Object)(object)threadDispatcher_Impl != (Object)null)
					{
						s_Instance = threadDispatcher_Impl;
					}
				}
				return s_Instance;
			}
		}

		public ThreadDispatcher_Impl(IntPtr intPtr)
			: base(intPtr)
		{
		}

		static ThreadDispatcher_Impl()
		{
			AssetAPI.OnStartupAssetsLoaded += OnAssetsLoaded;
		}

		private static void OnAssetsLoaded()
		{
			//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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (!((Object)(object)s_Instance != (Object)null))
			{
				GameObject val = new GameObject();
				ThreadDispatcher_Impl threadDispatcher_Impl = val.AddComponent<ThreadDispatcher_Impl>();
				((Object)val).name = "GTFO-API Thread Dispatcher";
				((Object)val).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)val);
				s_Instance = threadDispatcher_Impl;
			}
		}

		[HideFromIl2Cpp]
		internal void EnqueueAction(Action action)
		{
			lock (s_ActionQueue)
			{
				s_ActionQueue.Enqueue(action);
			}
		}

		internal void Update()
		{
			lock (s_ActionQueue)
			{
				while (s_ActionQueue.Count > 0)
				{
					s_ActionQueue.Dequeue()?.Invoke();
				}
			}
		}
	}
}
namespace GTFO.API.Resources
{
	public class ApiStatusInfo
	{
		public bool Created { get; internal set; }

		public bool Ready { get; internal set; }
	}
	public static class APIStatus
	{
		private static GameObject s_ScriptHolder;

		public static ApiStatusInfo Asset { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Event { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo GameData { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Localization { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Il2Cpp { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Level { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Network { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Prefab { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo SoundBank { get; internal set; } = new ApiStatusInfo();


		public static ApiStatusInfo Interop { get; internal set; } = new ApiStatusInfo();


		internal static GameObject ScriptHolder
		{
			get
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				if ((Object)(object)s_ScriptHolder == (Object)null)
				{
					s_ScriptHolder = new GameObject();
					((Object)s_ScriptHolder).name = "GTFO-API Script Holder";
					((Object)s_ScriptHolder).hideFlags = (HideFlags)61;
					Object.DontDestroyOnLoad((Object)(object)s_ScriptHolder);
				}
				return s_ScriptHolder;
			}
		}

		internal static void CreateApi<T>(string apiName) where T : Component
		{
			ApiStatusInfo apiStatusInfo = (ApiStatusInfo)(typeof(APIStatus).GetProperty(apiName)?.GetValue(null));
			if (apiStatusInfo == null)
			{
				throw new ArgumentException("Couldn't find API status for " + apiName, "apiName");
			}
			if (!apiStatusInfo.Created && !((Object)(object)ScriptHolder.GetComponent<T>() != (Object)null))
			{
				APILogger.Verbose("Core", "Creating API " + apiName);
				ScriptHolder.AddComponent<T>();
				apiStatusInfo.Created = true;
			}
		}
	}
	internal static class RuntimeData
	{
		public static Dictionary<InventorySlot, string[]> BotFavorites;
	}
	public static class ShaderConstants
	{
		public const string CUSTOM_GEAR_SHADER = "Cell/Player/CustomGearShader";
	}
	public static class NetworkConstants
	{
		public const string Magic = "GAPI_KSQK";

		public const byte MagicSize = 9;

		public const ulong VersionSignature = 18374688234229425498uL;
	}
}
namespace GTFO.API.Patches
{
	[HarmonyPatch(typeof(CellSettingsApply), "ApplyLanguage")]
	internal static class ApplyLanguage_Patches
	{
		private static bool s_LanguageChanged;

		[HarmonyWrapSafe]
		public static void Prefix(int value)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			s_LanguageChanged = (int)Text.TextLocalizationService.CurrentLanguage != value;
		}

		[HarmonyWrapSafe]
		public static void Postfix()
		{
			if (s_LanguageChanged)
			{
				LocalizationAPI.LanguageChanged();
			}
		}
	}
	[HarmonyPatch(typeof(AssetShardManager))]
	internal class AssetShardManager_Patches
	{
		[HarmonyPatch("Setup")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void Setup_Postfix()
		{
			if (!APIStatus.Asset.Created)
			{
				APIStatus.CreateApi<AssetAPI_Impl>("Asset");
			}
		}
	}
	[HarmonyPatch(typeof(Builder))]
	internal class Builder_Patches
	{
		[HarmonyPatch("Build")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void BuildStart_Postfix()
		{
			LevelAPI.BuildStart();
		}

		[HarmonyPatch("BuildDone")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void BuildDone_Postfix()
		{
			LevelAPI.BuildDone();
		}
	}
	[HarmonyPatch(typeof(GameDataInit))]
	internal class GameDataInit_Patches
	{
		private struct PluginWhitelistInfo
		{
			public string GUID;

			public string Name;

			public string Version;

			public string Checksum;
		}

		private static PluginWhitelistInfo[] FetchPluginWhitelist()
		{
			using HttpClient httpClient = new HttpClient();
			using Stream stream = httpClient.GetStreamAsync("https://raw.githubusercontent.com/GTFO-Modding/GTFO-API-PluginWhitelist/main/whitelist.txt").GetAwaiter().GetResult();
			using StreamReader streamReader = new StreamReader(stream);
			string[] array = streamReader.ReadToEnd().Split('\n', StringSplitOptions.RemoveEmptyEntries);
			PluginWhitelistInfo[] array2 = new PluginWhitelistInfo[array.Length];
			for (int i = 0; i < array2.Length; i++)
			{
				string[] array3 = array[i].Split(":");
				array2[i] = new PluginWhitelistInfo
				{
					GUID = array3[0],
					Name = array3[1],
					Version = array3[2],
					Checksum = array3[3].TrimEnd('\r')
				};
			}
			return array2;
		}

		[HarmonyPatch("Initialize")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void Initialize_Postfix()
		{
			Analytics.enabled = false;
			GameDataAPI.InvokeGameDataInit();
			if (!APIStatus.Network.Created)
			{
				APIStatus.CreateApi<NetworkAPI_Impl>("Network");
			}
		}

		private static void RemoveRequirementFromList(List<ExpeditionInTierData> list)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0026: Invalid comparison between Unknown and I4
			Enumerator<ExpeditionInTierData> enumerator = list.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ExpeditionInTierData current = enumerator.Current;
				if (current.Enabled)
				{
					eExpeditionAccessibility accessibility = current.Accessibility;
					if ((int)accessibility == 0 || accessibility - 4 <= 1)
					{
						current.Accessibility = (eExpeditionAccessibility)2;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(GearManager))]
	internal static class GearManager_Patches
	{
		private unsafe delegate IntPtr ReadFromDiskDelegate(IntPtr path, byte* createNew, Il2CppMethodInfo* methodInfo);

		private unsafe delegate void SaveToDiskDelegate(IntPtr path, IntPtr obj, Il2CppMethodInfo* methodInfo);

		private static bool m_PatchApplied;

		private static INativeDetour s_ReadFromDiskDetour;

		private static ReadFromDiskDelegate s_ReadFromDiskOriginal;

		private static INativeDetour s_SaveToDiskDetour;

		private static SaveToDiskDelegate s_SaveToDiskOriginal;

		private static string FavoritesDirectory => Path.Combine(Paths.BepInExRootPath, "GameData", "Favorites");

		private static string FavoritePath => Path.Combine(FavoritesDirectory, "Gear.json");

		private static string BotFavoritePath => Path.Combine(FavoritesDirectory, "BotGear.json");

		[HarmonyPatch("Setup")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private unsafe static void Setup_Prefix()
		{
			if (!m_PatchApplied)
			{
				if (!Directory.Exists(FavoritesDirectory))
				{
					Directory.CreateDirectory(FavoritesDirectory);
				}
				string methodName = "SaveToDisk";
				APILogger.Verbose("GearManager_Patches", "Applying ReadFromDisk Patch");
				s_ReadFromDiskDetour = Il2CppAPI.CreateGenericDetour<CellJSON, ReadFromDiskDelegate>("ReadFromDisk", "T", new string[2]
				{
					typeof(string).FullName,
					typeof(bool).MakeByRefType().FullName
				}, new Type[1] { typeof(GearFavoritesData) }, (ReadFromDiskDelegate)Patch_ReadFromDisk, out s_ReadFromDiskOriginal);
				APILogger.Verbose("GearManager_Patches", "Applying SaveToDisk Patch");
				s_SaveToDiskDetour = Il2CppAPI.CreateGenericDetour<CellJSON, SaveToDiskDelegate>(methodName, typeof(void).FullName, new string[2]
				{
					typeof(string).FullName,
					"T"
				}, new Type[1] { typeof(GearFavoritesData) }, (SaveToDiskDelegate)Patch_SaveToDisk, out s_SaveToDiskOriginal);
				m_PatchApplied = true;
			}
		}

		private unsafe static IntPtr Patch_ReadFromDisk(IntPtr path, byte* createNew, Il2CppMethodInfo* methodInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			string text = String.op_Implicit(new String(path));
			if (text.EndsWith("GTFO_Favorites.txt", StringComparison.OrdinalIgnoreCase))
			{
				return s_ReadFromDiskOriginal(IL2CPP.ManagedStringToIl2Cpp(FavoritePath), createNew, methodInfo);
			}
			if (text.EndsWith("GTFO_BotFavorites.txt", StringComparison.OrdinalIgnoreCase))
			{
				return s_ReadFromDiskOriginal(IL2CPP.ManagedStringToIl2Cpp(BotFavoritePath), createNew, methodInfo);
			}
			return s_ReadFromDiskOriginal(path, createNew, methodInfo);
		}

		private unsafe static void Patch_SaveToDisk(IntPtr path, IntPtr favData, Il2CppMethodInfo* methodInfo

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BoosterImplants;
using CellMenu;
using DropServer;
using GTFO.API;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using LocalProgression.Component;
using LocalProgression.Data;
using Localization;
using MTFO.API;
using Microsoft.CodeAnalysis;
using SNetwork;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Inas07.LocalProgression")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ab8c78f9ff6b5b5d947a46310ee1438e1340cc16")]
[assembly: AssemblyProduct("Inas07.LocalProgression")]
[assembly: AssemblyTitle("Inas07.LocalProgression")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LocalProgression
{
	internal static class Assets
	{
		internal static GameObject NoBoosterIcon { get; private set; }

		internal static void Init()
		{
			NoBoosterIcon = AssetAPI.GetLoadedAsset<GameObject>("Assets/Misc/CM_ExpeditionSectorIcon.prefab");
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Inas.LocalProgression", "LocalProgression", "1.3.7")]
	public class EntryPoint : BasePlugin
	{
		private Harmony m_Harmony;

		public override void Load()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			m_Harmony = new Harmony("LocalProgression");
			m_Harmony.PatchAll();
			EventAPI.OnManagersSetup += LocalProgressionManager.Current.Init;
			AssetAPI.OnAssetBundlesLoaded += Assets.Init;
		}
	}
	internal static class JSON
	{
		private static JsonSerializerOptions _setting;

		public static T Deserialize<T>(string json)
		{
			return JsonSerializer.Deserialize<T>(json, _setting);
		}

		public static string Serialize<T>(T value)
		{
			return JsonSerializer.Serialize(value, _setting);
		}

		static JSON()
		{
			_setting = new JsonSerializerOptions
			{
				ReadCommentHandling = JsonCommentHandling.Skip,
				IncludeFields = false,
				PropertyNameCaseInsensitive = true,
				WriteIndented = true,
				IgnoreReadOnlyProperties = true
			};
			_setting.Converters.Add(new JsonStringEnumConverter());
		}
	}
	public class LocalProgressionManager
	{
		public const string CONFIG_FILE_NAME = "ProgressionConfig.json";

		public static readonly LocalProgressionManager Current;

		private CM_PageRundown_New rundownPage;

		public static readonly string DirPath;

		public string LP_CONFIG_DIR => Path.Combine(MTFOPathAPI.CustomPath, "LocalProgressionConfig");

		public string CONFIG_PATH => Path.Combine(LP_CONFIG_DIR, "ProgressionConfig.json");

		public RundownProgressonConfig RundownProgressonConfig { get; private set; } = new RundownProgressonConfig();


		private RundownProgressionData CurrentRundownPData { get; } = new RundownProgressionData();


		internal RundownProgData nativeProgData { get; private set; }

		internal void SetCurrentRundownPageInstance(CM_PageRundown_New __instance)
		{
			rundownPage = __instance;
		}

		private void UpdateRundownPageExpeditionIconProgression()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_009e: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: 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_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: 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_039b: 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_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: 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_04b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rundownPage == (Object)null)
			{
				return;
			}
			uint rundownID = CurrentRundownPData.RundownID;
			if (rundownID == 0)
			{
				LPLogger.Warning("UpdateRundownPageExpeditionIconProgression: rundown_id == 0!");
				return;
			}
			RundownDataBlock block = GameDataBlockBase<RundownDataBlock>.GetBlock(rundownID);
			LPLogger.Log($"CM_PageRundown_New.UpdateRundownExpeditionProgression, overwrite with LocalProgression Data, RundownID {CurrentRundownPData.RundownID}");
			nativeProgData = ComputeLocalProgressionDataToRundownProgData();
			if ((Object)(object)rundownPage.m_tierMarker1 != (Object)null)
			{
				rundownPage.m_tierMarker1.SetProgression(nativeProgData, new RundownTierProgressionData());
				if (rundownPage.m_expIconsTier1 != null)
				{
					UpdateTierIconsWithProgression(rundownPage.m_expIconsTier1, rundownPage.m_tierMarker1, thisTierUnlocked: true);
				}
			}
			if ((Object)(object)rundownPage.m_tierMarker2 != (Object)null)
			{
				rundownPage.m_tierMarker2.SetProgression(nativeProgData, block.ReqToReachTierB);
				if (rundownPage.m_expIconsTier2 != null)
				{
					UpdateTierIconsWithProgression(rundownPage.m_expIconsTier2, rundownPage.m_tierMarker2, nativeProgData.tierBUnlocked && block.UseTierUnlockRequirements);
				}
			}
			if ((Object)(object)rundownPage.m_tierMarker3 != (Object)null)
			{
				rundownPage.m_tierMarker3.SetProgression(nativeProgData, block.ReqToReachTierC);
				if (rundownPage.m_expIconsTier3 != null)
				{
					UpdateTierIconsWithProgression(rundownPage.m_expIconsTier3, rundownPage.m_tierMarker3, nativeProgData.tierCUnlocked && block.UseTierUnlockRequirements);
				}
			}
			if ((Object)(object)rundownPage.m_tierMarker4 != (Object)null)
			{
				rundownPage.m_tierMarker4.SetProgression(nativeProgData, block.ReqToReachTierD);
				if (rundownPage.m_expIconsTier4 != null)
				{
					UpdateTierIconsWithProgression(rundownPage.m_expIconsTier4, rundownPage.m_tierMarker4, nativeProgData.tierDUnlocked && block.UseTierUnlockRequirements);
				}
			}
			if ((Object)(object)rundownPage.m_tierMarker5 != (Object)null)
			{
				rundownPage.m_tierMarker5.SetProgression(nativeProgData, block.ReqToReachTierE);
				if (rundownPage.m_expIconsTier5 != null)
				{
					UpdateTierIconsWithProgression(rundownPage.m_expIconsTier5, rundownPage.m_tierMarker5, nativeProgData.tierEUnlocked && block.UseTierUnlockRequirements);
				}
			}
			if (!((Object)(object)rundownPage.m_tierMarkerSectorSummary != (Object)null))
			{
				return;
			}
			rundownPage.m_tierMarkerSectorSummary.SetSectorIconTextForMain($"<color=orange>[{nativeProgData.clearedMain}/{nativeProgData.totalMain}]</color>", "#FFFFFFCC");
			rundownPage.m_tierMarkerSectorSummary.SetSectorIconTextForSecondary($"<color=orange>[{nativeProgData.clearedSecondary}/{nativeProgData.totalSecondary}]</color>", "#CCCCCCCC");
			rundownPage.m_tierMarkerSectorSummary.SetSectorIconTextForThird($"<color=orange>[{nativeProgData.clearedThird}/{nativeProgData.totalThird}]</color>", "#CCCCCCCC");
			rundownPage.m_tierMarkerSectorSummary.SetSectorIconTextForAllCleared($"<color=orange>[{nativeProgData.clearedAllClear}/{nativeProgData.totalAllClear}]</color>", "#CCCCCCCC");
			RundownTierMarker_NoBoosterIcon component = ((Component)rundownPage.m_tierMarkerSectorSummary).GetComponent<RundownTierMarker_NoBoosterIcon>();
			if (!((Object)(object)component != (Object)null) || !TryGetRundownConfig(rundownID, out var rundownConf))
			{
				return;
			}
			int value = rundownConf.ComputeNoBoosterClearPossibleCount();
			if (rundownConf.EnableNoBoosterUsedProgressionForRundown && (rundownConf.AlwaysShowIcon || CurrentRundownPData.NoBoosterAllClearCount > 0))
			{
				if (rundownConf.EnableNoBoosterUsedProgressionForRundown)
				{
					value = nativeProgData.totalMain;
				}
				component.SetVisible(visible: true);
				component.SetSectorIconText($"<color=orange>[{CurrentRundownPData.NoBoosterAllClearCount}/{value}]</color>");
			}
			else
			{
				component.SetVisible(visible: false);
			}
		}

		private void UpdateTierIconsWithProgression(List<CM_ExpeditionIcon_New> tierIcons, CM_RundownTierMarker tierMarker, bool thisTierUnlocked)
		{
			//IL_0031: 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)
			if (tierIcons == null || tierIcons.Count == 0)
			{
				if (tierMarker != null)
				{
					tierMarker.SetVisible(false, 0f);
				}
				return;
			}
			for (int i = 0; i < tierIcons.Count; i++)
			{
				CM_ExpeditionIcon_New val = tierIcons[i];
				string rundownProgressionExpeditionKey = RundownManager.GetRundownProgressionExpeditionKey(tierIcons[i].Tier, tierIcons[i].ExpIndex);
				ExpeditionProgressionData value;
				bool flag = CurrentRundownPData.LPData.TryGetValue(rundownProgressionExpeditionKey, out value);
				string text = "0";
				string text2 = (RundownManager.HasSecondaryLayer(tierIcons[i].DataBlock) ? "0" : "-");
				string text3 = (RundownManager.HasThirdLayer(tierIcons[i].DataBlock) ? "0" : "-");
				string text4 = (RundownManager.HasAllCompletetionPossibility(tierIcons[i].DataBlock) ? "0" : "-");
				if (flag)
				{
					if (value.MainCompletionCount > 0)
					{
						text = value.MainCompletionCount.ToString();
					}
					if (value.SecondaryCompletionCount > 0)
					{
						text2 = value.SecondaryCompletionCount.ToString();
					}
					if (value.ThirdCompletionCount > 0)
					{
						text3 = value.ThirdCompletionCount.ToString();
					}
					if (value.AllClearCount > 0)
					{
						text4 = value.AllClearCount.ToString();
					}
				}
				if (CheckExpeditionUnlocked(val.DataBlock, val.Tier))
				{
					if (flag)
					{
						rundownPage.SetIconStatus(val, (eExpeditionIconStatus)4, text, text2, text3, text4, 1f, false, (eExpeditionAccessibility)0);
					}
					else
					{
						rundownPage.SetIconStatus(val, (eExpeditionIconStatus)2, "-", "-", "-", "-", 1f, false, (eExpeditionAccessibility)0);
					}
				}
				else if (flag)
				{
					rundownPage.SetIconStatus(val, (eExpeditionIconStatus)1, text, text2, text3, text4, 1f, false, (eExpeditionAccessibility)0);
				}
				else if (val.DataBlock.HideOnLocked)
				{
					((RectTransformComp)val).SetVisible(false);
				}
				else
				{
					rundownPage.SetIconStatus(val, (eExpeditionIconStatus)0, "-", "-", "-", "-", 1f, false, (eExpeditionAccessibility)0);
				}
			}
			if (thisTierUnlocked)
			{
				if (tierMarker != null)
				{
					tierMarker.SetStatus((eRundownTierMarkerStatus)1);
				}
			}
			else if (tierMarker != null)
			{
				tierMarker.SetStatus((eRundownTierMarkerStatus)0);
			}
		}

		private RundownProgData ComputeLocalProgressionDataToRundownProgData()
		{
			//IL_0002: 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_00e5: 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)
			RundownProgData progressionData = default(RundownProgData);
			if (CurrentRundownPData.RundownID == 0)
			{
				LPLogger.Error("ComputeLocalProgressionDataToRundownProgData: rundown_id == 0...");
				return progressionData;
			}
			RundownDataBlock block = GameDataBlockBase<RundownDataBlock>.GetBlock(CurrentRundownPData.RundownID);
			if (block == null)
			{
				LPLogger.Error($"ComputeLocalProgressionDataToRundownProgData: cannot get rundown datablock with rundown_id: {CurrentRundownPData.RundownID}");
				return progressionData;
			}
			progressionData.clearedMain = CurrentRundownPData.MainClearCount;
			progressionData.clearedSecondary = CurrentRundownPData.SecondaryClearCount;
			progressionData.clearedThird = CurrentRundownPData.ThirdClearCount;
			progressionData.clearedAllClear = CurrentRundownPData.AllClearCount;
			AccumulateTierClearance(block, (eRundownTier)1, ref progressionData);
			AccumulateTierClearance(block, (eRundownTier)2, ref progressionData);
			AccumulateTierClearance(block, (eRundownTier)3, ref progressionData);
			AccumulateTierClearance(block, (eRundownTier)4, ref progressionData);
			AccumulateTierClearance(block, (eRundownTier)5, ref progressionData);
			return progressionData;
		}

		private void AccumulateTierClearance(RundownDataBlock rundownDB, eRundownTier tier, ref RundownProgData progressionData)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			//IL_0061: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			List<ExpeditionInTierData> val = rundownDB.TierA;
			switch (tier - 1)
			{
			case 1:
				val = rundownDB.TierB;
				break;
			case 2:
				val = rundownDB.TierC;
				break;
			case 3:
				val = rundownDB.TierD;
				break;
			case 4:
				val = rundownDB.TierE;
				break;
			default:
				LPLogger.Error($"Unsupported eRundownTier {tier}");
				return;
			case 0:
				break;
			}
			int num = 0;
			Enumerator<ExpeditionInTierData> enumerator = val.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ExpeditionInTierData current = enumerator.Current;
				if (current.Enabled && (!current.HideOnLocked || CheckExpeditionUnlocked(current, tier)))
				{
					progressionData.totalMain++;
					if (RundownManager.HasSecondaryLayer(current))
					{
						progressionData.totalSecondary++;
					}
					if (RundownManager.HasThirdLayer(current))
					{
						progressionData.totalThird++;
					}
					if (RundownManager.HasAllCompletetionPossibility(current))
					{
						progressionData.totalAllClear++;
					}
					if (current.Descriptive.IsExtraExpedition)
					{
						progressionData.totatlExtra++;
					}
					string uniqueExpeditionKey = RundownManager.GetUniqueExpeditionKey(rundownDB, tier, num);
					if (CurrentRundownPData.LPData.ContainsKey(uniqueExpeditionKey))
					{
						progressionData.clearedExtra++;
					}
					num++;
				}
			}
		}

		private bool CheckTierUnlocked(eRundownTier tier)
		{
			//IL_0013: 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_002f: Expected I4, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			RundownDataBlock block = GameDataBlockBase<RundownDataBlock>.GetBlock(CurrentRundownPData.RundownID);
			RundownTierProgressionData val = null;
			switch (tier - 1)
			{
			case 0:
				return true;
			case 1:
				val = block.ReqToReachTierB;
				break;
			case 2:
				val = block.ReqToReachTierC;
				break;
			case 3:
				val = block.ReqToReachTierD;
				break;
			case 4:
				val = block.ReqToReachTierE;
				break;
			default:
				LPLogger.Error("Unsupporrted tier: {0}", tier);
				return true;
			}
			if (CurrentRundownPData.MainClearCount >= val.MainSectors && CurrentRundownPData.SecondaryClearCount >= val.SecondarySectors && CurrentRundownPData.ThirdClearCount >= val.ThirdSectors)
			{
				return CurrentRundownPData.AllClearCount >= val.AllClearedSectors;
			}
			return false;
		}

		private bool CheckExpeditionUnlocked(ExpeditionInTierData expedition, eRundownTier tier)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected I4, but got Unknown
			//IL_002f: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected I4, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			eExpeditionAccessibility accessibility = expedition.Accessibility;
			switch ((int)accessibility)
			{
			case 1:
			case 3:
				return false;
			case 2:
				return true;
			case 0:
				return CheckTierUnlocked(tier);
			case 4:
			{
				RundownTierProgressionData customProgressionLock = expedition.CustomProgressionLock;
				if (CurrentRundownPData.MainClearCount >= customProgressionLock.MainSectors && CurrentRundownPData.SecondaryClearCount >= customProgressionLock.SecondarySectors && CurrentRundownPData.ThirdClearCount >= customProgressionLock.ThirdSectors)
				{
					return CurrentRundownPData.AllClearCount >= customProgressionLock.AllClearedSectors;
				}
				return false;
			}
			case 5:
			{
				ExpeditionIndex unlockedByExpedition = expedition.UnlockedByExpedition;
				string rundownProgressionExpeditionKey = RundownManager.GetRundownProgressionExpeditionKey(unlockedByExpedition.Tier, (int)unlockedByExpedition.Exp);
				return CurrentRundownPData.LPData.ContainsKey(rundownProgressionExpeditionKey);
			}
			default:
				LPLogger.Warning("Unsupported eExpeditionAccessibility: {0}", expedition.Accessibility);
				return true;
			}
		}

		private void SetNativeRundownProgression()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00bd: 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_0103: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_0159: 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)
			Dictionary<string, Expedition> expeditions = RundownManager.RundownProgression.Expeditions;
			if (expeditions.Count > 0)
			{
				LPLogger.Warning($"Non-empty native rundown progression data! RundownID: {CurrentRundownPData.RundownID}");
				expeditions.Clear();
			}
			Dictionary<string, ExpeditionProgressionData> lPData = CurrentRundownPData.LPData;
			Layer val2 = default(Layer);
			Layer val3 = default(Layer);
			Layer val4 = default(Layer);
			foreach (string key in lPData.Keys)
			{
				Expedition val = new Expedition();
				ExpeditionProgressionData expeditionProgressionData = lPData[key];
				val.AllLayerCompletionCount = expeditionProgressionData.AllClearCount;
				val.Layers = new LayerSet<Layer>();
				val2.CompletionCount = expeditionProgressionData.MainCompletionCount;
				val2.State = (LayerProgressionState)((expeditionProgressionData.MainCompletionCount > 0) ? 3 : 0);
				val3.CompletionCount = expeditionProgressionData.SecondaryCompletionCount;
				val3.State = (LayerProgressionState)((expeditionProgressionData.SecondaryCompletionCount > 0) ? 3 : 0);
				val4.CompletionCount = expeditionProgressionData.ThirdCompletionCount;
				val4.State = (LayerProgressionState)((expeditionProgressionData.ThirdCompletionCount > 0) ? 3 : 0);
				val.Layers.SetLayer((ExpeditionLayers)0, val2);
				val.Layers.SetLayer((ExpeditionLayers)1, val3);
				val.Layers.SetLayer((ExpeditionLayers)2, val4);
				LPLogger.Warning($"{val2.CompletionCount}, {val3.CompletionCount}, {val4.CompletionCount}");
				expeditions[key] = val;
			}
		}

		private void InitConfig()
		{
			if (!Directory.Exists(LP_CONFIG_DIR))
			{
				Directory.CreateDirectory(LP_CONFIG_DIR);
			}
			if (!File.Exists(CONFIG_PATH))
			{
				StreamWriter streamWriter = File.CreateText(CONFIG_PATH);
				streamWriter.WriteLine(JSON.Serialize(new RundownProgressonConfig()));
				streamWriter.Flush();
				streamWriter.Close();
				RundownProgressonConfig = new RundownProgressonConfig();
			}
			ReloadConfig();
			RundownManager.OnRundownProgressionUpdated += Action.op_Implicit((Action)ReloadConfig);
		}

		private void ReloadConfig()
		{
			try
			{
				RundownProgressonConfig = JSON.Deserialize<RundownProgressonConfig>(File.ReadAllText(CONFIG_PATH));
			}
			catch
			{
				LPLogger.Error("Cannot reload RundownProgressonConfig, probably the file is invalid");
				RundownProgressonConfig = new RundownProgressonConfig();
			}
		}

		public bool TryGetRundownConfig(uint RundownID, out RundownConfig rundownConf)
		{
			rundownConf = RundownProgressonConfig.Configs.Find((RundownConfig rundownConf) => rundownConf.RundownID == RundownID);
			return rundownConf != null;
		}

		public bool TryGetExpeditionConfig(uint RundownID, eRundownTier tier, int expIndex, out ExpeditionProgressionConfig expConf)
		{
			//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)
			expConf = null;
			if (TryGetRundownConfig(RundownID, out var rundownConf))
			{
				expConf = rundownConf.Expeditions.Find((ExpeditionProgressionConfig e) => e.Tier == tier && e.ExpeditionIndex == expIndex);
			}
			return expConf != null;
		}

		public void RecordExpeditionSuccessForCurrentRundown(string expeditionKey, bool mainLayerCleared, bool secondaryLayerCleared, bool thirdLayerCleared, bool clearedWithNoBooster)
		{
			if (RundownManager.ActiveExpedition.ExcludeFromProgression)
			{
				return;
			}
			UpdateLPDataToActiveRundown();
			bool flag = mainLayerCleared && secondaryLayerCleared && thirdLayerCleared;
			Dictionary<string, ExpeditionProgressionData> lPData = CurrentRundownPData.LPData;
			if (!lPData.ContainsKey(expeditionKey))
			{
				lPData[expeditionKey] = new ExpeditionProgressionData
				{
					ExpeditionKey = expeditionKey,
					MainCompletionCount = (mainLayerCleared ? 1 : 0),
					SecondaryCompletionCount = (secondaryLayerCleared ? 1 : 0),
					ThirdCompletionCount = (thirdLayerCleared ? 1 : 0),
					AllClearCount = (flag ? 1 : 0),
					NoBoosterAllClearCount = (clearedWithNoBooster ? 1 : 0)
				};
				CurrentRundownPData.MainClearCount += (mainLayerCleared ? 1 : 0);
				CurrentRundownPData.SecondaryClearCount += (secondaryLayerCleared ? 1 : 0);
				CurrentRundownPData.ThirdClearCount += (thirdLayerCleared ? 1 : 0);
				CurrentRundownPData.AllClearCount += (flag ? 1 : 0);
				CurrentRundownPData.NoBoosterAllClearCount += (clearedWithNoBooster ? 1 : 0);
			}
			else
			{
				ExpeditionProgressionData expeditionProgressionData = lPData[expeditionKey];
				if (expeditionProgressionData.MainCompletionCount == 0 && mainLayerCleared)
				{
					CurrentRundownPData.MainClearCount++;
				}
				if (expeditionProgressionData.SecondaryCompletionCount == 0 && secondaryLayerCleared)
				{
					CurrentRundownPData.SecondaryClearCount++;
				}
				if (expeditionProgressionData.ThirdCompletionCount == 0 && thirdLayerCleared)
				{
					CurrentRundownPData.ThirdClearCount++;
				}
				if (expeditionProgressionData.AllClearCount == 0 && flag)
				{
					CurrentRundownPData.AllClearCount++;
				}
				if (expeditionProgressionData.NoBoosterAllClearCount == 0 && clearedWithNoBooster)
				{
					CurrentRundownPData.NoBoosterAllClearCount++;
				}
				expeditionProgressionData.MainCompletionCount += (mainLayerCleared ? 1 : 0);
				expeditionProgressionData.SecondaryCompletionCount += (secondaryLayerCleared ? 1 : 0);
				expeditionProgressionData.ThirdCompletionCount += (thirdLayerCleared ? 1 : 0);
				expeditionProgressionData.AllClearCount += (flag ? 1 : 0);
				expeditionProgressionData.NoBoosterAllClearCount += (clearedWithNoBooster ? 1 : 0);
			}
			SaveRundownLPDataToDisk();
		}

		public void UpdateLPDataToActiveRundown()
		{
			uint num = ActiveRundownID();
			if (num == 0)
			{
				LPLogger.Debug("UpdateLPDataToActiveRundown: cannot find any active rundown!");
				return;
			}
			LPLogger.Warning($"Update LPData to rundown_id: {num}");
			CurrentRundownPData.Reset();
			RundownDataBlock block = GameDataBlockBase<RundownDataBlock>.GetBlock(num);
			if (block == null)
			{
				LPLogger.Error($"Didn't find Rundown Datablock with rundown id {num}");
				return;
			}
			Dictionary<string, ExpeditionProgressionData> dictionary = ReadRundownLPData(((GameDataBlockBase<RundownDataBlock>)(object)block).name);
			CurrentRundownPData.RundownID = num;
			CurrentRundownPData.RundownName = ((GameDataBlockBase<RundownDataBlock>)(object)block).name;
			CurrentRundownPData.LPData = dictionary;
			foreach (ExpeditionProgressionData value in dictionary.Values)
			{
				CurrentRundownPData.MainClearCount += ((value.MainCompletionCount > 0) ? 1 : 0);
				CurrentRundownPData.SecondaryClearCount += ((value.SecondaryCompletionCount > 0) ? 1 : 0);
				CurrentRundownPData.ThirdClearCount += ((value.ThirdCompletionCount > 0) ? 1 : 0);
				CurrentRundownPData.AllClearCount += ((value.AllClearCount > 0) ? 1 : 0);
				CurrentRundownPData.NoBoosterAllClearCount += ((value.NoBoosterAllClearCount > 0) ? 1 : 0);
			}
		}

		internal void Init()
		{
			if (!Directory.Exists(DirPath))
			{
				Directory.CreateDirectory(DirPath);
			}
			RundownManager.OnRundownProgressionUpdated += Action.op_Implicit((Action)OnNativeRundownProgressionUpdated);
			InitConfig();
		}

		internal void OnNativeRundownProgressionUpdated()
		{
			UpdateLPDataToActiveRundown();
			if (!((Object)(object)rundownPage == (Object)null) && ((CM_PageBase)rundownPage).m_isActive)
			{
				UpdateRundownPageExpeditionIconProgression();
			}
		}

		public bool AllSectorCompletedWithoutBoosterAndCheckpoint()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (RundownManager.HasSecondaryLayer(RundownManager.ActiveExpedition) && (int)WardenObjectiveManager.CurrentState.second_status != 40)
			{
				return false;
			}
			if (RundownManager.HasThirdLayer(RundownManager.ActiveExpedition) && (int)WardenObjectiveManager.CurrentState.third_status != 40)
			{
				return false;
			}
			bool flag = CheckpointManager.CheckpointUsage == 0;
			if (flag)
			{
				foreach (PlayerBoosterImplantState item in (Il2CppArrayBase<PlayerBoosterImplantState>)(object)BoosterImplantManager.Current.m_boosterPlayers)
				{
					if (item == null)
					{
						continue;
					}
					foreach (pBoosterImplantData item2 in (Il2CppArrayBase<pBoosterImplantData>)(object)item.BoosterImplantDatas)
					{
						if (item2.BoosterImplantID != 0)
						{
							flag = false;
							break;
						}
					}
				}
			}
			return flag;
		}

		public uint ActiveRundownID()
		{
			uint num = default(uint);
			if (!RundownManager.TryGetIdFromLocalRundownKey(RundownManager.ActiveRundownKey, ref num) || num == 0)
			{
				return 0u;
			}
			return num;
		}

		public string ExpeditionKey(eRundownTier tier, int expIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return RundownManager.GetRundownProgressionExpeditionKey(tier, expIndex);
		}

		public ExpeditionProgressionData GetExpeditionLP(uint RundownID, eRundownTier tier, int expIndex)
		{
			//IL_0007: 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)
			ExpeditionProgressionData result = new ExpeditionProgressionData
			{
				ExpeditionKey = ExpeditionKey(tier, expIndex)
			};
			Dictionary<string, ExpeditionProgressionData> dictionary;
			if (CurrentRundownPData.RundownID != RundownID)
			{
				RundownDataBlock block = GameDataBlockBase<RundownDataBlock>.GetBlock(RundownID);
				if (block == null)
				{
					LPLogger.Error($"Didn't find Rundown Datablock with rundown id {RundownID}");
					return result;
				}
				dictionary = ReadRundownLPData(((GameDataBlockBase<RundownDataBlock>)(object)block).name);
			}
			else
			{
				dictionary = CurrentRundownPData.LPData;
			}
			string key = ExpeditionKey(tier, expIndex);
			if (dictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			return result;
		}

		static LocalProgressionManager()
		{
			Current = new LocalProgressionManager();
			DirPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "GTFO-Modding", "LocalProgression");
		}

		private LocalProgressionManager()
		{
		}

		private static string RundownLPDataPath(string rundownName)
		{
			char[] invalidPathChars = Path.GetInvalidPathChars();
			foreach (char oldChar in invalidPathChars)
			{
				rundownName = rundownName.Replace(oldChar, '_');
			}
			return Path.Combine(DirPath, rundownName);
		}

		private static string NBSClearDataPath(string rundownName)
		{
			return RundownLPDataPath(rundownName) + " - NBSClear";
		}

		private bool TryReadAggregatedFormatData(string datapath, out Dictionary<string, ExpeditionProgressionData> dataDict)
		{
			dataDict = new Dictionary<string, ExpeditionProgressionData>();
			bool result = true;
			FileStream fileStream = null;
			BinaryReader binaryReader = null;
			try
			{
				fileStream = File.Open(datapath, FileMode.Open);
				binaryReader = new BinaryReader(fileStream, Encoding.UTF8, leaveOpen: false);
				int num = binaryReader.ReadInt32();
				for (int i = 0; i < num; i++)
				{
					ExpeditionProgressionData expeditionProgressionData = new ExpeditionProgressionData();
					expeditionProgressionData.ExpeditionKey = binaryReader.ReadString();
					expeditionProgressionData.MainCompletionCount = binaryReader.ReadInt32();
					expeditionProgressionData.SecondaryCompletionCount = binaryReader.ReadInt32();
					expeditionProgressionData.ThirdCompletionCount = binaryReader.ReadInt32();
					expeditionProgressionData.AllClearCount = binaryReader.ReadInt32();
					expeditionProgressionData.NoBoosterAllClearCount = binaryReader.ReadInt32();
					dataDict[expeditionProgressionData.ExpeditionKey] = expeditionProgressionData;
				}
			}
			catch (EndOfStreamException)
			{
				dataDict.Clear();
				result = false;
			}
			finally
			{
				binaryReader?.Close();
				fileStream?.Close();
			}
			return result;
		}

		private bool TryReadOldFormatData(string datapath, out Dictionary<string, ExpeditionProgressionData> dataDict)
		{
			dataDict = new Dictionary<string, ExpeditionProgressionData>();
			bool result = true;
			FileStream fileStream = null;
			BinaryReader binaryReader = null;
			if (!File.Exists(datapath))
			{
				return true;
			}
			try
			{
				fileStream = File.Open(datapath, FileMode.Open);
				binaryReader = new BinaryReader(fileStream, Encoding.UTF8, leaveOpen: false);
				int num = binaryReader.ReadInt32();
				for (int i = 0; i < num; i++)
				{
					ExpeditionProgressionData expeditionProgressionData = new ExpeditionProgressionData();
					expeditionProgressionData.ExpeditionKey = binaryReader.ReadString();
					expeditionProgressionData.MainCompletionCount = binaryReader.ReadInt32();
					expeditionProgressionData.SecondaryCompletionCount = binaryReader.ReadInt32();
					expeditionProgressionData.ThirdCompletionCount = binaryReader.ReadInt32();
					expeditionProgressionData.AllClearCount = binaryReader.ReadInt32();
					dataDict[expeditionProgressionData.ExpeditionKey] = expeditionProgressionData;
				}
			}
			catch (EndOfStreamException)
			{
				dataDict.Clear();
				result = false;
			}
			finally
			{
				binaryReader?.Close();
				fileStream?.Close();
			}
			return result;
		}

		private bool TryReadNBSClearData(string datapath, out Dictionary<string, ExpeditionProgressionData> dataDict)
		{
			dataDict = new Dictionary<string, ExpeditionProgressionData>();
			bool result = true;
			FileStream fileStream = null;
			BinaryReader binaryReader = null;
			if (!File.Exists(datapath))
			{
				return true;
			}
			try
			{
				fileStream = File.Open(datapath, FileMode.Open);
				binaryReader = new BinaryReader(fileStream, Encoding.UTF8, leaveOpen: false);
				int num = binaryReader.ReadInt32();
				for (int i = 0; i < num; i++)
				{
					ExpeditionProgressionData expeditionProgressionData = new ExpeditionProgressionData();
					expeditionProgressionData.ExpeditionKey = binaryReader.ReadString();
					expeditionProgressionData.NoBoosterAllClearCount = binaryReader.ReadInt32();
					dataDict[expeditionProgressionData.ExpeditionKey] = expeditionProgressionData;
				}
			}
			catch (EndOfStreamException)
			{
				dataDict.Clear();
				result = false;
			}
			finally
			{
				binaryReader?.Close();
				fileStream?.Close();
			}
			return result;
		}

		private void WriteOldFormatDataToDisk(string filepath, Dictionary<string, ExpeditionProgressionData> dataDict)
		{
			using FileStream output = File.Open(filepath, FileMode.Create);
			using BinaryWriter binaryWriter = new BinaryWriter(output, Encoding.UTF8, leaveOpen: false);
			binaryWriter.Write(dataDict.Count);
			foreach (string key in dataDict.Keys)
			{
				ExpeditionProgressionData expeditionProgressionData = dataDict[key];
				binaryWriter.Write(key);
				binaryWriter.Write(expeditionProgressionData.MainCompletionCount);
				binaryWriter.Write(expeditionProgressionData.SecondaryCompletionCount);
				binaryWriter.Write(expeditionProgressionData.ThirdCompletionCount);
				binaryWriter.Write(expeditionProgressionData.AllClearCount);
			}
		}

		private void WriteNBSClearDataToDisk(string filepath, Dictionary<string, ExpeditionProgressionData> dataDict)
		{
			using FileStream output = File.Open(filepath, FileMode.Create);
			using BinaryWriter binaryWriter = new BinaryWriter(output, Encoding.UTF8, leaveOpen: false);
			binaryWriter.Write(dataDict.Count);
			foreach (string key in dataDict.Keys)
			{
				ExpeditionProgressionData expeditionProgressionData = dataDict[key];
				binaryWriter.Write(key);
				binaryWriter.Write(expeditionProgressionData.NoBoosterAllClearCount);
			}
		}

		private Dictionary<string, ExpeditionProgressionData> ReadRundownLPData(string rundownName)
		{
			string text = RundownLPDataPath(rundownName);
			string text2 = NBSClearDataPath(rundownName);
			Dictionary<string, ExpeditionProgressionData> dataDict = new Dictionary<string, ExpeditionProgressionData>();
			if (File.Exists(text))
			{
				if (TryReadAggregatedFormatData(text, out dataDict))
				{
					LPLogger.Warning(rundownName + " - aggregated format");
					WriteOldFormatDataToDisk(text, dataDict);
					WriteNBSClearDataToDisk(text2, dataDict);
					LPLogger.Warning("wrote old format and nbs data");
				}
				else if (TryReadOldFormatData(text, out dataDict))
				{
					LPLogger.Warning(rundownName + " - old format");
					if (TryReadNBSClearData(text2, out var dataDict2))
					{
						foreach (string key in dataDict.Keys)
						{
							dataDict[key].NoBoosterAllClearCount = (dataDict2.TryGetValue(key, out var value) ? value.NoBoosterAllClearCount : 0);
						}
					}
				}
				else
				{
					LPLogger.Error("Something went wrong with localprogression data, contact the plugin developer...");
				}
			}
			return dataDict;
		}

		internal RundownProgressionData GetLPDataForCurrentRundown()
		{
			return CurrentRundownPData;
		}

		private void SaveRundownLPDataToDisk()
		{
			string rundownName = CurrentRundownPData.RundownName;
			Dictionary<string, ExpeditionProgressionData> lPData = CurrentRundownPData.LPData;
			string text = RundownLPDataPath(rundownName);
			string filepath = NBSClearDataPath(rundownName);
			LPLogger.Warning($"SaveData: saving {CurrentRundownPData.RundownName} LPData to '{text}'");
			WriteOldFormatDataToDisk(text, lPData);
			WriteNBSClearDataToDisk(filepath, lPData);
		}
	}
	internal static class LPLogger
	{
		private static ManualLogSource logger = Logger.CreateLogSource("LocalProgression");

		public static void Log(string format, params object[] args)
		{
			Log(string.Format(format, args));
		}

		public static void Log(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)8, (object)str);
			}
		}

		public static void Warning(string format, params object[] args)
		{
			Warning(string.Format(format, args));
		}

		public static void Warning(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)4, (object)str);
			}
		}

		public static void Error(string format, params object[] args)
		{
			Error(string.Format(format, args));
		}

		public static void Error(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)2, (object)str);
			}
		}

		public static void Debug(string format, params object[] args)
		{
			Debug(string.Format(format, args));
		}

		public static void Debug(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)32, (object)str);
			}
		}
	}
	public static class Utils
	{
		public static bool TryGetComponent<T>(this GameObject obj, out T comp)
		{
			comp = obj.GetComponent<T>();
			return comp != null;
		}
	}
}
namespace LocalProgression.Patches
{
	[HarmonyPatch]
	internal static class Patches_CM_ExpeditionWindow
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_ExpeditionWindow), "Setup")]
		private static void Post_Setup(CM_ExpeditionWindow __instance)
		{
			ExpeditionWindow_NoBoosterIcon expeditionWindow_NoBoosterIcon = ((Component)__instance).gameObject.AddComponent<ExpeditionWindow_NoBoosterIcon>();
			expeditionWindow_NoBoosterIcon.m_window = __instance;
			expeditionWindow_NoBoosterIcon.InitialSetup();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_ExpeditionWindow), "SetExpeditionInfo")]
		private static void Post_SetExpeditionInfo(CM_ExpeditionWindow __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			ExpeditionWindow_NoBoosterIcon component = ((Component)__instance).gameObject.GetComponent<ExpeditionWindow_NoBoosterIcon>();
			if (!((Object)(object)component == (Object)null))
			{
				float num = 0f;
				float num2 = 410f;
				((RectTransformComp)__instance.m_sectorIconMain).SetPosition(new Vector2(num, 0f));
				num += num2;
				if (RundownManager.HasSecondaryLayer(__instance.m_data))
				{
					num += num2;
				}
				if (RundownManager.HasThirdLayer(__instance.m_data))
				{
					num += num2;
				}
				ExpeditionProgressionData expeditionLP = LocalProgressionManager.Current.GetExpeditionLP(LocalProgressionManager.Current.ActiveRundownID(), __instance.m_tier, __instance.m_expIndex);
				if (RundownManager.HasAllCompletetionPossibility(__instance.m_data) && expeditionLP.AllClearCount > 0)
				{
					num += num2;
				}
				component.SetIconPosition(new Vector2(num, 0f));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CM_ExpeditionWindow), "SetVisible")]
		private static bool Pre_SetVisible(CM_ExpeditionWindow __instance, bool visible, bool inMenuBar)
		{
			//IL_0028: 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_007d: Invalid comparison between Unknown and I4
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Invalid comparison between Unknown and I4
			//IL_00bf: 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_00cd: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Invalid comparison between Unknown and I4
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			ExpeditionWindow_NoBoosterIcon component = ((Component)__instance).GetComponent<ExpeditionWindow_NoBoosterIcon>();
			if (!visible)
			{
				return true;
			}
			if (__instance.m_data == null)
			{
				return true;
			}
			uint rundownID = LocalProgressionManager.Current.ActiveRundownID();
			ExpeditionProgressionData expeditionLP = LocalProgressionManager.Current.GetExpeditionLP(rundownID, __instance.m_tier, __instance.m_expIndex);
			((Component)__instance).gameObject.SetActive(visible);
			((RectTransformComp)__instance.m_joinWindow).SetVisible(!inMenuBar && !SNet.IsInLobby);
			((RectTransformComp)__instance.m_hostButton).SetVisible(!inMenuBar && !SNet.IsInLobby && (int)__instance.m_status != 0 && (int)__instance.m_status != 5 && (int)__instance.m_status != 1);
			((RectTransformComp)__instance.m_changeExpeditionButton).SetVisible(SNet.IsMaster && !((RectTransformComp)__instance.m_hostButton).IsVisible && !inMenuBar && SNet.IsInLobby && RundownManager.ActiveExpedition != null && (int)__instance.m_status != 0 && (int)__instance.m_status != 5 && (int)__instance.m_status != 1);
			__instance.m_bottomStripes.SetActive(!((RectTransformComp)__instance.m_hostButton).IsVisible && !((RectTransformComp)__instance.m_changeExpeditionButton).IsVisible);
			((Component)__instance.m_title).gameObject.SetActive(false);
			((Component)__instance.m_wardenObjective).gameObject.SetActive(false);
			((Component)__instance.m_wardenIntel).gameObject.SetActive(false);
			((Component)__instance.m_depthTitle).gameObject.SetActive(false);
			((Component)__instance.m_artifactHeatTitle).gameObject.SetActive(false);
			CoroutineManager.BlinkIn(__instance.m_title, 0.3f, (Transform)null);
			CoroutineManager.BlinkIn(__instance.m_wardenObjective, 1.1f, (Transform)null);
			CoroutineManager.BlinkIn(__instance.m_wardenIntel, 2.5f, (Transform)null);
			CoroutineManager.BlinkIn(__instance.m_depthTitle, 3f, (Transform)null);
			CoroutineManager.BlinkIn(__instance.m_artifactHeatTitle, 3.25f, (Transform)null);
			float num = 1.8f;
			float num2 = 0.4f;
			__instance.m_sectorIconMain.Setup((LG_LayerType)0, __instance.m_root, true, expeditionLP.MainCompletionCount > 0, true, 0.5f, 0.8f);
			((RectTransformComp)__instance.m_sectorIconMain).SetVisible(false);
			((RectTransformComp)__instance.m_sectorIconSecond).SetVisible(false);
			((RectTransformComp)__instance.m_sectorIconThird).SetVisible(false);
			((RectTransformComp)__instance.m_sectorIconAllCompleted).SetVisible(false);
			component.SetVisible(visible: false);
			__instance.m_sectorIconMain.StopBlink();
			__instance.m_sectorIconSecond.StopBlink();
			__instance.m_sectorIconThird.StopBlink();
			__instance.m_sectorIconAllCompleted.StopBlink();
			__instance.m_sectorIconMain.BlinkIn(num);
			num += num2;
			if (RundownManager.HasSecondaryLayer(__instance.m_data))
			{
				__instance.m_sectorIconSecond.Setup((LG_LayerType)1, __instance.m_root, true, expeditionLP.SecondaryCompletionCount > 0, true, 0.5f, 0.8f);
				__instance.m_sectorIconSecond.BlinkIn(num);
				num += num2;
			}
			if (RundownManager.HasThirdLayer(__instance.m_data))
			{
				__instance.m_sectorIconThird.Setup((LG_LayerType)2, __instance.m_root, true, expeditionLP.ThirdCompletionCount > 0, true, 0.5f, 0.8f);
				__instance.m_sectorIconThird.BlinkIn(num);
				num += num2;
			}
			if (expeditionLP.AllClearCount > 0)
			{
				__instance.m_sectorIconAllCompleted.BlinkIn(num);
				num += num2;
			}
			bool flag = expeditionLP.NoBoosterAllClearCount > 0;
			if ((LocalProgressionManager.Current.TryGetRundownConfig(rundownID, out var rundownConf) && rundownConf.EnableNoBoosterUsedProgressionForRundown && (rundownConf.AlwaysShowIcon || flag)) || (LocalProgressionManager.Current.TryGetExpeditionConfig(rundownID, __instance.m_tier, __instance.m_expIndex, out var expConf) && expConf.EnableNoBoosterUsedProgression && (expConf.AlwaysShowIcon || flag)))
			{
				component.SetupNoBoosterUsedIcon(flag);
				component.BlinkIn(num);
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class Patches_CM_ExpeditionIcon
	{
		private static readonly Color BORDER_COLOR = new Color(0f, 1f, 82f / 85f, 1f);

		private static readonly Color TEXT_COLOR = new Color(0f, 1f, 0.5882353f, 1f);

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_ExpeditionIcon_New), "UpdateBorderColor")]
		private static void Post_UpdateBorderColor(CM_ExpeditionIcon_New __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0033: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.Status != 5)
			{
				uint rundownID = LocalProgressionManager.Current.ActiveRundownID();
				if (((LocalProgressionManager.Current.TryGetRundownConfig(rundownID, out var rundownConf) && rundownConf.EnableNoBoosterUsedProgressionForRundown) || (LocalProgressionManager.Current.TryGetExpeditionConfig(rundownID, __instance.Tier, __instance.ExpIndex, out var expConf) && expConf.EnableNoBoosterUsedProgression)) && LocalProgressionManager.Current.GetExpeditionLP(rundownID, __instance.Tier, __instance.ExpIndex).NoBoosterAllClearCount > 0)
				{
					__instance.SetBorderColor(BORDER_COLOR);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class Patch_CM_PageExpeditionSuccess
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_PageExpeditionSuccess), "Setup")]
		private static void Post_Setup(CM_PageExpeditionSuccess __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<ExpeditionSuccessPage_NoBoosterIcon>() == (Object)null)
			{
				ExpeditionSuccessPage_NoBoosterIcon expeditionSuccessPage_NoBoosterIcon = ((Component)__instance).gameObject.AddComponent<ExpeditionSuccessPage_NoBoosterIcon>();
				expeditionSuccessPage_NoBoosterIcon.m_page = __instance;
				expeditionSuccessPage_NoBoosterIcon.Setup();
			}
		}
	}
	[HarmonyPatch]
	internal class Patches_CM_PageRundown_New
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_PageRundown_New), "Setup")]
		private static void Post_Setup(CM_PageRundown_New __instance)
		{
			LocalProgressionManager.Current.SetCurrentRundownPageInstance(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_PageRundown_New), "PlaceRundown")]
		private static void Post_PlaceRundown(CM_PageRundown_New __instance)
		{
			LocalProgressionManager.Current.OnNativeRundownProgressionUpdated();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_PageRundown_New), "OnEnable")]
		private static void Post_OnEnable(CM_PageRundown_New __instance)
		{
			LocalProgressionManager.Current.OnNativeRundownProgressionUpdated();
		}
	}
	[HarmonyPatch]
	internal class Patches_CM_RundownTierMarker
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_RundownTierMarker), "Setup")]
		private static void Post_Setup(CM_RundownTierMarker __instance)
		{
			RundownTierMarker_NoBoosterIcon rundownTierMarker_NoBoosterIcon = ((Component)__instance).gameObject.AddComponent<RundownTierMarker_NoBoosterIcon>();
			rundownTierMarker_NoBoosterIcon.m_tierMarker = __instance;
			rundownTierMarker_NoBoosterIcon.Setup();
		}
	}
	[HarmonyPatch]
	internal class FixEndScreen
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(DiscordManager), "UpdateDiscordDetails")]
		private static bool Pre_UpdateDiscordDetails()
		{
			return false;
		}
	}
	[HarmonyPatch]
	internal class Patches_GS_ExpeditionSuccess
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(GS_ExpeditionSuccess), "Enter")]
		private static void DoChangeState(GS_ExpeditionSuccess __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			pActiveExpedition activeExpeditionData = RundownManager.GetActiveExpeditionData();
			string text = LocalProgressionManager.Current.ExpeditionKey(activeExpeditionData.tier, activeExpeditionData.expeditionIndex);
			bool mainLayerCleared = (int)WardenObjectiveManager.CurrentState.main_status == 40;
			bool secondaryLayerCleared = (int)WardenObjectiveManager.CurrentState.second_status == 40;
			bool thirdLayerCleared = (int)WardenObjectiveManager.CurrentState.third_status == 40;
			bool clearedWithNoBooster = LocalProgressionManager.Current.AllSectorCompletedWithoutBoosterAndCheckpoint();
			LPLogger.Debug("Level cleared, recording - " + text);
			LocalProgressionManager.Current.RecordExpeditionSuccessForCurrentRundown(text, mainLayerCleared, secondaryLayerCleared, thirdLayerCleared, clearedWithNoBooster);
		}
	}
}
namespace LocalProgression.Data
{
	public class ExpeditionProgressionData
	{
		public string ExpeditionKey { get; set; } = string.Empty;


		public int MainCompletionCount { get; set; }

		public int SecondaryCompletionCount { get; set; }

		public int ThirdCompletionCount { get; set; }

		public int AllClearCount { get; set; }

		public int NoBoosterAllClearCount { get; set; }
	}
	public class ExpeditionProgressionConfig
	{
		public eRundownTier Tier { get; set; }

		public int ExpeditionIndex { get; set; }

		public bool EnableNoBoosterUsedProgression { get; set; }

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

	}
	public class RundownConfig
	{
		public uint RundownID { get; set; }

		public bool EnableNoBoosterUsedProgressionForRundown { get; set; }

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


		public List<ExpeditionProgressionConfig> Expeditions { get; set; } = new List<ExpeditionProgressionConfig>
		{
			new ExpeditionProgressionConfig()
		};


		internal int ComputeNoBoosterClearPossibleCount()
		{
			if (EnableNoBoosterUsedProgressionForRundown)
			{
				return int.MaxValue;
			}
			return Expeditions.TakeWhile((ExpeditionProgressionConfig conf) => conf.EnableNoBoosterUsedProgression).Count();
		}
	}
	public class RundownProgressonConfig
	{
		public List<RundownConfig> Configs { get; set; } = new List<RundownConfig>
		{
			new RundownConfig()
		};

	}
	public class RundownProgressionData
	{
		public string RundownName { get; set; } = string.Empty;


		public uint RundownID { get; set; }

		public Dictionary<string, ExpeditionProgressionData> LPData { get; set; } = new Dictionary<string, ExpeditionProgressionData>();


		public int MainClearCount { get; set; }

		public int SecondaryClearCount { get; set; }

		public int ThirdClearCount { get; set; }

		public int AllClearCount { get; set; }

		public int NoBoosterAllClearCount { get; set; }

		public void Reset()
		{
			RundownName = string.Empty;
			RundownID = 0u;
			LPData.Clear();
			int num2 = (NoBoosterAllClearCount = 0);
			int num4 = (AllClearCount = num2);
			int num6 = (ThirdClearCount = num4);
			int mainClearCount = (SecondaryClearCount = num6);
			MainClearCount = mainClearCount;
		}
	}
}
namespace LocalProgression.Component
{
	public class ExpeditionSuccessPage_NoBoosterIcon : MonoBehaviour
	{
		internal CM_PageExpeditionSuccess m_page;

		private CM_ExpeditionSectorIcon m_completeWithNoBoosterIcon;

		private SpriteRenderer m_icon;

		private SpriteRenderer m_bg;

		private TextMeshPro m_title;

		private TextMeshPro m_rightSideText;

		private NoBoosterIconGOWrapper Wrapper;

		internal void Setup()
		{
			if ((Object)(object)m_page == (Object)null)
			{
				LPLogger.Error("ExpeditionSuccess_NoBooster: Assign the page instance before setup");
			}
			else
			{
				if ((Object)(object)m_completeWithNoBoosterIcon != (Object)null)
				{
					return;
				}
				if ((Object)(object)Assets.NoBoosterIcon == (Object)null)
				{
					AssetAPI.OnAssetBundlesLoaded += delegate
					{
						LoadAsset();
						AssetAPI.OnAssetBundlesLoaded -= LoadAsset;
					};
				}
				else
				{
					LoadAsset();
				}
			}
		}

		private void LoadAsset()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Assets.NoBoosterIcon == (Object)null)
			{
				LPLogger.Error("ExpeditionSuccess_NoBooster.Setup: cannot instantiate NoBooster icon...");
				return;
			}
			m_completeWithNoBoosterIcon = ((Il2CppObjectBase)((GuiLayer)((CM_PageBase)m_page).m_guiLayer).AddRectComp(Assets.NoBoosterIcon, (GuiAnchor)1, new Vector2(1200f, 0f), m_page.m_sectorIconAlign)).Cast<CM_ExpeditionSectorIcon>();
			Wrapper = new NoBoosterIconGOWrapper(((Component)m_completeWithNoBoosterIcon).gameObject);
			m_bg = Wrapper.BGGO.GetComponent<SpriteRenderer>();
			m_icon = Wrapper.IconGO.GetComponent<SpriteRenderer>();
			m_title = Object.Instantiate<TextMeshPro>(m_page.m_sectorIconMain.m_title);
			m_title.transform.SetParent(Wrapper.ObjectiveIcon.transform, false);
			m_rightSideText = Object.Instantiate<TextMeshPro>(m_page.m_sectorIconMain.m_rightSideText);
			m_rightSideText.transform.SetParent(Wrapper.RightSideText.transform, false);
			m_completeWithNoBoosterIcon.m_title = m_title;
			m_completeWithNoBoosterIcon.m_rightSideText = m_rightSideText;
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(false);
		}

		private void OnEnable()
		{
			//IL_003b: 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_00a5: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Invalid comparison between Unknown and I4
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(false);
			uint rundownID = LocalProgressionManager.Current.ActiveRundownID();
			pActiveExpedition activeExpeditionData = RundownManager.GetActiveExpeditionData();
			if ((LocalProgressionManager.Current.TryGetRundownConfig(rundownID, out var rundownConf) && rundownConf.EnableNoBoosterUsedProgressionForRundown) || (LocalProgressionManager.Current.TryGetExpeditionConfig(rundownID, activeExpeditionData.tier, activeExpeditionData.expeditionIndex, out var expConf) && expConf.EnableNoBoosterUsedProgression))
			{
				bool boosterUnused = LocalProgressionManager.Current.AllSectorCompletedWithoutBoosterAndCheckpoint();
				int num = 1;
				bool flag = RundownManager.HasSecondaryLayer(RundownManager.ActiveExpedition);
				bool flag2 = RundownManager.HasThirdLayer(RundownManager.ActiveExpedition);
				num += (flag ? 1 : 0);
				num += (flag2 ? 1 : 0);
				num += ((flag && (int)WardenObjectiveManager.CurrentState.second_status == 40 && flag2 && (int)WardenObjectiveManager.CurrentState.second_status == 40) ? 1 : 0);
				float num2 = m_page.m_time_sectorIcon + (float)num * 0.7f;
				SetupNoBoosterUsedIcon(boosterUnused);
				((RectTransformComp)m_completeWithNoBoosterIcon).SetPosition(new Vector2((float)num * 400f, 0f));
				m_completeWithNoBoosterIcon.BlinkIn(num2);
			}
		}

		private void SetupNoBoosterUsedIcon(bool boosterUnused)
		{
			//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_0098: 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: 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_00b0: 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)
			//IL_00d5: 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_00e1: 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)
			CM_ExpeditionSectorIcon completeWithNoBoosterIcon = m_completeWithNoBoosterIcon;
			completeWithNoBoosterIcon.m_isFinishedAll = true;
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconMainSkull, completeWithNoBoosterIcon.m_iconMainBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconSecondarySkull, completeWithNoBoosterIcon.m_iconSecondaryBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconThirdSkull, completeWithNoBoosterIcon.m_iconThirdBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconFinishedAllSkull, completeWithNoBoosterIcon.m_iconFinishedAllBG, false, false, 0.5f, 0.7f);
			Color color = m_icon.color;
			Color color2 = m_bg.color;
			m_icon.color = new Color(color.r, color.g, color.b, boosterUnused ? 1f : 0.4f);
			m_bg.color = new Color(color2.r, color2.g, color2.b, boosterUnused ? 1f : 0.3f);
			((TMP_Text)m_title).alpha = (boosterUnused ? 1f : 0.2f);
			completeWithNoBoosterIcon.m_titleVisible = true;
			completeWithNoBoosterIcon.m_isCleared = boosterUnused;
			if (boosterUnused)
			{
				completeWithNoBoosterIcon.m_isFinishedAll = true;
			}
			else
			{
				completeWithNoBoosterIcon.m_isFinishedAll = false;
				completeWithNoBoosterIcon.m_type = (LG_LayerType)0;
			}
			((Component)completeWithNoBoosterIcon.m_rightSideText).gameObject.SetActive(false);
			TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock("InGame.ExpeditionSuccessPage.AllClearWithNoBoosterUsed");
			if (block != null)
			{
				((TMP_Text)completeWithNoBoosterIcon.m_title).SetText(Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID), true);
			}
			else
			{
				((TMP_Text)completeWithNoBoosterIcon.m_title).SetText("<color=orange>OMNIPOTENT</color>", true);
			}
			((Component)completeWithNoBoosterIcon.m_title).gameObject.SetActive(true);
		}

		private void OnDestroy()
		{
			m_icon = (m_bg = null);
			m_completeWithNoBoosterIcon = null;
			Wrapper.Destory();
		}

		static ExpeditionSuccessPage_NoBoosterIcon()
		{
			ClassInjector.RegisterTypeInIl2Cpp<ExpeditionSuccessPage_NoBoosterIcon>();
		}
	}
	internal class ExpeditionWindow_NoBoosterIcon : MonoBehaviour
	{
		internal CM_ExpeditionWindow m_window;

		private CM_ExpeditionSectorIcon m_completeWithNoBoosterIcon;

		private NoBoosterIconGOWrapper Wrapper;

		private SpriteRenderer m_icon;

		private SpriteRenderer m_bg;

		private TextMeshPro m_title;

		private TextMeshPro m_rightSideText;

		internal void InitialSetup()
		{
			if ((Object)(object)m_window == (Object)null)
			{
				LPLogger.Error("ExpeditionSuccess_NoBooster: Assign the page instance before setup");
			}
			else
			{
				if ((Object)(object)m_completeWithNoBoosterIcon != (Object)null)
				{
					return;
				}
				if ((Object)(object)Assets.NoBoosterIcon == (Object)null)
				{
					AssetAPI.OnAssetBundlesLoaded += delegate
					{
						LoadAsset();
						AssetAPI.OnAssetBundlesLoaded -= LoadAsset;
					};
				}
				else
				{
					LoadAsset();
				}
			}
		}

		private void LoadAsset()
		{
			if ((Object)(object)Assets.NoBoosterIcon == (Object)null)
			{
				LPLogger.Error("ExpeditionSuccess_NoBooster.Setup: cannot instantiate NoBooster icon...");
				return;
			}
			m_completeWithNoBoosterIcon = GOUtil.SpawnChildAndGetComp<CM_ExpeditionSectorIcon>(Assets.NoBoosterIcon, m_window.m_sectorIconAlign);
			Wrapper = new NoBoosterIconGOWrapper(((Component)m_completeWithNoBoosterIcon).gameObject);
			m_bg = Wrapper.BGGO.GetComponent<SpriteRenderer>();
			m_icon = Wrapper.IconGO.GetComponent<SpriteRenderer>();
			m_title = Object.Instantiate<TextMeshPro>(m_window.m_sectorIconMain.m_title);
			m_title.transform.SetParent(Wrapper.ObjectiveIcon.transform, false);
			m_rightSideText = Object.Instantiate<TextMeshPro>(m_window.m_sectorIconMain.m_rightSideText);
			m_rightSideText.transform.SetParent(Wrapper.RightSideText.transform, false);
			m_completeWithNoBoosterIcon.m_title = m_title;
			m_completeWithNoBoosterIcon.m_rightSideText = m_rightSideText;
			((RectTransformComp)m_completeWithNoBoosterIcon).SetAnchor((GuiAnchor)1, true);
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(false);
			m_completeWithNoBoosterIcon.SortAsPopupLayer();
			m_completeWithNoBoosterIcon.m_root = m_window.m_root;
		}

		internal void SetVisible(bool visible)
		{
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(visible);
		}

		internal void SetIconPosition(Vector2 position)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((RectTransformComp)m_completeWithNoBoosterIcon).SetPosition(position);
		}

		internal void BlinkIn(float delay)
		{
			m_completeWithNoBoosterIcon.BlinkIn(delay);
		}

		internal void SetupNoBoosterUsedIcon(bool boosterUnused)
		{
			//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_0098: 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: 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_00b0: 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)
			//IL_00d5: 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_00e1: 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)
			CM_ExpeditionSectorIcon completeWithNoBoosterIcon = m_completeWithNoBoosterIcon;
			completeWithNoBoosterIcon.m_isFinishedAll = true;
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconMainSkull, completeWithNoBoosterIcon.m_iconMainBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconSecondarySkull, completeWithNoBoosterIcon.m_iconSecondaryBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconThirdSkull, completeWithNoBoosterIcon.m_iconThirdBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconFinishedAllSkull, completeWithNoBoosterIcon.m_iconFinishedAllBG, false, false, 0.5f, 0.7f);
			Color color = m_icon.color;
			Color color2 = m_bg.color;
			m_icon.color = new Color(color.r, color.g, color.b, boosterUnused ? 1f : 0.4f);
			m_bg.color = new Color(color2.r, color2.g, color2.b, boosterUnused ? 1f : 0.3f);
			((TMP_Text)m_title).alpha = (boosterUnused ? 1f : 0.2f);
			completeWithNoBoosterIcon.m_titleVisible = true;
			completeWithNoBoosterIcon.m_isCleared = boosterUnused;
			if (boosterUnused)
			{
				completeWithNoBoosterIcon.m_isFinishedAll = true;
			}
			else
			{
				completeWithNoBoosterIcon.m_isFinishedAll = false;
				completeWithNoBoosterIcon.m_type = (LG_LayerType)0;
			}
			((Component)completeWithNoBoosterIcon.m_rightSideText).gameObject.SetActive(false);
			TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock("InGame.ExpeditionSuccessPage.AllClearWithNoBoosterUsed");
			if (block != null)
			{
				((TMP_Text)completeWithNoBoosterIcon.m_title).SetText(Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID), true);
			}
			else
			{
				((TMP_Text)completeWithNoBoosterIcon.m_title).SetText("<color=orange>OMNIPOTENT</color>", true);
			}
			((Component)completeWithNoBoosterIcon.m_title).gameObject.SetActive(true);
		}

		private void OnDestroy()
		{
			m_icon = (m_bg = null);
			m_completeWithNoBoosterIcon = null;
			Wrapper.Destory();
		}

		static ExpeditionWindow_NoBoosterIcon()
		{
			ClassInjector.RegisterTypeInIl2Cpp<ExpeditionWindow_NoBoosterIcon>();
		}
	}
	public class NoBoosterIconGOWrapper
	{
		public GameObject GameObject { get; private set; }

		public GameObject ObjectiveIcon
		{
			get
			{
				GameObject gameObject = GameObject;
				if (gameObject == null)
				{
					return null;
				}
				return ((Component)gameObject.transform.GetChild(0)).gameObject;
			}
		}

		public GameObject BGHolder
		{
			get
			{
				GameObject objectiveIcon = ObjectiveIcon;
				if (objectiveIcon == null)
				{
					return null;
				}
				return ((Component)objectiveIcon.transform.GetChild(2)).gameObject;
			}
		}

		public GameObject SkullHolder
		{
			get
			{
				GameObject objectiveIcon = ObjectiveIcon;
				if (objectiveIcon == null)
				{
					return null;
				}
				return ((Component)objectiveIcon.transform.GetChild(3)).gameObject;
			}
		}

		public GameObject BGGO
		{
			get
			{
				GameObject bGHolder = BGHolder;
				if (bGHolder == null)
				{
					return null;
				}
				return ((Component)bGHolder.transform.GetChild(4)).gameObject;
			}
		}

		public GameObject IconGO
		{
			get
			{
				GameObject skullHolder = SkullHolder;
				if (skullHolder == null)
				{
					return null;
				}
				return ((Component)skullHolder.transform.GetChild(4)).gameObject;
			}
		}

		public GameObject TitleGO
		{
			get
			{
				GameObject objectiveIcon = ObjectiveIcon;
				if (objectiveIcon == null)
				{
					return null;
				}
				return ((Component)objectiveIcon.transform.GetChild(1)).gameObject;
			}
		}

		public GameObject RightSideText
		{
			get
			{
				GameObject gameObject = GameObject;
				if (gameObject == null)
				{
					return null;
				}
				return ((Component)gameObject.transform.GetChild(2)).gameObject;
			}
		}

		public NoBoosterIconGOWrapper(GameObject iconGO)
		{
			GameObject = iconGO;
		}

		public void Destory()
		{
			if ((Object)(object)GameObject != (Object)null)
			{
				Object.Destroy((Object)(object)GameObject);
			}
			GameObject = null;
		}
	}
	internal class RundownTierMarker_NoBoosterIcon : MonoBehaviour
	{
		internal CM_RundownTierMarker m_tierMarker;

		private CM_ExpeditionSectorIcon m_completeWithNoBoosterIcon;

		private SpriteRenderer m_icon;

		private SpriteRenderer m_bg;

		private TextMeshPro m_title;

		private TextMeshPro m_rightSideText;

		private NoBoosterIconGOWrapper Wrapper;

		internal void Setup()
		{
			if ((Object)(object)m_tierMarker == (Object)null)
			{
				LPLogger.Error("ExpeditionSuccess_NoBooster: Assign the page instance before setup");
			}
			else
			{
				if ((Object)(object)m_completeWithNoBoosterIcon != (Object)null)
				{
					return;
				}
				if ((Object)(object)Assets.NoBoosterIcon == (Object)null)
				{
					AssetAPI.OnAssetBundlesLoaded += delegate
					{
						LoadAsset();
						AssetAPI.OnAssetBundlesLoaded -= LoadAsset;
					};
				}
				else
				{
					LoadAsset();
				}
			}
		}

		private void LoadAsset()
		{
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_015f: 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_016b: 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)
			if ((Object)(object)Assets.NoBoosterIcon == (Object)null)
			{
				LPLogger.Error("ExpeditionSuccess_NoBooster.Setup: cannot instantiate NoBooster icon...");
				return;
			}
			m_completeWithNoBoosterIcon = GOUtil.SpawnChildAndGetComp<CM_ExpeditionSectorIcon>(Assets.NoBoosterIcon, m_tierMarker.m_sectorIconAlign_main);
			Wrapper = new NoBoosterIconGOWrapper(((Component)m_completeWithNoBoosterIcon).gameObject);
			m_bg = Wrapper.BGGO.GetComponent<SpriteRenderer>();
			m_icon = Wrapper.IconGO.GetComponent<SpriteRenderer>();
			m_title = Object.Instantiate<TextMeshPro>(m_tierMarker.m_sectorIconSummaryMain.m_title);
			m_title.transform.SetParent(Wrapper.ObjectiveIcon.transform, false);
			m_rightSideText = Object.Instantiate<TextMeshPro>(m_tierMarker.m_sectorIconSummaryMain.m_rightSideText);
			m_rightSideText.transform.SetParent(Wrapper.RightSideText.transform, false);
			m_completeWithNoBoosterIcon.m_title = m_title;
			m_completeWithNoBoosterIcon.m_rightSideText = m_rightSideText;
			SetupNoBoosterUsedIcon(boosterUnused: true);
			float num = 0.16f;
			Vector3 localScale = default(Vector3);
			((Vector3)(ref localScale))..ctor(num, num, num);
			_ = num / 0.16f;
			((Component)m_completeWithNoBoosterIcon).transform.localScale = localScale;
			Vector2 val = ((RectTransformComp)m_tierMarker.m_sectorIconSummarySecondary).GetPosition() - ((RectTransformComp)m_tierMarker.m_sectorIconSummaryMain).GetPosition();
			((RectTransformComp)m_completeWithNoBoosterIcon).SetPosition(val * 4f);
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(false);
		}

		internal void SetVisible(bool visible)
		{
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(visible);
		}

		internal void SetSectorIconText(string text)
		{
			((RectTransformComp)m_completeWithNoBoosterIcon).SetVisible(true);
			m_completeWithNoBoosterIcon.SetRightSideText(text);
		}

		private void SetupNoBoosterUsedIcon(bool boosterUnused)
		{
			//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_0098: 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: 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_00b0: 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)
			//IL_00d5: 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_00e1: 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)
			CM_ExpeditionSectorIcon completeWithNoBoosterIcon = m_completeWithNoBoosterIcon;
			completeWithNoBoosterIcon.m_isFinishedAll = true;
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconMainSkull, completeWithNoBoosterIcon.m_iconMainBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconSecondarySkull, completeWithNoBoosterIcon.m_iconSecondaryBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconThirdSkull, completeWithNoBoosterIcon.m_iconThirdBG, false, false, 0.5f, 0.7f);
			completeWithNoBoosterIcon.SetupIcon(completeWithNoBoosterIcon.m_iconFinishedAllSkull, completeWithNoBoosterIcon.m_iconFinishedAllBG, false, false, 0.5f, 0.7f);
			Color color = m_icon.color;
			Color color2 = m_bg.color;
			m_icon.color = new Color(color.r, color.g, color.b, boosterUnused ? 1f : 0.4f);
			m_bg.color = new Color(color2.r, color2.g, color2.b, boosterUnused ? 1f : 0.3f);
			((TMP_Text)m_title).alpha = (boosterUnused ? 1f : 0.2f);
			completeWithNoBoosterIcon.m_titleVisible = true;
			completeWithNoBoosterIcon.m_isCleared = boosterUnused;
			if (boosterUnused)
			{
				completeWithNoBoosterIcon.m_isFinishedAll = true;
			}
			else
			{
				completeWithNoBoosterIcon.m_isFinishedAll = false;
				completeWithNoBoosterIcon.m_type = (LG_LayerType)0;
			}
			((Component)completeWithNoBoosterIcon.m_rightSideText).gameObject.SetActive(false);
			TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock("InGame.ExpeditionSuccessPage.AllClearWithNoBoosterUsed");
			if (block != null)
			{
				((TMP_Text)completeWithNoBoosterIcon.m_title).SetText(Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID), true);
			}
			else
			{
				((TMP_Text)completeWithNoBoosterIcon.m_title).SetText("<color=orange>OMNIPOTENT</color>", true);
			}
			((Component)completeWithNoBoosterIcon.m_title).gameObject.SetActive(true);
		}

		static RundownTierMarker_NoBoosterIcon()
		{
			ClassInjector.RegisterTypeInIl2Cpp<RundownTierMarker_NoBoosterIcon>();
		}
	}
}

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

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Linq.JsonPath;
using Newtonsoft.Json.Schema;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")]
[assembly: CLSCompliant(true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Newtonsoft")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © James Newton-King 2008")]
[assembly: AssemblyDescription("Json.NET is a popular high-performance JSON framework for .NET")]
[assembly: AssemblyFileVersion("13.0.3.27908")]
[assembly: AssemblyInformationalVersion("13.0.3+0a2e291c0d9c0c7675d445703e51750363a549ef")]
[assembly: AssemblyProduct("Json.NET")]
[assembly: AssemblyTitle("Json.NET .NET 6.0")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/JamesNK/Newtonsoft.Json")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("13.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Newtonsoft.Json
{
	public enum ConstructorHandling
	{
		Default,
		AllowNonPublicDefaultConstructor
	}
	public enum DateFormatHandling
	{
		IsoDateFormat,
		MicrosoftDateFormat
	}
	public enum DateParseHandling
	{
		None,
		DateTime,
		DateTimeOffset
	}
	public enum DateTimeZoneHandling
	{
		Local,
		Utc,
		Unspecified,
		RoundtripKind
	}
	public class DefaultJsonNameTable : JsonNameTable
	{
		private class Entry
		{
			internal readonly string Value;

			internal readonly int HashCode;

			internal Entry Next;

			internal Entry(string value, int hashCode, Entry next)
			{
				Value = value;
				HashCode = hashCode;
				Next = next;
			}
		}

		private static readonly int HashCodeRandomizer;

		private int _count;

		private Entry[] _entries;

		private int _mask = 31;

		static DefaultJsonNameTable()
		{
			HashCodeRandomizer = Environment.TickCount;
		}

		public DefaultJsonNameTable()
		{
			_entries = new Entry[_mask + 1];
		}

		public override string? Get(char[] key, int start, int length)
		{
			if (length == 0)
			{
				return string.Empty;
			}
			int num = length + HashCodeRandomizer;
			num += (num << 7) ^ key[start];
			int num2 = start + length;
			for (int i = start + 1; i < num2; i++)
			{
				num += (num << 7) ^ key[i];
			}
			num -= num >> 17;
			num -= num >> 11;
			num -= num >> 5;
			int num3 = Volatile.Read(ref _mask);
			int num4 = num & num3;
			for (Entry entry = _entries[num4]; entry != null; entry = entry.Next)
			{
				if (entry.HashCode == num && TextEquals(entry.Value, key, start, length))
				{
					return entry.Value;
				}
			}
			return null;
		}

		public string Add(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			int length = key.Length;
			if (length == 0)
			{
				return string.Empty;
			}
			int num = length + HashCodeRandomizer;
			for (int i = 0; i < key.Length; i++)
			{
				num += (num << 7) ^ key[i];
			}
			num -= num >> 17;
			num -= num >> 11;
			num -= num >> 5;
			for (Entry entry = _entries[num & _mask]; entry != null; entry = entry.Next)
			{
				if (entry.HashCode == num && entry.Value.Equals(key, StringComparison.Ordinal))
				{
					return entry.Value;
				}
			}
			return AddEntry(key, num);
		}

		private string AddEntry(string str, int hashCode)
		{
			int num = hashCode & _mask;
			Entry entry = new Entry(str, hashCode, _entries[num]);
			_entries[num] = entry;
			if (_count++ == _mask)
			{
				Grow();
			}
			return entry.Value;
		}

		private void Grow()
		{
			Entry[] entries = _entries;
			int num = _mask * 2 + 1;
			Entry[] array = new Entry[num + 1];
			for (int i = 0; i < entries.Length; i++)
			{
				Entry entry = entries[i];
				while (entry != null)
				{
					int num2 = entry.HashCode & num;
					Entry next = entry.Next;
					entry.Next = array[num2];
					array[num2] = entry;
					entry = next;
				}
			}
			_entries = array;
			Volatile.Write(ref _mask, num);
		}

		private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
		{
			if (str1.Length != str2Length)
			{
				return false;
			}
			for (int i = 0; i < str1.Length; i++)
			{
				if (str1[i] != str2[str2Start + i])
				{
					return false;
				}
			}
			return true;
		}
	}
	[Flags]
	public enum DefaultValueHandling
	{
		Include = 0,
		Ignore = 1,
		Populate = 2,
		IgnoreAndPopulate = 3
	}
	public enum FloatFormatHandling
	{
		String,
		Symbol,
		DefaultValue
	}
	public enum FloatParseHandling
	{
		Double,
		Decimal
	}
	public enum Formatting
	{
		None,
		Indented
	}
	public interface IArrayPool<T>
	{
		T[] Rent(int minimumLength);

		void Return(T[]? array);
	}
	public interface IJsonLineInfo
	{
		int LineNumber { get; }

		int LinePosition { get; }

		bool HasLineInfo();
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	public sealed class JsonArrayAttribute : JsonContainerAttribute
	{
		private bool _allowNullItems;

		public bool AllowNullItems
		{
			get
			{
				return _allowNullItems;
			}
			set
			{
				_allowNullItems = value;
			}
		}

		public JsonArrayAttribute()
		{
		}

		public JsonArrayAttribute(bool allowNullItems)
		{
			_allowNullItems = allowNullItems;
		}

		public JsonArrayAttribute(string id)
			: base(id)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
	public sealed class JsonConstructorAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	public abstract class JsonContainerAttribute : Attribute
	{
		internal bool? _isReference;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		private Type? _namingStrategyType;

		private object[]? _namingStrategyParameters;

		public string? Id { get; set; }

		public string? Title { get; set; }

		public string? Description { get; set; }

		public Type? ItemConverterType { get; set; }

		public object[]? ItemConverterParameters { get; set; }

		public Type? NamingStrategyType
		{
			get
			{
				return _namingStrategyType;
			}
			set
			{
				_namingStrategyType = value;
				NamingStrategyInstance = null;
			}
		}

		public object[]? NamingStrategyParameters
		{
			get
			{
				return _namingStrategyParameters;
			}
			set
			{
				_namingStrategyParameters = value;
				NamingStrategyInstance = null;
			}
		}

		internal NamingStrategy? NamingStrategyInstance { get; set; }

		public bool IsReference
		{
			get
			{
				return _isReference.GetValueOrDefault();
			}
			set
			{
				_isReference = value;
			}
		}

		public bool ItemIsReference
		{
			get
			{
				return _itemIsReference.GetValueOrDefault();
			}
			set
			{
				_itemIsReference = value;
			}
		}

		public ReferenceLoopHandling ItemReferenceLoopHandling
		{
			get
			{
				return _itemReferenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_itemReferenceLoopHandling = value;
			}
		}

		public TypeNameHandling ItemTypeNameHandling
		{
			get
			{
				return _itemTypeNameHandling.GetValueOrDefault();
			}
			set
			{
				_itemTypeNameHandling = value;
			}
		}

		protected JsonContainerAttribute()
		{
		}

		protected JsonContainerAttribute(string id)
		{
			Id = id;
		}
	}
	public static class JsonConvert
	{
		public static readonly string True = "true";

		public static readonly string False = "false";

		public static readonly string Null = "null";

		public static readonly string Undefined = "undefined";

		public static readonly string PositiveInfinity = "Infinity";

		public static readonly string NegativeInfinity = "-Infinity";

		public static readonly string NaN = "NaN";

		public static Func<JsonSerializerSettings>? DefaultSettings { get; set; }

		public static string ToString(DateTime value)
		{
			return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
		}

		public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
		{
			DateTime value2 = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
			using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
			stringWriter.Write('"');
			DateTimeUtils.WriteDateTimeString(stringWriter, value2, format, null, CultureInfo.InvariantCulture);
			stringWriter.Write('"');
			return stringWriter.ToString();
		}

		public static string ToString(DateTimeOffset value)
		{
			return ToString(value, DateFormatHandling.IsoDateFormat);
		}

		public static string ToString(DateTimeOffset value, DateFormatHandling format)
		{
			using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
			stringWriter.Write('"');
			DateTimeUtils.WriteDateTimeOffsetString(stringWriter, value, format, null, CultureInfo.InvariantCulture);
			stringWriter.Write('"');
			return stringWriter.ToString();
		}

		public static string ToString(bool value)
		{
			if (!value)
			{
				return False;
			}
			return True;
		}

		public static string ToString(char value)
		{
			return ToString(char.ToString(value));
		}

		public static string ToString(Enum value)
		{
			return value.ToString("D");
		}

		public static string ToString(int value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(short value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(ushort value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(uint value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(long value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		private static string ToStringInternal(BigInteger value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(ulong value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(float value)
		{
			return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
		}

		internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
		{
			return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
		}

		private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
		{
			if (floatFormatHandling == FloatFormatHandling.Symbol || (!double.IsInfinity(value) && !double.IsNaN(value)))
			{
				return text;
			}
			if (floatFormatHandling == FloatFormatHandling.DefaultValue)
			{
				if (nullable)
				{
					return Null;
				}
				return "0.0";
			}
			return quoteChar + text + quoteChar;
		}

		public static string ToString(double value)
		{
			return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
		}

		internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
		{
			return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
		}

		private static string EnsureDecimalPlace(double value, string text)
		{
			if (double.IsNaN(value) || double.IsInfinity(value) || StringUtils.IndexOf(text, '.') != -1 || StringUtils.IndexOf(text, 'E') != -1 || StringUtils.IndexOf(text, 'e') != -1)
			{
				return text;
			}
			return text + ".0";
		}

		private static string EnsureDecimalPlace(string text)
		{
			if (StringUtils.IndexOf(text, '.') != -1)
			{
				return text;
			}
			return text + ".0";
		}

		public static string ToString(byte value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(sbyte value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(decimal value)
		{
			return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
		}

		public static string ToString(Guid value)
		{
			return ToString(value, '"');
		}

		internal static string ToString(Guid value, char quoteChar)
		{
			string text = value.ToString("D", CultureInfo.InvariantCulture);
			string text2 = quoteChar.ToString(CultureInfo.InvariantCulture);
			return text2 + text + text2;
		}

		public static string ToString(TimeSpan value)
		{
			return ToString(value, '"');
		}

		internal static string ToString(TimeSpan value, char quoteChar)
		{
			return ToString(value.ToString(), quoteChar);
		}

		public static string ToString(Uri? value)
		{
			if (value == null)
			{
				return Null;
			}
			return ToString(value, '"');
		}

		internal static string ToString(Uri value, char quoteChar)
		{
			return ToString(value.OriginalString, quoteChar);
		}

		public static string ToString(string? value)
		{
			return ToString(value, '"');
		}

		public static string ToString(string? value, char delimiter)
		{
			return ToString(value, delimiter, StringEscapeHandling.Default);
		}

		public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling)
		{
			if (delimiter != '"' && delimiter != '\'')
			{
				throw new ArgumentException("Delimiter must be a single or double quote.", "delimiter");
			}
			return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, appendDelimiters: true, stringEscapeHandling);
		}

		public static string ToString(object? value)
		{
			if (value == null)
			{
				return Null;
			}
			return ConvertUtils.GetTypeCode(value.GetType()) switch
			{
				PrimitiveTypeCode.String => ToString((string)value), 
				PrimitiveTypeCode.Char => ToString((char)value), 
				PrimitiveTypeCode.Boolean => ToString((bool)value), 
				PrimitiveTypeCode.SByte => ToString((sbyte)value), 
				PrimitiveTypeCode.Int16 => ToString((short)value), 
				PrimitiveTypeCode.UInt16 => ToString((ushort)value), 
				PrimitiveTypeCode.Int32 => ToString((int)value), 
				PrimitiveTypeCode.Byte => ToString((byte)value), 
				PrimitiveTypeCode.UInt32 => ToString((uint)value), 
				PrimitiveTypeCode.Int64 => ToString((long)value), 
				PrimitiveTypeCode.UInt64 => ToString((ulong)value), 
				PrimitiveTypeCode.Single => ToString((float)value), 
				PrimitiveTypeCode.Double => ToString((double)value), 
				PrimitiveTypeCode.DateTime => ToString((DateTime)value), 
				PrimitiveTypeCode.Decimal => ToString((decimal)value), 
				PrimitiveTypeCode.DBNull => Null, 
				PrimitiveTypeCode.DateTimeOffset => ToString((DateTimeOffset)value), 
				PrimitiveTypeCode.Guid => ToString((Guid)value), 
				PrimitiveTypeCode.Uri => ToString((Uri)value), 
				PrimitiveTypeCode.TimeSpan => ToString((TimeSpan)value), 
				PrimitiveTypeCode.BigInteger => ToStringInternal((BigInteger)value), 
				_ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())), 
			};
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value)
		{
			return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Formatting formatting)
		{
			return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, params JsonConverter[] converters)
		{
			JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
			{
				Converters = converters
			} : null);
			return SerializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters)
		{
			JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
			{
				Converters = converters
			} : null);
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, JsonSerializerSettings? settings)
		{
			return SerializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
		{
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			jsonSerializer.Formatting = formatting;
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer)
		{
			StringWriter stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture);
			using (JsonTextWriter jsonTextWriter = new JsonTextWriter(stringWriter))
			{
				jsonTextWriter.Formatting = jsonSerializer.Formatting;
				jsonSerializer.Serialize(jsonTextWriter, value, type);
			}
			return stringWriter.ToString();
		}

		[DebuggerStepThrough]
		public static object? DeserializeObject(string value)
		{
			return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static object? DeserializeObject(string value, JsonSerializerSettings settings)
		{
			return DeserializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		public static object? DeserializeObject(string value, Type type)
		{
			return DeserializeObject(value, type, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static T? DeserializeObject<T>(string value)
		{
			return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
		{
			return DeserializeObject<T>(value);
		}

		[DebuggerStepThrough]
		public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
		{
			return DeserializeObject<T>(value, settings);
		}

		[DebuggerStepThrough]
		public static T? DeserializeObject<T>(string value, params JsonConverter[] converters)
		{
			return (T)DeserializeObject(value, typeof(T), converters);
		}

		[DebuggerStepThrough]
		public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings)
		{
			return (T)DeserializeObject(value, typeof(T), settings);
		}

		[DebuggerStepThrough]
		public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters)
		{
			JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
			{
				Converters = converters
			} : null);
			return DeserializeObject(value, type, settings);
		}

		public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings)
		{
			ValidationUtils.ArgumentNotNull(value, "value");
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			if (!jsonSerializer.IsCheckAdditionalContentSet())
			{
				jsonSerializer.CheckAdditionalContent = true;
			}
			using JsonTextReader reader = new JsonTextReader(new StringReader(value));
			return jsonSerializer.Deserialize(reader, type);
		}

		[DebuggerStepThrough]
		public static void PopulateObject(string value, object target)
		{
			PopulateObject(value, target, null);
		}

		public static void PopulateObject(string value, object target, JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			using JsonReader jsonReader = new JsonTextReader(new StringReader(value));
			jsonSerializer.Populate(jsonReader, target);
			if (settings == null || !settings.CheckAdditionalContent)
			{
				return;
			}
			while (jsonReader.Read())
			{
				if (jsonReader.TokenType != JsonToken.Comment)
				{
					throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
				}
			}
		}

		public static string SerializeXmlNode(XmlNode? node)
		{
			return SerializeXmlNode(node, Formatting.None);
		}

		public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static XmlDocument? DeserializeXmlNode(string value)
		{
			return DeserializeXmlNode(value, null);
		}

		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
			xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
			xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
			return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter);
		}

		public static string SerializeXNode(XObject? node)
		{
			return SerializeXNode(node, Formatting.None);
		}

		public static string SerializeXNode(XObject? node, Formatting formatting)
		{
			return SerializeXNode(node, formatting, omitRootObject: false);
		}

		public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static XDocument? DeserializeXNode(string value)
		{
			return DeserializeXNode(value, null);
		}

		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
			xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
			xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
			return (XDocument)DeserializeObject(value, typeof(XDocument), xmlNodeConverter);
		}
	}
	public abstract class JsonConverter
	{
		public virtual bool CanRead => true;

		public virtual bool CanWrite => true;

		public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);

		public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);

		public abstract bool CanConvert(Type objectType);
	}
	public abstract class JsonConverter<T> : JsonConverter
	{
		public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T))))
			{
				throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
			}
			WriteJson(writer, (T)value, serializer);
		}

		public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer);

		public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			bool flag = existingValue == null;
			if (!flag && !(existingValue is T))
			{
				throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
			}
			return ReadJson(reader, objectType, flag ? default(T) : ((T)existingValue), !flag, serializer);
		}

		public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer);

		public sealed override bool CanConvert(Type objectType)
		{
			return typeof(T).IsAssignableFrom(objectType);
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
	public sealed class JsonConverterAttribute : Attribute
	{
		private readonly Type _converterType;

		public Type ConverterType => _converterType;

		public object[]? ConverterParameters { get; }

		public JsonConverterAttribute(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			_converterType = converterType;
		}

		public JsonConverterAttribute(Type converterType, params object[] converterParameters)
			: this(converterType)
		{
			ConverterParameters = converterParameters;
		}
	}
	public class JsonConverterCollection : Collection<JsonConverter>
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	public sealed class JsonDictionaryAttribute : JsonContainerAttribute
	{
		public JsonDictionaryAttribute()
		{
		}

		public JsonDictionaryAttribute(string id)
			: base(id)
		{
		}
	}
	[Serializable]
	public class JsonException : Exception
	{
		public JsonException()
		{
		}

		public JsonException(string message)
			: base(message)
		{
		}

		public JsonException(string message, Exception? innerException)
			: base(message, innerException)
		{
		}

		public JsonException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
		{
			message = JsonPosition.FormatMessage(lineInfo, path, message);
			return new JsonException(message);
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public class JsonExtensionDataAttribute : Attribute
	{
		public bool WriteData { get; set; }

		public bool ReadData { get; set; }

		public JsonExtensionDataAttribute()
		{
			WriteData = true;
			ReadData = true;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class JsonIgnoreAttribute : Attribute
	{
	}
	public abstract class JsonNameTable
	{
		public abstract string? Get(char[] key, int start, int length);
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
	public sealed class JsonObjectAttribute : JsonContainerAttribute
	{
		private MemberSerialization _memberSerialization;

		internal MissingMemberHandling? _missingMemberHandling;

		internal Required? _itemRequired;

		internal NullValueHandling? _itemNullValueHandling;

		public MemberSerialization MemberSerialization
		{
			get
			{
				return _memberSerialization;
			}
			set
			{
				_memberSerialization = value;
			}
		}

		public MissingMemberHandling MissingMemberHandling
		{
			get
			{
				return _missingMemberHandling.GetValueOrDefault();
			}
			set
			{
				_missingMemberHandling = value;
			}
		}

		public NullValueHandling ItemNullValueHandling
		{
			get
			{
				return _itemNullValueHandling.GetValueOrDefault();
			}
			set
			{
				_itemNullValueHandling = value;
			}
		}

		public Required ItemRequired
		{
			get
			{
				return _itemRequired.GetValueOrDefault();
			}
			set
			{
				_itemRequired = value;
			}
		}

		public JsonObjectAttribute()
		{
		}

		public JsonObjectAttribute(MemberSerialization memberSerialization)
		{
			MemberSerialization = memberSerialization;
		}

		public JsonObjectAttribute(string id)
			: base(id)
		{
		}
	}
	internal enum JsonContainerType
	{
		None,
		Object,
		Array,
		Constructor
	}
	internal struct JsonPosition
	{
		private static readonly char[] SpecialCharacters = new char[18]
		{
			'.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t',
			'\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029'
		};

		internal JsonContainerType Type;

		internal int Position;

		internal string? PropertyName;

		internal bool HasIndex;

		public JsonPosition(JsonContainerType type)
		{
			Type = type;
			HasIndex = TypeHasIndex(type);
			Position = -1;
			PropertyName = null;
		}

		internal int CalculateLength()
		{
			switch (Type)
			{
			case JsonContainerType.Object:
				return PropertyName.Length + 5;
			case JsonContainerType.Array:
			case JsonContainerType.Constructor:
				return MathUtils.IntLength((ulong)Position) + 2;
			default:
				throw new ArgumentOutOfRangeException("Type");
			}
		}

		internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer)
		{
			switch (Type)
			{
			case JsonContainerType.Object:
			{
				string propertyName = PropertyName;
				if (propertyName.IndexOfAny(SpecialCharacters) != -1)
				{
					sb.Append("['");
					if (writer == null)
					{
						writer = new StringWriter(sb);
					}
					JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', appendDelimiters: false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
					sb.Append("']");
				}
				else
				{
					if (sb.Length > 0)
					{
						sb.Append('.');
					}
					sb.Append(propertyName);
				}
				break;
			}
			case JsonContainerType.Array:
			case JsonContainerType.Constructor:
				sb.Append('[');
				sb.Append(Position);
				sb.Append(']');
				break;
			}
		}

		internal static bool TypeHasIndex(JsonContainerType type)
		{
			if (type != JsonContainerType.Array)
			{
				return type == JsonContainerType.Constructor;
			}
			return true;
		}

		internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition)
		{
			int num = 0;
			if (positions != null)
			{
				for (int i = 0; i < positions.Count; i++)
				{
					num += positions[i].CalculateLength();
				}
			}
			if (currentPosition.HasValue)
			{
				num += currentPosition.GetValueOrDefault().CalculateLength();
			}
			StringBuilder stringBuilder = new StringBuilder(num);
			StringWriter writer = null;
			char[] buffer = null;
			if (positions != null)
			{
				foreach (JsonPosition position in positions)
				{
					position.WriteTo(stringBuilder, ref writer, ref buffer);
				}
			}
			currentPosition?.WriteTo(stringBuilder, ref writer, ref buffer);
			return stringBuilder.ToString();
		}

		internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message)
		{
			if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
			{
				message = message.Trim();
				if (!message.EndsWith('.'))
				{
					message += ".";
				}
				message += " ";
			}
			message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
			}
			message += ".";
			return message;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
	public sealed class JsonPropertyAttribute : Attribute
	{
		internal NullValueHandling? _nullValueHandling;

		internal DefaultValueHandling? _defaultValueHandling;

		internal ReferenceLoopHandling? _referenceLoopHandling;

		internal ObjectCreationHandling? _objectCreationHandling;

		internal TypeNameHandling? _typeNameHandling;

		internal bool? _isReference;

		internal int? _order;

		internal Required? _required;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		public Type? ItemConverterType { get; set; }

		public object[]? ItemConverterParameters { get; set; }

		public Type? NamingStrategyType { get; set; }

		public object[]? NamingStrategyParameters { get; set; }

		public NullValueHandling NullValueHandling
		{
			get
			{
				return _nullValueHandling.GetValueOrDefault();
			}
			set
			{
				_nullValueHandling = value;
			}
		}

		public DefaultValueHandling DefaultValueHandling
		{
			get
			{
				return _defaultValueHandling.GetValueOrDefault();
			}
			set
			{
				_defaultValueHandling = value;
			}
		}

		public ReferenceLoopHandling ReferenceLoopHandling
		{
			get
			{
				return _referenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_referenceLoopHandling = value;
			}
		}

		public ObjectCreationHandling ObjectCreationHandling
		{
			get
			{
				return _objectCreationHandling.GetValueOrDefault();
			}
			set
			{
				_objectCreationHandling = value;
			}
		}

		public TypeNameHandling TypeNameHandling
		{
			get
			{
				return _typeNameHandling.GetValueOrDefault();
			}
			set
			{
				_typeNameHandling = value;
			}
		}

		public bool IsReference
		{
			get
			{
				return _isReference.GetValueOrDefault();
			}
			set
			{
				_isReference = value;
			}
		}

		public int Order
		{
			get
			{
				return _order.GetValueOrDefault();
			}
			set
			{
				_order = value;
			}
		}

		public Required Required
		{
			get
			{
				return _required.GetValueOrDefault();
			}
			set
			{
				_required = value;
			}
		}

		public string? PropertyName { get; set; }

		public ReferenceLoopHandling ItemReferenceLoopHandling
		{
			get
			{
				return _itemReferenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_itemReferenceLoopHandling = value;
			}
		}

		public TypeNameHandling ItemTypeNameHandling
		{
			get
			{
				return _itemTypeNameHandling.GetValueOrDefault();
			}
			set
			{
				_itemTypeNameHandling = value;
			}
		}

		public bool ItemIsReference
		{
			get
			{
				return _itemIsReference.GetValueOrDefault();
			}
			set
			{
				_itemIsReference = value;
			}
		}

		public JsonPropertyAttribute()
		{
		}

		public JsonPropertyAttribute(string propertyName)
		{
			PropertyName = propertyName;
		}
	}
	public abstract class JsonReader : IAsyncDisposable, IDisposable
	{
		protected internal enum State
		{
			Start,
			Complete,
			Property,
			ObjectStart,
			Object,
			ArrayStart,
			Array,
			Closed,
			PostValue,
			ConstructorStart,
			Constructor,
			Error,
			Finished
		}

		private JsonToken _tokenType;

		private object? _value;

		internal char _quoteChar;

		internal State _currentState;

		private JsonPosition _currentPosition;

		private CultureInfo? _culture;

		private DateTimeZoneHandling _dateTimeZoneHandling;

		private int? _maxDepth;

		private bool _hasExceededMaxDepth;

		internal DateParseHandling _dateParseHandling;

		internal FloatParseHandling _floatParseHandling;

		private string? _dateFormatString;

		private List<JsonPosition>? _stack;

		protected State CurrentState => _currentState;

		public bool CloseInput { get; set; }

		public bool SupportMultipleContent { get; set; }

		public virtual char QuoteChar
		{
			get
			{
				return _quoteChar;
			}
			protected internal set
			{
				_quoteChar = value;
			}
		}

		public DateTimeZoneHandling DateTimeZoneHandling
		{
			get
			{
				return _dateTimeZoneHandling;
			}
			set
			{
				if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_dateTimeZoneHandling = value;
			}
		}

		public DateParseHandling DateParseHandling
		{
			get
			{
				return _dateParseHandling;
			}
			set
			{
				if (value < DateParseHandling.None || value > DateParseHandling.DateTimeOffset)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_dateParseHandling = value;
			}
		}

		public FloatParseHandling FloatParseHandling
		{
			get
			{
				return _floatParseHandling;
			}
			set
			{
				if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_floatParseHandling = value;
			}
		}

		public string? DateFormatString
		{
			get
			{
				return _dateFormatString;
			}
			set
			{
				_dateFormatString = value;
			}
		}

		public int? MaxDepth
		{
			get
			{
				return _maxDepth;
			}
			set
			{
				if (value <= 0)
				{
					throw new ArgumentException("Value must be positive.", "value");
				}
				_maxDepth = value;
			}
		}

		public virtual JsonToken TokenType => _tokenType;

		public virtual object? Value => _value;

		public virtual Type? ValueType => _value?.GetType();

		public virtual int Depth
		{
			get
			{
				int num = _stack?.Count ?? 0;
				if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
				{
					return num;
				}
				return num + 1;
			}
		}

		public virtual string Path
		{
			get
			{
				if (_currentPosition.Type == JsonContainerType.None)
				{
					return string.Empty;
				}
				JsonPosition? currentPosition = ((_currentState != State.ArrayStart && _currentState != State.ConstructorStart && _currentState != State.ObjectStart) ? new JsonPosition?(_currentPosition) : null);
				return JsonPosition.BuildPath(_stack, currentPosition);
			}
		}

		public CultureInfo Culture
		{
			get
			{
				return _culture ?? CultureInfo.InvariantCulture;
			}
			set
			{
				_culture = value;
			}
		}

		ValueTask IAsyncDisposable.DisposeAsync()
		{
			try
			{
				Dispose(disposing: true);
				return default(ValueTask);
			}
			catch (Exception exception)
			{
				return ValueTask.FromException(exception);
			}
		}

		public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
		}

		public async Task SkipAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (TokenType == JsonToken.PropertyName)
			{
				await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			if (JsonTokenUtils.IsStartToken(TokenType))
			{
				int depth = Depth;
				while (await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) && depth < Depth)
				{
				}
			}
		}

		internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
		{
			if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
			{
				throw CreateUnexpectedEndException();
			}
		}

		public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
		}

		public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
		}

		internal async Task<byte[]?> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
		{
			List<byte> buffer = new List<byte>();
			do
			{
				if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					SetToken(JsonToken.None);
				}
			}
			while (!ReadArrayElementIntoByteArrayReportDone(buffer));
			byte[] array = buffer.ToArray();
			SetToken(JsonToken.Bytes, array, updateIndex: false);
			return array;
		}

		public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
		}

		public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
		}

		public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
		}

		public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return Task.FromResult(ReadAsDouble());
		}

		public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
		}

		public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
		}

		internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken)
		{
			bool flag = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (flag)
			{
				flag = await MoveToContentAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			return flag;
		}

		internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType = TokenType;
			if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
			{
				return MoveToContentFromNonContentAsync(cancellationToken);
			}
			return AsyncUtils.True;
		}

		private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType;
			do
			{
				if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					return false;
				}
				tokenType = TokenType;
			}
			while (tokenType == JsonToken.None || tokenType == JsonToken.Comment);
			return true;
		}

		internal JsonPosition GetPosition(int depth)
		{
			if (_stack != null && depth < _stack.Count)
			{
				return _stack[depth];
			}
			return _currentPosition;
		}

		protected JsonReader()
		{
			_currentState = State.Start;
			_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
			_dateParseHandling = DateParseHandling.DateTime;
			_floatParseHandling = FloatParseHandling.Double;
			_maxDepth = 64;
			CloseInput = true;
		}

		private void Push(JsonContainerType value)
		{
			UpdateScopeWithFinishedValue();
			if (_currentPosition.Type == JsonContainerType.None)
			{
				_currentPosition = new JsonPosition(value);
				return;
			}
			if (_stack == null)
			{
				_stack = new List<JsonPosition>();
			}
			_stack.Add(_currentPosition);
			_currentPosition = new JsonPosition(value);
			if (!_maxDepth.HasValue || !(Depth + 1 > _maxDepth) || _hasExceededMaxDepth)
			{
				return;
			}
			_hasExceededMaxDepth = true;
			throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
		}

		private JsonContainerType Pop()
		{
			JsonPosition currentPosition;
			if (_stack != null && _stack.Count > 0)
			{
				currentPosition = _currentPosition;
				_currentPosition = _stack[_stack.Count - 1];
				_stack.RemoveAt(_stack.Count - 1);
			}
			else
			{
				currentPosition = _currentPosition;
				_currentPosition = default(JsonPosition);
			}
			if (_maxDepth.HasValue && Depth <= _maxDepth)
			{
				_hasExceededMaxDepth = false;
			}
			return currentPosition.Type;
		}

		private JsonContainerType Peek()
		{
			return _currentPosition.Type;
		}

		public abstract bool Read();

		public virtual int? ReadAsInt32()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				object value = Value;
				if (value is int)
				{
					return (int)value;
				}
				int num;
				if (value is BigInteger bigInteger)
				{
					num = (int)bigInteger;
				}
				else
				{
					try
					{
						num = Convert.ToInt32(value, CultureInfo.InvariantCulture);
					}
					catch (Exception ex)
					{
						throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
					}
				}
				SetToken(JsonToken.Integer, num, updateIndex: false);
				return num;
			}
			case JsonToken.String:
			{
				string s = (string)Value;
				return ReadInt32String(s);
			}
			default:
				throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal int? ReadInt32String(string? s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (int.TryParse(s, NumberStyles.Integer, Culture, out var result))
			{
				SetToken(JsonToken.Integer, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual string? ReadAsString()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.String:
				return (string)Value;
			default:
				if (JsonTokenUtils.IsPrimitiveToken(contentToken))
				{
					object value = Value;
					if (value != null)
					{
						string text = ((!(value is IFormattable formattable)) ? ((value is Uri uri) ? uri.OriginalString : value.ToString()) : formattable.ToString(null, Culture));
						SetToken(JsonToken.String, text, updateIndex: false);
						return text;
					}
				}
				throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		public virtual byte[]? ReadAsBytes()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.StartObject:
			{
				ReadIntoWrappedTypeObject();
				byte[] array2 = ReadAsBytes();
				ReaderReadAndAssert();
				if (TokenType != JsonToken.EndObject)
				{
					throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
				}
				SetToken(JsonToken.Bytes, array2, updateIndex: false);
				return array2;
			}
			case JsonToken.String:
			{
				string text = (string)Value;
				Guid g;
				byte[] array3 = ((text.Length == 0) ? CollectionUtils.ArrayEmpty<byte>() : ((!ConvertUtils.TryConvertGuid(text, out g)) ? Convert.FromBase64String(text) : g.ToByteArray()));
				SetToken(JsonToken.Bytes, array3, updateIndex: false);
				return array3;
			}
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Bytes:
				if (Value is Guid guid)
				{
					byte[] array = guid.ToByteArray();
					SetToken(JsonToken.Bytes, array, updateIndex: false);
					return array;
				}
				return (byte[])Value;
			case JsonToken.StartArray:
				return ReadArrayIntoByteArray();
			default:
				throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal byte[] ReadArrayIntoByteArray()
		{
			List<byte> list = new List<byte>();
			do
			{
				if (!Read())
				{
					SetToken(JsonToken.None);
				}
			}
			while (!ReadArrayElementIntoByteArrayReportDone(list));
			byte[] array = list.ToArray();
			SetToken(JsonToken.Bytes, array, updateIndex: false);
			return array;
		}

		private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
		{
			switch (TokenType)
			{
			case JsonToken.None:
				throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
			case JsonToken.Integer:
				buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
				return false;
			case JsonToken.EndArray:
				return true;
			case JsonToken.Comment:
				return false;
			default:
				throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
			}
		}

		public virtual double? ReadAsDouble()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				object value = Value;
				if (value is double)
				{
					return (double)value;
				}
				double num = ((!(value is BigInteger bigInteger)) ? Convert.ToDouble(value, CultureInfo.InvariantCulture) : ((double)bigInteger));
				SetToken(JsonToken.Float, num, updateIndex: false);
				return num;
			}
			case JsonToken.String:
				return ReadDoubleString((string)Value);
			default:
				throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal double? ReadDoubleString(string? s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out var result))
			{
				SetToken(JsonToken.Float, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual bool? ReadAsBoolean()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				bool flag = ((!(Value is BigInteger bigInteger)) ? Convert.ToBoolean(Value, CultureInfo.InvariantCulture) : (bigInteger != 0L));
				SetToken(JsonToken.Boolean, flag, updateIndex: false);
				return flag;
			}
			case JsonToken.String:
				return ReadBooleanString((string)Value);
			case JsonToken.Boolean:
				return (bool)Value;
			default:
				throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal bool? ReadBooleanString(string? s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (bool.TryParse(s, out var result))
			{
				SetToken(JsonToken.Boolean, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual decimal? ReadAsDecimal()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				object value = Value;
				if (value is decimal)
				{
					return (decimal)value;
				}
				decimal num;
				if (value is BigInteger bigInteger)
				{
					num = (decimal)bigInteger;
				}
				else
				{
					try
					{
						num = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
					}
					catch (Exception ex)
					{
						throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
					}
				}
				SetToken(JsonToken.Float, num, updateIndex: false);
				return num;
			}
			case JsonToken.String:
				return ReadDecimalString((string)Value);
			default:
				throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal decimal? ReadDecimalString(string? s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (decimal.TryParse(s, NumberStyles.Number, Culture, out var result))
			{
				SetToken(JsonToken.Float, result, updateIndex: false);
				return result;
			}
			if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out result) == ParseResult.Success)
			{
				SetToken(JsonToken.Float, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual DateTime? ReadAsDateTime()
		{
			switch (GetContentToken())
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Date:
				if (Value is DateTimeOffset dateTimeOffset)
				{
					SetToken(JsonToken.Date, dateTimeOffset.DateTime, updateIndex: false);
				}
				return (DateTime)Value;
			case JsonToken.String:
				return ReadDateTimeString((string)Value);
			default:
				throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
			}
		}

		internal DateTime? ReadDateTimeString(string? s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out var dt))
			{
				dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
				SetToken(JsonToken.Date, dt, updateIndex: false);
				return dt;
			}
			if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
			{
				dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
				SetToken(JsonToken.Date, dt, updateIndex: false);
				return dt;
			}
			throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual DateTimeOffset? ReadAsDateTimeOffset()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Date:
				if (Value is DateTime dateTime)
				{
					SetToken(JsonToken.Date, new DateTimeOffset(dateTime), updateIndex: false);
				}
				return (DateTimeOffset)Value;
			case JsonToken.String:
			{
				string s = (string)Value;
				return ReadDateTimeOffsetString(s);
			}
			default:
				throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal DateTimeOffset? ReadDateTimeOffsetString(string? s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out var dt))
			{
				SetToken(JsonToken.Date, dt, updateIndex: false);
				return dt;
			}
			if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
			{
				SetToken(JsonToken.Date, dt, updateIndex: false);
				return dt;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		internal void ReaderReadAndAssert()
		{
			if (!Read())
			{
				throw CreateUnexpectedEndException();
			}
		}

		internal JsonReaderException CreateUnexpectedEndException()
		{
			return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
		}

		internal void ReadIntoWrappedTypeObject()
		{
			ReaderReadAndAssert();
			if (Value != null && Value.ToString() == "$type")
			{
				ReaderReadAndAssert();
				if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
				{
					ReaderReadAndAssert();
					if (Value.ToString() == "$value")
					{
						return;
					}
				}
			}
			throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
		}

		public void Skip()
		{
			if (TokenType == JsonToken.PropertyName)
			{
				Read();
			}
			if (JsonTokenUtils.IsStartToken(TokenType))
			{
				int depth = Depth;
				while (Read() && depth < Depth)
				{
				}
			}
		}

		protected void SetToken(JsonToken newToken)
		{
			SetToken(newToken, null, updateIndex: true);
		}

		protected void SetToken(JsonToken newToken, object? value)
		{
			SetToken(newToken, value, updateIndex: true);
		}

		protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
		{
			_tokenType = newToken;
			_value = value;
			switch (newToken)
			{
			case JsonToken.StartObject:
				_currentState = State.ObjectStart;
				Push(JsonContainerType.Object);
				break;
			case JsonToken.StartArray:
				_currentState = State.ArrayStart;
				Push(JsonContainerType.Array);
				break;
			case JsonToken.StartConstructor:
				_currentState = State.ConstructorStart;
				Push(JsonContainerType.Constructor);
				break;
			case JsonToken.EndObject:
				ValidateEnd(JsonToken.EndObject);
				break;
			case JsonToken.EndArray:
				ValidateEnd(JsonToken.EndArray);
				break;
			case JsonToken.EndConstructor:
				ValidateEnd(JsonToken.EndConstructor);
				break;
			case JsonToken.PropertyName:
				_currentState = State.Property;
				_currentPosition.PropertyName = (string)value;
				break;
			case JsonToken.Raw:
			case JsonToken.Integer:
			case JsonToken.Float:
			case JsonToken.String:
			case JsonToken.Boolean:
			case JsonToken.Null:
			case JsonToken.Undefined:
			case JsonToken.Date:
			case JsonToken.Bytes:
				SetPostValueState(updateIndex);
				break;
			case JsonToken.Comment:
				break;
			}
		}

		internal void SetPostValueState(bool updateIndex)
		{
			if (Peek() != 0 || SupportMultipleContent)
			{
				_currentState = State.PostValue;
			}
			else
			{
				SetFinished();
			}
			if (updateIndex)
			{
				UpdateScopeWithFinishedValue();
			}
		}

		private void UpdateScopeWithFinishedValue()
		{
			if (_currentPosition.HasIndex)
			{
				_currentPosition.Position++;
			}
		}

		private void ValidateEnd(JsonToken endToken)
		{
			JsonContainerType jsonContainerType = Pop();
			if (GetTypeForCloseToken(endToken) != jsonContainerType)
			{
				throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, jsonContainerType));
			}
			if (Peek() != 0 || SupportMultipleContent)
			{
				_currentState = State.PostValue;
			}
			else
			{
				SetFinished();
			}
		}

		protected void SetStateBasedOnCurrent()
		{
			JsonContainerType jsonContainerType = Peek();
			switch (jsonContainerType)
			{
			case JsonContainerType.Object:
				_currentState = State.Object;
				break;
			case JsonContainerType.Array:
				_currentState = State.Array;
				break;
			case JsonContainerType.Constructor:
				_currentState = State.Constructor;
				break;
			case JsonContainerType.None:
				SetFinished();
				break;
			default:
				throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, jsonContainerType));
			}
		}

		private void SetFinished()
		{
			_currentState = ((!SupportMultipleContent) ? State.Finished : State.Start);
		}

		private JsonContainerType GetTypeForCloseToken(JsonToken token)
		{
			return token switch
			{
				JsonToken.EndObject => JsonContainerType.Object, 
				JsonToken.EndArray => JsonContainerType.Array, 
				JsonToken.EndConstructor => JsonContainerType.Constructor, 
				_ => throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token)), 
			};
		}

		void IDisposable.Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (_currentState != State.Closed && disposing)
			{
				Close();
			}
		}

		public virtual void Close()
		{
			_currentState = State.Closed;
			_tokenType = JsonToken.None;
			_value = null;
		}

		internal void ReadAndAssert()
		{
			if (!Read())
			{
				throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
			}
		}

		internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
		{
			if (!ReadForType(contract, hasConverter))
			{
				throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
			}
		}

		internal bool ReadForType(JsonContract? contract, bool hasConverter)
		{
			if (hasConverter)
			{
				return Read();
			}
			switch (contract?.InternalReadType ?? ReadType.Read)
			{
			case ReadType.Read:
				return ReadAndMoveToContent();
			case ReadType.ReadAsInt32:
				ReadAsInt32();
				break;
			case ReadType.ReadAsInt64:
			{
				bool result = ReadAndMoveToContent();
				if (TokenType == JsonToken.Undefined)
				{
					throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
				}
				return result;
			}
			case ReadType.ReadAsDecimal:
				ReadAsDecimal();
				break;
			case ReadType.ReadAsDouble:
				ReadAsDouble();
				break;
			case ReadType.ReadAsBytes:
				ReadAsBytes();
				break;
			case ReadType.ReadAsBoolean:
				ReadAsBoolean();
				break;
			case ReadType.ReadAsString:
				ReadAsString();
				break;
			case ReadType.ReadAsDateTime:
				ReadAsDateTime();
				break;
			case ReadType.ReadAsDateTimeOffset:
				ReadAsDateTimeOffset();
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
			return TokenType != JsonToken.None;
		}

		internal bool ReadAndMoveToContent()
		{
			if (Read())
			{
				return MoveToContent();
			}
			return false;
		}

		internal bool MoveToContent()
		{
			JsonToken tokenType = TokenType;
			while (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
			{
				if (!Read())
				{
					return false;
				}
				tokenType = TokenType;
			}
			return true;
		}

		private JsonToken GetContentToken()
		{
			JsonToken tokenType;
			do
			{
				if (!Read())
				{
					SetToken(JsonToken.None);
					return JsonToken.None;
				}
				tokenType = TokenType;
			}
			while (tokenType == JsonToken.Comment);
			return tokenType;
		}
	}
	[Serializable]
	public class JsonReaderException : JsonException
	{
		public int LineNumber { get; }

		public int LinePosition { get; }

		public string? Path { get; }

		public JsonReaderException()
		{
		}

		public JsonReaderException(string message)
			: base(message)
		{
		}

		public JsonReaderException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public JsonReaderException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
			: base(message, innerException)
		{
			Path = path;
			LineNumber = lineNumber;
			LinePosition = linePosition;
		}

		internal static JsonReaderException Create(JsonReader reader, string message)
		{
			return Create(reader, message, null);
		}

		internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
		{
			return Create(reader as IJsonLineInfo, reader.Path, message, ex);
		}

		internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
		{
			message = JsonPosition.FormatMessage(lineInfo, path, message);
			int lineNumber;
			int linePosition;
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				lineNumber = lineInfo.LineNumber;
				linePosition = lineInfo.LinePosition;
			}
			else
			{
				lineNumber = 0;
				linePosition = 0;
			}
			return new JsonReaderException(message, path, lineNumber, linePosition, ex);
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class JsonRequiredAttribute : Attribute
	{
	}
	[Serializable]
	public class JsonSerializationException : JsonException
	{
		public int LineNumber { get; }

		public int LinePosition { get; }

		public string? Path { get; }

		public JsonSerializationException()
		{
		}

		public JsonSerializationException(string message)
			: base(message)
		{
		}

		public JsonSerializationException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public JsonSerializationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
			: base(message, innerException)
		{
			Path = path;
			LineNumber = lineNumber;
			LinePosition = linePosition;
		}

		internal static JsonSerializationException Create(JsonReader reader, string message)
		{
			return Create(reader, message, null);
		}

		internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
		{
			return Create(reader as IJsonLineInfo, reader.Path, message, ex);
		}

		internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
		{
			message = JsonPosition.FormatMessage(lineInfo, path, message);
			int lineNumber;
			int linePosition;
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				lineNumber = lineInfo.LineNumber;
				linePosition = lineInfo.LinePosition;
			}
			else
			{
				lineNumber = 0;
				linePosition = 0;
			}
			return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
		}
	}
	public class JsonSerializer
	{
		internal TypeNameHandling _typeNameHandling;

		internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;

		internal PreserveReferencesHandling _preserveReferencesHandling;

		internal ReferenceLoopHandling _referenceLoopHandling;

		internal MissingMemberHandling _missingMemberHandling;

		internal ObjectCreationHandling _objectCreationHandling;

		internal NullValueHandling _nullValueHandling;

		internal DefaultValueHandling _defaultValueHandling;

		internal ConstructorHandling _constructorHandling;

		internal MetadataPropertyHandling _metadataPropertyHandling;

		internal JsonConverterCollection? _converters;

		internal IContractResolver _contractResolver;

		internal ITraceWriter? _traceWriter;

		internal IEqualityComparer? _equalityComparer;

		internal ISerializationBinder _serializationBinder;

		internal StreamingContext _context;

		private IReferenceResolver? _referenceResolver;

		private Formatting? _formatting;

		private DateFormatHandling? _dateFormatHandling;

		private DateTimeZoneHandling? _dateTimeZoneHandling;

		private DateParseHandling? _dateParseHandling;

		private FloatFormatHandling? _floatFormatHandling;

		private FloatParseHandling? _floatParseHandling;

		private StringEscapeHandling? _stringEscapeHandling;

		private CultureInfo _culture;

		private int? _maxDepth;

		private bool _maxDepthSet;

		private bool? _checkAdditionalContent;

		private string? _dateFormatString;

		private bool _dateFormatStringSet;

		public virtual IReferenceResolver? ReferenceResolver
		{
			get
			{
				return GetReferenceResolver();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value", "Reference resolver cannot be null.");
				}
				_referenceResolver = value;
			}
		}

		[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
		public virtual SerializationBinder Binder
		{
			get
			{
				if (_serializationBinder is SerializationBinder result)
				{
					return result;
				}
				if (_serializationBinder is SerializationBinderAdapter serializationBinderAdapter)
				{
					return serializationBinderAdapter.SerializationBinder;
				}
				throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value", "Serialization binder cannot be null.");
				}
				_serializationBinder = (value as ISerializationBinder) ?? new SerializationBinderAdapter(value);
			}
		}

		public virtual ISerializationBinder SerializationBinder
		{
			get
			{
				return _serializationBinder;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value", "Serialization binder cannot be null.");
				}
				_serializationBinder = value;
			}
		}

		public virtual ITraceWriter? TraceWriter
		{
			get
			{
				return _traceWriter;
			}
			set
			{
				_traceWriter = value;
			}
		}

		public virtual IEqualityComparer? EqualityComparer
		{
			get
			{
				return _equalityComparer;
			}
			set
			{
				_equalityComparer = value;
			}
		}

		public virtual TypeNameHandling TypeNameHandling
		{
			get
			{
				return _typeNameHandling;
			}
			set
			{
				if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_typeNameHandling = value;
			}
		}

		[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
		public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
		{
			get
			{
				return (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
			}
			set
			{
				if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
			}
		}

		public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
		{
			get
			{
				return _typeNameAssemblyFormatHandling;
			}
			set
			{
				if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_typeNameAssemblyFormatHandling = value;
			}
		}

		public virtual PreserveReferencesHandling PreserveReferencesHandling
		{
			get
			{
				return _preserveReferencesHandling;
			}
			set
			{
				if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_preserveReferencesHandling = value;
			}
		}

		public virtual ReferenceLoopHandling ReferenceLoopHandling
		{
			get
			{
				return _referenceLoopHandling;
			}
			set
			{
				if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_referenceLoopHandling = value;
			}
		}

		public virtual MissingMemberHandling MissingMemberHandling
		{
			get
			{
				return _missingMemberHandling;
			}
			set
			{
				if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_missingMemberHandling = value;
			}
		}

		public virtual NullValueHandling NullValueHandling
		{
			get
			{
				return _nullValueHandling;
			}
			set
			{
				if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_nullValueHandling = value;
			}
		}

		public virtual DefaultValueHandling DefaultValueHandling
		{
			get
			{
				return _defaultValueHandling;
			}
			set
			{
				if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_defaultValueHandling = value;
			}
		}

		public virtual ObjectCreationHandling ObjectCreationHandling
		{
			get
			{
				return _objectCreationHandling;
			}
			set
			{
				if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_objectCreationHandling = value;
			}
		}

		public virtual ConstructorHandling ConstructorHandling
		{
			get
			{
				return _constructorHandling;
			}
			set
			{
				if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_constructorHandling = value;
			}
		}

		public virtual MetadataPropertyHandling MetadataPropertyHandling
		{
			get
			{
				return _metadataPropertyHandling;
			}
			set
			{
				if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_metadataPropertyHandling = value;
			}
		}

		public virtual JsonConverterCollection Converters
		{
			get
			{
				if (_converters == null)
				{
					_converters = new JsonConverterCollection();
				}
				return _converters;
			}
		}

		public virtual IContractResolver ContractResolver
		{
			get
			{
				return _contractResolver;
			}
			set
			{
				_contractResolver = value ?? DefaultContractResolver.Instance;
			}
		}

		public virtual StreamingContext Context
		{
			get
			{
				return _context;
			}
			set
			{
				_context = value;
			}
		}

		public virtual Formatting Formatting
		{
			get
			{
				return _formatting.GetValueOrDefault();
			}
			set
			{
				_formatting = value;
			}
		}

		public virtual DateFormatHandling DateFormatHandling
		{
			get
			{
				return _dateFormatHandling.GetValueOrDefault();
			}
			set
			{
				_dateFormatHandling = value;
			}
		}

		public virtual DateTimeZoneHandling DateTimeZoneHandling
		{
			get
			{
				return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind;
			}
			set
			{
				_dateTimeZoneHandling = value;
			}
		}

		public virtual DateParseHandling DateParseHandling
		{
			get
			{
				return _dateParseHandling ?? DateParseHandling.DateTime;
			}
			set
			{
				_dateParseHandling = value;
			}
		}

		public virtual FloatParseHandling FloatParseHandling
		{
			get
			{
				return _floatParseHandling.GetValueOrDefault();
			}
			set
			{
				_floatParseHandling = value;
			}
		}

		public virtual FloatFormatHandling FloatFormatHandling
		{
			get
			{
				return _floatFormatHandling.GetValueOrDefault();
			}
			set
			{
				_floatFormatHandling = value;
			}
		}

		public virtual StringEscapeHandling StringEscapeHandling
		{
			get
			{
				return _stringEscapeHandling.GetValueOrDefault();
			}
			set
			{
				_stringEscapeHandling = value;
			}
		}

		public virtual string DateFormatString
		{
			get
			{
				return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
			}
			set
			{
				_dateFormatString = value;
				_dateFormatStringSet = true;
			}
		}

		public virtual CultureInfo Culture
		{
			get
			{
				return _culture ?? JsonSerializerSettings.DefaultCulture;
			}
			set
			{
				_culture = value;
			}
		}

		public virtual int? MaxDepth
		{
			get
			{
				return _maxDepth;
			}
			set
			{
				if (value <= 0)
				{
					throw new ArgumentException("Value must be positive.", "value");
				}
				_maxDepth = value;
				_maxDepthSet = true;
			}
		}

		public virtual bool CheckAdditionalContent
		{
			get
			{
				return _checkAdditionalContent.GetValueOrDefault();
			}
			set
			{
				_checkAdditionalContent = value;
			}
		}

		public virtual event EventHandler<ErrorEventArgs>? Error;

		internal bool IsCheckAdditionalContentSet()
		{
			return _checkAdditionalContent.HasValue;
		}

		public JsonSerializer()
		{
			_referenceLoopHandling = ReferenceLoopHandling.Error;
			_missingMemberHandling = MissingMemberHandling.Ignore;
			_nullValueHandling = NullValueHandling.Include;
			_defaultValueHandling = DefaultValueHandling.Include;
			_objectCreationHandling = ObjectCreationHandling.Auto;
			_preserveReferencesHandling = PreserveReferencesHandling.None;
			_constructorHandling = ConstructorHandling.Default;
			_typeNameHandling = TypeNameHandling.None;
			_metadataPropertyHandling = MetadataPropertyHandling.Default;
			_context = JsonSerializerSettings.DefaultContext;
			_serializationBinder = DefaultSerializationBinder.Instance;
			_culture = JsonSerializerSettings.DefaultCulture;
			_contractResolver = DefaultContractResolver.Instance;
		}

		public static JsonSerializer Create()
		{
			return new JsonSerializer();
		}

		public static JsonSerializer Create(JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = Create();
			if (settings != null)
			{
				ApplySerializerSettings(jsonSerializer, settings);
			}
			return jsonSerializer;
		}

		public static JsonSerializer CreateDefault()
		{
			return Create(JsonConvert.DefaultSettings?.Invoke());
		}

		public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = CreateDefault();
			if (settings != null)
			{
				ApplySerializerSettings(jsonSerializer, settings);
			}
			return jsonSerializer;
		}

		private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
		{
			if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
			{
				for (int i = 0; i < settings.Converters.Count; i++)
				{
					serializer.Converters.Insert(i, settings.Converters[i]);
				}
			}
			if (settings._typeNameHandling.HasValue)
			{
				serializer.TypeNameHandling = settings.TypeNameHandling;
			}
			if (settings._metadataPropertyHandling.HasValue)
			{
				serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
			}
			if (settings._typeNameAssemblyFormatHandling.HasValue)
			{
				serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
			}
			if (settings._preserveReferencesHandling.HasValue)
			{
				serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
			}
			if (settings._referenceLoopHandling.HasValue)
			{
				serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
			}
			if (settings._missingMemberHandling.HasValue)
			{
				serializer.MissingMemberHandling = settings.MissingMemberHandling;
			}
			if (settings._objectCreationHandling.HasValue)
			{
				serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
			}
			if (settings._nullValueHandling.HasValue)
			{
				serializer.NullValueHandling = settings.NullValueHandling;
			}
			if (settings._defaultValueHandling.HasValue)
			{
				serializer.DefaultValueHandling = settings.DefaultValueHandling;
			}
			if (settings._constructorHandling.HasValue)
			{
				serializer.ConstructorHandling = settings.ConstructorHandling;
			}
			if (settings._context.HasValue)
			{
				serializer.Context = settings.Context;
			}
			if (settings._checkAdditionalContent.HasValue)
			{
				serializer._checkAdditionalContent = settings._checkAdditionalContent;
			}
			if (settings.Error != null)
			{
				serializer.Error += settings.Error;
			}
			if (settings.ContractResolver != null)
			{
				serializer.ContractResolver = settings.ContractResolver;
			}
			if (settings.ReferenceResolverProvider != null)
			{
				serializer.ReferenceResolver = settings.ReferenceResolverProvider();
			}
			if (settings.TraceWriter != null)
			{
				serializer.TraceWriter = settings.TraceWriter;
			}
			if (settings.EqualityComparer != null)
			{
				serializer.EqualityComparer = settings.EqualityComparer;
			}
			if (settings.SerializationBinder != null)
			{
				serializer.SerializationBinder = settings.SerializationBinder;
			}
			if (settings._formatting.HasValue)
			{
				serializer._formatting = settings._formatting;
			}
			if (settings._dateFormatHandling.HasValue)
			{
				serializer._dateFormatHandling = settings._dateFormatHandling;
			}
			if (settings._dateTimeZoneHandling.HasValue)
			{
				serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
			}
			if (settings._dateParseHandling.HasValue)
			{
				serializer._dateParseHandling = settings._dateParseHandling;
			}
			if (settings._dateFormatStringSet)
			{
				serializer._dateFormatString = settings._dateFormatString;
				serializer._dateFormatStringSet = settings._dateFormatStringSet;
			}
			if (settings._floatFormatHandling.HasValue)
			{
				serializer._floatFormatHandling = settings._floatFormatHandling;
			}
			if (settings._floatParseHandling.HasValue)
			{
				serializer._floatParseHandling = settings._floatParseHandling;
			}
			if (settings._stringEscapeHandling.HasValue)
			{
				serializer._stringEscapeHandling = settings._stringEscapeHandling;
			}
			if (settings._culture != null)
			{
				serializer._culture = settings._culture;
			}
			if (settings._maxDepthSet)
			{
				serializer._maxDepth = settings._maxDepth;
				serializer._maxDepthSet = settings._maxDepthSet;
			}
		}

		[DebuggerStepThrough]
		public void Populate(TextReader reader, object target)
		{
			Populate(new JsonTextReader(reader), target);
		}

		[DebuggerStepThrough]
		public void Populate(JsonReader reader, object target)
		{
			PopulateInternal(reader, target);
		}

		internal virtual void PopulateInternal(JsonReader reader, object target)
		{
			ValidationUtils.ArgumentNotNull(reader, "reader");
			ValidationUtils.ArgumentNotNull(target, "target");
			SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
			TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
			new JsonSerializerInternalReader(this).Populate(traceJsonReader ?? reader, target);
			if (traceJsonReader != null)
			{
				TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
			}
			ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
		}

		[DebuggerStepThrough]
		public object? Deserialize(JsonReader reader)
		{
			return Deserialize(reader, null);
		}

		[DebuggerStepThrough]
		public object? Deserialize(TextReader reader, Type objectType)
		{
			return Deserialize(new JsonTextReader(reader), objectType);
		}

		[DebuggerStepThrough]
		public T? Deserialize<T>(JsonReader reader)
		{
			return (T)Deserialize(reader, typeof(T));
		}

		[DebuggerStepThrough]
		public object? Deserialize(JsonReader reader, Type? objectType)
		{
			return DeserializeInternal(reader, objectType);
		}

		internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
		{
			ValidationUtils.ArgumentNotNull(reader, "reader");
			SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
			TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
			object? result = new JsonSerializerInternalReader(this).Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
			if (traceJsonReader != null)
			{
				TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
			}
			ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
			return result;
		}

		internal void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
		{
			if (_culture != null && !_culture.Equals(reader.Culture))
			{
				previousCulture = reader.Culture;
				reader.Culture = _culture;
			}
			else
			{
				previousCulture = null;
			}
			if (_dateTimeZoneHandling.HasValue && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
			{
				previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
				reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
			}
			else
			{
				previousDateTimeZoneHandling = null;
			}
			if (_dateParseHandling.HasValue && reader.DateParseHandling != _dateParseHandling)
			{
				previousDateParseHandling = reader.DateParseHandling;
				reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
			}
			else
			{
				previousDateParseHandling = null;
			}
			if (_floatParseHandling.HasValue && reader.FloatParseHandling != _floatParseHandling)
			{
				previousFloatParseHandling = reader.FloatParseHandling;
				reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
			}
			else
			{
				previousFloatParseHandling = null;
			}
			if (_maxDepthSet && reader.MaxDepth != _maxDepth)
			{
				previousMaxDepth = reader.MaxDepth;
				reader.MaxDepth = _maxDepth;
			}
			else
			{
				previousMaxDepth = null;
			}
			if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
			{
				previousDateFormatString = reader.DateFormatString;
				reader.DateFormatString = _dateFormatString;
			}
			else
			{
				previousDateFormatString = null;
			}
			if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver defaultContractResolver)
			{
				jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable();
			}
		}

		private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
		{
			if (previousCulture != null)
			{
				reader.Culture = previousCulture;
			}
			if (previousDateTimeZoneHandling.HasValue)
			{
				reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
			}
			if (previousDateParseHandling.HasValue)
			{
				reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
			}
			if (previousFloatParseHandling.HasValue)
			{
				reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
			}
			if (_maxDepthSet)
			{
				reader.MaxDepth = previousMaxDepth;
			}
			if (_dateFormatStringSet)
			{
				reader.DateFormatString = previousDateFormatString;
			}
			if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable != null && _contractResolver is DefaultContractResolver defaultContractResolver && jsonTextReader.PropertyNameTable == defaultContractResolver.GetNameTable())
			{
				jsonTextReader.PropertyNameTable = null;
			}
		}

		public void Serialize(TextWriter textWriter, object? value)
		{
			Serialize(new JsonTextWriter(textWriter), value);
		}

		public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
		{
			SerializeInternal(jsonWriter, value, objectType);
		}

		public void Serialize(TextWriter textWriter, object? value, Type objectType)
		{
			Serialize(new JsonTextWriter(textWriter), value, objectType);
		}

		public void Serialize(JsonWriter jsonWriter, object? value)
		{
			SerializeInternal(jsonWriter, value, null);
		}

		private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
		{
			TraceJsonReader traceJsonReader = new TraceJsonReader(reader);
			if (reader.TokenType != 0)
			{
				traceJsonReader.WriteCurrentToken();
			}
			return traceJsonReader;
		}

		internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
		{
			ValidationUtils.ArgumentNotNull(jsonWriter, "jsonWriter");
			Formatting? formatting = null;
			if (_formatting.HasValue && jsonWriter.Formatting != _formatting)
			{
				formatting = jsonWriter.Formatting;
				jsonWriter.Formatting = _formatting.GetValueOrDefault();
			}
			DateFormatHandling? dateFormatHandling = null;
			if (_dateFormatHandling.HasValue && jsonWriter.DateFormatHandling != _dateFormatHandling)
			{
				dateFormatHandling = jsonWriter.DateFormatHandling;
				jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
			}
			DateTimeZoneHandling? dateTimeZoneHandling = null;
			if (_dateTimeZoneHandling.HasValue && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
			{
				dateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
				jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
			}
			FloatFormatHandling? floatFormatHandling = null;
			if (_floatFormatHandling.HasValue && jsonWriter.FloatFormatHandling != _floatFormatHandling)
			{
				floatFormatHandling = jsonWriter.FloatFormatHandling;
				jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
			}
			StringEscapeHandling? stringEscapeHandling = null;
			if (_stringEscapeHandling.HasValue && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
			{
				stringEscapeHandling = jsonWriter.StringEscapeHandling;
				jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
			}
			CultureInfo cultureInfo = null;
			if (_culture != null && !_culture.Equals(jsonWriter.Culture))
			{
				cultureInfo = jsonWriter.Culture;
				jsonWriter.Culture = _culture;
			}
			string dateFormatString = null;
			if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
			{
				dateFormatString = jsonWriter.DateFormatString;
				jsonWriter.DateFormatString = _dateFormatString;
			}
			TraceJsonWriter traceJsonWriter = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? new TraceJsonWriter(jsonWriter) : null);
			new JsonSerializerInternalWriter(this).Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
			if (traceJsonWriter != null)
			{
				TraceWriter.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
			}
			if (formatting.HasValue)
			{
				jsonWriter.Formatting = formatting.GetValueOrDefault();
			}
			if (dateFormatHandling.HasValue)
			{
				jsonWriter.DateFormatHandling = dateFormatHandling.GetValueOrDefault();
			}
			if (dateTimeZoneHandling.HasValue)
			{
				jsonWriter.DateTimeZoneHandling = dateTimeZoneHandling.GetValueOrDefault();
			}
			if (floatFormatHandling.HasValue)
			{
				jsonWriter.FloatFormatHandling = floatFormatHandling.GetValueOrDefault();
			}
			if (stringEscapeHandling.HasValue)
			{
				jsonWriter.StringEscapeHandling = stringEscapeHandling.GetValueOrDefault();
			}
			if (_dateFormatStringSet)
			{
				jsonWriter.DateFormatString = dateFormatString;
			}
			if (cultureInfo != null)
			{
				jsonWriter.Culture = cultureInfo;
			}
		}

		internal IReferenceResolver GetReferenceResolver()
		{
			if (_referenceResolver == null)
			{
				_referenceResolver = new DefaultReferenceResolver();
			}
			return _referenceResolver;
		}

		internal JsonConverter? GetMatchingConverter(Type type)
		{
			return GetMatchingConverter(_converters, type);
		}

		internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType)
		{
			if (converters != null)
			{
				for (int i = 0; i < converters.Count; i++)
				{
					JsonConverter jsonConverter = converters[i];
					if (jsonConverter.CanConvert(objectType))
					{
						return jsonConverter;
					}
				}
			}
			return null;
		}

		internal void OnError(ErrorEventArgs e)
		{
			this.Error?.Invoke(this, e);
		}
	}
	public class JsonSerializerSettings
	{
		internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;

		internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;

		internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;

		internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;

		internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;

		internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;

		internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;

		internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;

		internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;

		internal static readonly StreamingContext DefaultContext;

		internal const Formatting DefaultFormatting = Formatting.None;

		internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;

		internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;

		internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;

		internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;

		internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;

		internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;

		internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;

		internal static readonly CultureInfo DefaultCulture;

		internal const bool DefaultCheckAdditionalContent = false;

		internal const string DefaultDateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";

		internal const int DefaultMaxDepth = 64;

		internal Formatting? _formatting;

		internal DateFormatHandling? _dateFormatHandling;

		internal DateTimeZoneHandling? _dateTimeZoneHandling;

		internal DateParseHandling? _dateParseHandling;

		internal FloatFormatHandling? _floatFormatHandling;

		internal FloatParseHandling? _floatParseHandling;

		internal StringEscapeHandling? _stringEscapeHandling;

		internal CultureInfo? _culture;

		internal bool? _checkAdditionalContent;

		internal int? _maxDepth;

		internal bool _maxDepthSet;

		internal string? _dateFormatString;

		internal bool _dateFormatStringSet;

		internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;

		internal DefaultValueHandling? _defaultValueHandling;

		internal PreserveReferencesHandling? _preserveReferencesHandling;

		internal NullValueHandling? _nullValueHandling;

		internal ObjectCreationHandling? _objectCreationHandling;

		internal MissingMemberHandling? _missingMemberHandling;

		internal ReferenceLoopHandling? _referenceLoopHandling;

		internal StreamingContext? _context;

		internal ConstructorHandling? _constructorHandling;

		internal TypeNameHandling? _typeNameHandling;

		internal MetadataPropertyHandling? _metadataPropertyHandling;

		public ReferenceLoopHandling ReferenceLoopHandling
		{
			get
			{
				return _referenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_referenceLoopHandling = value;
			}
		}

		public MissingMemberHandling MissingMemberHandling
		{
			get
			{
				return _missingMemberHandling.GetValueOrDefault();
			}
			set
			{
				_missingMemberHandling = value;
			}
		}

		public ObjectCreationHandling ObjectCreationHandling
		{
			get
			{
				return _objectCreationHandling.GetValueOrDefault();
			}
			set
			{
				_objectCreationHandling = value;
			}
		}

		public NullValueHandling NullValueHandling
		{
			get
			{
				return _nullValueHandling.GetValueOrDefault();
			}
			set
			{
				_nullValueHandling = value;
			}
		}

		public DefaultValueHandling DefaultValueHandling
		{
			get
			{
				return _defaultValueHandling.GetValueOrDefault();
			}
			set
			{
				_defaultValueHandling = value;
			}
		}

		public IList<JsonConverter> Converters { get; set; }

		public PreserveReferencesHandling PreserveReferencesHandling
		{
			get
			{
				return _preserveReferencesHandling.GetValueOrDefault();
			}
			set
			{
				_preserveReferencesHandling = value;
			}
		}

		public TypeNameHandling TypeNameHandling
		{
			get
			{
				return _typeNameHandling.GetValueOrDefault();
			}
			set
			{
				_typeNameHandling = value;
			}
		}

		public MetadataPropertyHandling MetadataPropertyHandling
		{
			get
			{
				return _metadataPropertyHandling.GetValueOrDefault();
			}
			set
			{
				_metadataPropertyHandling = value;
			}
		}

		[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
		public FormatterAssemblyStyle TypeNameAssemblyFormat
		{
			get
			{
				return (FormatterAssemblyStyle)TypeNameAssemblyFormatHandling;
			}
			set
			{
				TypeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
			}
		}

		public TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
		{
			get
			{
				return _typeNameAssemblyFormatHandling.GetValueOrDefault();
			}
			set
			{
				_typeNameAssemblyFormatHandling = value;
			}
		}

		public ConstructorHandling ConstructorHandling
		{
			get
			{
				return _constructorHandling.GetValueOrDefault();
			}
			set
			{
				_constructorHandling = value;
			}
		}

		public IContractResolver? ContractResolver { get; set; }

		public IEqualityComparer? EqualityComparer { get; set; }

		[Obsolete("Refer

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

using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Cysharp.Text;
using Microsoft.CodeAnalysis;
using SmartFormat.Core.Extensions;
using SmartFormat.Core.Formatting;
using SmartFormat.Core.Output;
using SmartFormat.Core.Parsing;
using SmartFormat.Core.Settings;
using SmartFormat.Extensions;
using SmartFormat.Extensions.PersistentVariables;
using SmartFormat.Pooling.ObjectPools;
using SmartFormat.Pooling.SmartPools;
using SmartFormat.Pooling.SpecializedPools;
using SmartFormat.Utilities;
using SmartFormat.ZString;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: InternalsVisibleTo("SmartFormat.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a1cdb8ba81e1a00f0f9509a8f0c896e0de0da6875652fffd44fb867e6b78fd78c31c6fdb07544b2ae53ed4b56daa90333d32ac14387f7f68d39165da8f99b8c294c1cee1bcc4bbcbe2dd73879824b53708837f425e2bf5c7d2cf868de9548c44871888bf9db5cb425064dda4b17134f8e3b52e1f686315a1832043c7b58fb0ac")]
[assembly: InternalsVisibleTo("Performance, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a1cdb8ba81e1a00f0f9509a8f0c896e0de0da6875652fffd44fb867e6b78fd78c31c6fdb07544b2ae53ed4b56daa90333d32ac14387f7f68d39165da8f99b8c294c1cee1bcc4bbcbe2dd73879824b53708837f425e2bf5c7d2cf868de9548c44871888bf9db5cb425064dda4b17134f8e3b52e1f686315a1832043c7b58fb0ac")]
[assembly: AssemblyCompany("SmartFormat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2011-2025 SmartFormat Project")]
[assembly: AssemblyDescription("This package contains the core SmartFormat assemblies with core extensions built-in.\n\nSmartFormat is a lightweight text templating library written in C#.\nIt can format various data sources into a string with a minimal, intuitive syntax similar to string.Format.\nIt uses extensions to provide named placeholders, localization, pluralization, gender conjugation, and list and time formatting.\n        ")]
[assembly: AssemblyFileVersion("3.6.1")]
[assembly: AssemblyInformationalVersion("3.6.1+ebf693558e4e511ae8542bdca527d55077296c4d")]
[assembly: AssemblyProduct("SmartFormat")]
[assembly: AssemblyTitle("SmartFormat")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/axuno/SmartFormat.git")]
[assembly: AssemblyVersion("3.0.0.0")]
[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;
		}
	}
}
namespace SmartFormat
{
	internal class Evaluator
	{
		internal readonly record struct FormatEventArgs(Format Format);

		internal readonly record struct OutputWrittenEventArgs(string WrittenValue);

		internal readonly record struct LiteralEventArgs(string Text);

		internal readonly record struct PlaceholderEventArgs(Placeholder Placeholder);

		internal readonly record struct SelectorValueEventArgs(Selector Selector, bool Success, Type? SourceType, object? Value);

		internal readonly record struct FormattingEventArgs(Selector Selector, object? Value, bool Success, Type? FormatterType);

		private readonly SmartFormatter _formatter;

		private readonly SmartSettings _settings;

		private readonly Registry _registry;

		internal EventHandler<FormatEventArgs>? OnFormat;

		internal EventHandler<LiteralEventArgs>? OnLiteral;

		internal EventHandler<PlaceholderEventArgs>? OnPlaceholder;

		internal EventHandler<SelectorValueEventArgs>? OnSelectorValue;

		internal EventHandler<SelectorValueEventArgs>? OnSelectorFailure;

		internal EventHandler<FormattingEventArgs>? OnFormattingStart;

		internal EventHandler<OutputWrittenEventArgs>? OnOutputWritten;

		internal EventHandler<FormattingEventArgs>? OnFormattingEnd;

		public event EventHandler<FormattingErrorEventArgs>? OnFormattingFailure;

		public Evaluator(SmartFormatter formatter)
		{
			_formatter = formatter;
			_settings = _formatter.Settings;
			_registry = _formatter.Registry;
		}

		public void WriteFormat(FormattingInfo formattingInfo)
		{
			Format format = formattingInfo.Format;
			OnFormat?.Invoke(this, new FormatEventArgs(format));
			foreach (FormatItem item in format.Items)
			{
				if (item is LiteralText literalText)
				{
					OnLiteral?.Invoke(this, new LiteralEventArgs(literalText.ToString()));
					formattingInfo.Write(literalText.ToString().AsSpan());
					continue;
				}
				Placeholder placeholder = (Placeholder)item;
				FormattingInfo formattingInfo2 = formattingInfo.CreateChild(placeholder);
				OnPlaceholder?.Invoke(this, new PlaceholderEventArgs(placeholder));
				if (EvaluatePlaceholder(formattingInfo2))
				{
					InvokeFormatters(formattingInfo2);
				}
			}
		}

		private bool EvaluatePlaceholder(FormattingInfo formattingInfo)
		{
			formattingInfo.Result = null;
			Placeholder placeholder = formattingInfo.Placeholder;
			try
			{
				EvaluateSelectors(formattingInfo);
			}
			catch (Exception innerException)
			{
				int startIndex = placeholder.Format?.StartIndex ?? placeholder.Selectors[placeholder.Selectors.Count - 1].EndIndex;
				FormatError(placeholder, innerException, startIndex, formattingInfo);
				return false;
			}
			return true;
		}

		public bool TryGetValue(FormattingInfo parentFormattingInfo, Placeholder placeholder, out object? result)
		{
			result = null;
			if (placeholder.Selectors.Count == 0)
			{
				result = parentFormattingInfo.CurrentValue;
				return true;
			}
			FormattingInfo formattingInfo = FormattingInfoPool.Instance.Get().Initialize(parentFormattingInfo, parentFormattingInfo.FormatDetails, placeholder, parentFormattingInfo.CurrentValue);
			parentFormattingInfo.Children.Add(formattingInfo);
			try
			{
				EvaluateSelectors(formattingInfo);
				result = formattingInfo.CurrentValue;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private void EvaluateSelectors(FormattingInfo formattingInfo)
		{
			formattingInfo.Result = null;
			bool flag = true;
			foreach (Selector selector in formattingInfo.Placeholder.Selectors)
			{
				if (!SkipThisSelector(selector))
				{
					formattingInfo.Selector = selector;
					(bool, Type) handled = _registry.InvokeSourceExtensions(formattingInfo);
					if (handled.Item1)
					{
						formattingInfo.CurrentValue = formattingInfo.Result;
						OnSelectorValue?.Invoke(this, new SelectorValueEventArgs(selector, handled.Item1, handled.Item2, formattingInfo.CurrentValue));
					}
					else if (flag)
					{
						flag = false;
						HandleNestedScope(formattingInfo, selector, ref handled);
						OnSelectorValue?.Invoke(this, new SelectorValueEventArgs(selector, handled.Item1, handled.Item2, formattingInfo.CurrentValue));
					}
					if (!handled.Item1)
					{
						OnSelectorFailure?.Invoke(this, new SelectorValueEventArgs(selector, handled.Item1, null, null));
						throw formattingInfo.FormattingException("No source extension could handle the selector named \"" + selector.RawText + "\"", selector);
					}
				}
			}
		}

		private void HandleNestedScope(FormattingInfo formattingInfo, Selector selector, ref (bool Success, Type? SourceType) handled)
		{
			FormattingInfo formattingInfo2 = formattingInfo;
			while (!handled.Success && formattingInfo2.Parent != null)
			{
				formattingInfo2 = formattingInfo2.Parent;
				formattingInfo2.Selector = selector;
				formattingInfo2.Result = null;
				handled = _registry.InvokeSourceExtensions(formattingInfo2);
				if (handled.Success)
				{
					formattingInfo.CurrentValue = formattingInfo2.Result;
				}
			}
		}

		private bool SkipThisSelector(Selector selector)
		{
			if (selector.Length == 0)
			{
				return true;
			}
			if (selector.Operator.Length > 0 && selector.Operator[0] == _settings.Parser.AlignmentOperator)
			{
				return true;
			}
			return false;
		}

		private void InvokeFormatters(FormattingInfo formattingInfo)
		{
			if (formattingInfo.DisableFormattingExtensions)
			{
				return;
			}
			Placeholder placeholder = formattingInfo.Placeholder;
			try
			{
				OnFormattingStart?.Invoke(this, new FormattingEventArgs(formattingInfo.Selector, formattingInfo.CurrentValue, Success: true, null));
				(bool, Type) tuple = _registry.InvokeFormatterExtensions(formattingInfo);
				OnFormattingEnd?.Invoke(this, new FormattingEventArgs(formattingInfo.Selector, formattingInfo.CurrentValue, tuple.Item1, tuple.Item2));
				if (!tuple.Item1)
				{
					throw formattingInfo.FormattingException("No suitable Formatter could be found", formattingInfo.Format, formattingInfo.Selector?.SelectorIndex ?? (-1));
				}
			}
			catch (Exception innerException)
			{
				int startIndex = placeholder.Format?.StartIndex ?? placeholder.Selectors[placeholder.Selectors.Count - 1].EndIndex;
				FormatError(placeholder, innerException, startIndex, formattingInfo);
			}
		}

		private void FormatError(FormatItem errorItem, Exception innerException, int startIndex, FormattingInfo formattingInfo)
		{
			FormattingErrorEventArgs formattingErrorEventArgs = new FormattingErrorEventArgs(errorItem.RawText, startIndex, _settings.Formatter.ErrorAction != FormatErrorAction.ThrowError);
			this.OnFormattingFailure?.Invoke(this, formattingErrorEventArgs);
			_formatter.FormatError(formattingErrorEventArgs);
			switch (_settings.Formatter.ErrorAction)
			{
			case FormatErrorAction.Ignore:
				break;
			case FormatErrorAction.ThrowError:
				throw (innerException as FormattingException) ?? new FormattingException(errorItem, innerException, startIndex);
			case FormatErrorAction.OutputErrorInResult:
				formattingInfo.FormatDetails.FormattingException = (innerException as FormattingException) ?? new FormattingException(errorItem, innerException, startIndex);
				formattingInfo.Write(innerException.Message);
				formattingInfo.FormatDetails.FormattingException = null;
				break;
			case FormatErrorAction.MaintainTokens:
				formattingInfo.Write(formattingInfo.Placeholder?.RawText ?? "'null'");
				break;
			}
		}
	}
	public class FormattingErrorEventArgs : EventArgs
	{
		public string Placeholder { get; }

		public int ErrorIndex { get; }

		public bool IgnoreError { get; }

		internal FormattingErrorEventArgs(string rawText, int errorIndex, bool ignoreError)
		{
			Placeholder = rawText;
			ErrorIndex = errorIndex;
			IgnoreError = ignoreError;
		}
	}
	public static class Smart
	{
		private static SmartFormatter? _formatter;

		public static SmartFormatter Default
		{
			get
			{
				if (_formatter == null)
				{
					_formatter = CreateDefaultSmartFormat();
				}
				return _formatter;
			}
			set
			{
				_formatter = value;
			}
		}

		public static string Format(string format, params object?[] args)
		{
			return Default.Format(format, args);
		}

		public static string Format(IFormatProvider provider, string format, params object?[] args)
		{
			return Default.Format(provider, format, args);
		}

		public static string Format(string format, object? arg0, object? arg1, object? arg2)
		{
			return Default.Format(format, arg0, arg1, arg2);
		}

		public static string Format(string format, object? arg0, object? arg1)
		{
			return Default.Format(format, arg0, arg1);
		}

		public static string Format(string format, object? arg0)
		{
			return Default.Format(format, arg0);
		}

		public static SmartFormatter CreateDefaultSmartFormat(SmartSettings? settings = null)
		{
			return new SmartFormatter(settings).AddExtensions(new StringSource(), new ListFormatter(), new DictionarySource(), new ValueTupleSource(), new ReflectionSource(), new DefaultSource(), new KeyValuePairSource()).AddExtensions(new PluralLocalizationFormatter(), new ConditionalFormatter(), new IsMatchFormatter(), new NullFormatter(), new ChooseFormatter(), new SubStringFormatter(), new DefaultFormatter());
		}
	}
	public static class SmartExtensions
	{
		public static StringBuilder AppendSmart(this StringBuilder sb, string format, params object[] args)
		{
			StringOutput output = new StringOutput(sb);
			Smart.Default.FormatInto(output, format, args);
			return sb;
		}

		public static StringBuilder AppendLineSmart(this StringBuilder sb, string format, params object[] args)
		{
			sb.AppendSmart(format, args);
			sb.AppendLine();
			return sb;
		}

		public static void WriteSmart(this TextWriter writer, string format, params object[] args)
		{
			TextWriterOutput output = new TextWriterOutput(writer);
			Smart.Default.FormatInto(output, format, args);
		}

		public static void WriteLineSmart(this TextWriter writer, string format, params object[] args)
		{
			writer.WriteSmart(format, args);
			writer.WriteLine();
		}

		public static string FormatSmart(this string format, params object[] args)
		{
			return Smart.Format(format, args);
		}
	}
	public class SmartFormatter
	{
		internal List<ISource> SourceExtensions => Registry.SourceExtensions;

		internal List<IFormatter> FormatterExtensions => Registry.FormatterExtensions;

		public Parser Parser { get; }

		public SmartSettings Settings { get; }

		internal Registry Registry { get; }

		internal Evaluator Evaluator { get; }

		public event EventHandler<FormattingErrorEventArgs>? OnFormattingFailure;

		public SmartFormatter(SmartSettings? settings = null)
		{
			Settings = settings ?? new SmartSettings();
			Parser = new Parser(Settings);
			Registry = new Registry(this);
			Evaluator = new Evaluator(this);
		}

		internal void FormatError(FormattingErrorEventArgs args)
		{
			this.OnFormattingFailure?.Invoke(this, args);
		}

		public IReadOnlyList<ISource> GetSourceExtensions()
		{
			return Registry.GetSourceExtensions();
		}

		public IReadOnlyList<IFormatter> GetFormatterExtensions()
		{
			return Registry.GetFormatterExtensions();
		}

		public SmartFormatter AddExtensions(params ISource[] sourceExtensions)
		{
			Registry.AddExtensions(sourceExtensions);
			return this;
		}

		public SmartFormatter AddExtensions(params IFormatter[] formatterExtensions)
		{
			Registry.AddExtensions(formatterExtensions);
			return this;
		}

		public SmartFormatter InsertExtension(int position, ISource sourceExtension)
		{
			Registry.InsertExtension(position, sourceExtension);
			return this;
		}

		public SmartFormatter InsertExtension(int position, IFormatter formatterExtension)
		{
			Registry.InsertExtension(position, formatterExtension);
			return this;
		}

		public T? GetSourceExtension<T>() where T : class, ISource
		{
			return Registry.GetSourceExtension<T>();
		}

		public T? GetFormatterExtension<T>() where T : class, IFormatter
		{
			return Registry.GetFormatterExtension<T>();
		}

		public bool RemoveSourceExtension<T>() where T : class, ISource
		{
			return Registry.RemoveSourceExtension<T>();
		}

		public bool RemoveFormatterExtension<T>() where T : class, IFormatter
		{
			return Registry.RemoveFormatterExtension<T>();
		}

		public string Format(string format, params object?[] args)
		{
			return Format((IFormatProvider?)null, format, (IList<object?>)args);
		}

		public string Format(string format, IList<object?> args)
		{
			return Format(null, format, args);
		}

		public string Format(IFormatProvider? provider, string format, params object?[] args)
		{
			return Format(provider, format, (IList<object?>)args);
		}

		public string Format(IFormatProvider? provider, string format, IList<object?> args)
		{
			Format format2 = Parser.ParseFormat(format);
			try
			{
				return Format(provider, format2, args);
			}
			finally
			{
				FormatPool.Instance.Return(format2);
			}
		}

		public string Format(Format formatParsed, params object?[] args)
		{
			return Format((IFormatProvider?)null, formatParsed, (IList<object?>)args);
		}

		public string Format(Format formatParsed, IList<object?> args)
		{
			return Format(null, formatParsed, args);
		}

		public string Format(IFormatProvider? provider, Format formatParsed, params object?[] args)
		{
			return Format(provider, formatParsed, (IList<object?>)args);
		}

		public string Format(IFormatProvider? provider, Format formatParsed, IList<object?> args)
		{
			using ZStringOutput zStringOutput = new ZStringOutput(ZStringBuilderUtilities.CalcCapacity(formatParsed));
			FormatInto(zStringOutput, provider, formatParsed, args);
			return zStringOutput.ToString();
		}

		public void Format(FormattingInfo formattingInfo)
		{
			Registry.ThrowIfNoExtensions();
			Evaluator.WriteFormat(formattingInfo);
		}

		public void FormatInto(IOutput output, string format, params object?[] args)
		{
			FormatInto(output, format, (IList<object?>)args);
		}

		public void FormatInto(IOutput output, string format, IList<object?> args)
		{
			FormatInto(output, null, format, args);
		}

		public void FormatInto(IOutput output, IFormatProvider? provider, string format, IList<object?> args)
		{
			Format format2 = Parser.ParseFormat(format);
			try
			{
				FormatInto(output, provider, format2, args);
			}
			finally
			{
				FormatPool.Instance.Return(format2);
			}
		}

		public void FormatInto(IOutput output, IFormatProvider? provider, Format format, params object?[] args)
		{
			FormatInto(output, provider, format, (IList<object?>)args);
		}

		public void FormatInto(IOutput output, IFormatProvider? provider, Format formatParsed, IList<object?> args)
		{
			Registry.ThrowIfNoExtensions();
			ExecuteFormattingAction(this, provider, formatParsed, args, output, Evaluator.WriteFormat);
		}

		private static void ExecuteFormattingAction(SmartFormatter formatter, IFormatProvider? provider, Format formatParsed, IList<object?> args, IOutput output, Action<FormattingInfo> doWork)
		{
			object currentValue = ((args.Count > 0) ? args[0] : args);
			FormatDetails instance;
			using (FormatDetailsPool.Instance.Pool.Get(out instance))
			{
				instance.Initialize(formatter, formatParsed, args, provider, output);
				FormattingInfo instance2;
				using (FormattingInfoPool.Instance.Pool.Get(out instance2))
				{
					instance2.Initialize(instance, formatParsed, currentValue);
					doWork(instance2);
				}
			}
		}
	}
}
namespace SmartFormat.ZString
{
	public struct ZCharArray : IDisposable
	{
		private static readonly ArrayPool<char> Pool = ArrayPool<char>.Create(10000000, 100);

		private char[]? _bufferArray;

		private int _currentLength;

		public const int DefaultBufferCapacity = 1000000;

		public const int MaxBufferCapacity = 10000000;

		internal Span<char> Span
		{
			get
			{
				ThrowIfDisposed();
				return _bufferArray.AsSpan(0, _currentLength);
			}
		}

		public int Length
		{
			get
			{
				ThrowIfDisposed();
				return _currentLength;
			}
		}

		public int Capacity
		{
			get
			{
				ThrowIfDisposed();
				return _bufferArray.Length;
			}
		}

		public bool IsDisposed => _bufferArray == null;

		public ZCharArray()
			: this(1000000)
		{
		}

		public ZCharArray(int length)
		{
			_bufferArray = Pool.Rent(length);
			_currentLength = 0;
		}

		public ReadOnlySpan<char> GetSpan()
		{
			ThrowIfDisposed();
			return _bufferArray.AsSpan(0, _currentLength);
		}

		public void Reset()
		{
			ThrowIfDisposed();
			_currentLength = 0;
		}

		private void Grow(int length)
		{
			char[] array = Pool.Rent(length);
			Array.Copy(_bufferArray, array, Math.Min(_bufferArray.Length, length));
			Pool.Return(_bufferArray);
			_bufferArray = array;
		}

		public void Write(Span<char> data)
		{
			ThrowIfDisposed();
			GrowBufferIfNeeded(data.Length);
			data.CopyTo(_bufferArray.AsSpan(_currentLength, data.Length));
			_currentLength += data.Length;
		}

		public void Write(ReadOnlySpan<char> data)
		{
			ThrowIfDisposed();
			GrowBufferIfNeeded(data.Length);
			data.CopyTo(_bufferArray.AsSpan(_currentLength, data.Length));
			_currentLength += data.Length;
		}

		public void Write(string data)
		{
			ThrowIfDisposed();
			GrowBufferIfNeeded(data.Length);
			data.AsSpan().CopyTo(_bufferArray.AsSpan(_currentLength, data.Length));
			_currentLength += data.Length;
		}

		public void Write(char c)
		{
			ThrowIfDisposed();
			GrowBufferIfNeeded(1);
			_bufferArray[_currentLength++] = c;
		}

		public void Write(char c, int count)
		{
			ThrowIfDisposed();
			GrowBufferIfNeeded(count);
			for (int i = 0; i < count; i++)
			{
				_bufferArray[_currentLength++] = c;
			}
		}

		public void Write(ISpanFormattable data, ReadOnlySpan<char> format, IFormatProvider? provider = null)
		{
			ThrowIfDisposed();
			int charsWritten;
			while (!data.TryFormat(_bufferArray.AsSpan(_currentLength), out charsWritten, format, provider))
			{
				GrowBufferIfNeeded(1000);
			}
			_currentLength += charsWritten;
		}

		public void Write(IFormattable data, string format, IFormatProvider? provider = null)
		{
			ThrowIfDisposed();
			ReadOnlySpan<char> data2 = data.ToString(format, provider).AsSpan();
			GrowBufferIfNeeded(data2.Length);
			Write(data2);
		}

		private void GrowBufferIfNeeded(int dataLength)
		{
			int num = _currentLength + dataLength;
			if (num > Capacity)
			{
				Grow(num * 2);
			}
		}

		private void ThrowIfDisposed()
		{
			if (IsDisposed)
			{
				throw new ObjectDisposedException("ZCharArray");
			}
		}

		public override string ToString()
		{
			ThrowIfDisposed();
			return new string(_bufferArray, 0, _currentLength);
		}

		public void Dispose()
		{
			if (!IsDisposed)
			{
				Pool.Return(_bufferArray);
				_bufferArray = null;
			}
		}
	}
	[ExcludeFromCodeCoverage]
	public class ZStringBuilder : IDisposable
	{
		private Utf16ValueStringBuilder _vsb;

		public int Length => ((Utf16ValueStringBuilder)(ref _vsb)).Length;

		public ZStringBuilder(bool disposeImmediately)
		{
			//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)
			_vsb = new Utf16ValueStringBuilder(disposeImmediately);
		}

		public ReadOnlySpan<char> AsSpan()
		{
			return ((Utf16ValueStringBuilder)(ref _vsb)).AsSpan();
		}

		public ReadOnlyMemory<char> AsMemory()
		{
			return ((Utf16ValueStringBuilder)(ref _vsb)).AsMemory();
		}

		public ArraySegment<char> AsArraySegment()
		{
			return ((Utf16ValueStringBuilder)(ref _vsb)).AsArraySegment();
		}

		public void Dispose()
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Dispose();
		}

		public void Clear()
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Clear();
		}

		public void TryGrow(int sizeHint)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).TryGrow(sizeHint);
		}

		public void Grow(int sizeHint)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Grow(sizeHint);
		}

		public void AppendLine()
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine();
		}

		public void AppendLine(char value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(string value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(ReadOnlySpan<char> value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine<T>(T value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine<T>(value);
		}

		public void AppendLine(byte value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(byte value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(DateTime value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(DateTime value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(DateTimeOffset value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(DateTimeOffset value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(decimal value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(decimal value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(double value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(double value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(short value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(short value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(int value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(int value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(long value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(long value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(sbyte value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(sbyte value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(float value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(float value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(TimeSpan value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(TimeSpan value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(ushort value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(ushort value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(uint value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(uint value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(ulong value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(ulong value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void AppendLine(Guid value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value);
		}

		public void AppendLine(Guid value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendLine(value, format);
		}

		public void Append(char value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(char value, int repeatCount)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, repeatCount);
		}

		public void Append(string value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(ReadOnlySpan<char> value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append<T>(T value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append<T>(value);
		}

		public void Append(ZStringBuilder value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((Utf16ValueStringBuilder)(ref _vsb)).Append<Utf16ValueStringBuilder>(value._vsb);
		}

		public void Append(byte value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(byte value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(DateTime value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(DateTime value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(DateTimeOffset value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(DateTimeOffset value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(decimal value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(decimal value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(double value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(double value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(short value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(short value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(int value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(int value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(long value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(long value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(sbyte value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(sbyte value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(float value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(float value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(TimeSpan value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(TimeSpan value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(ushort value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(ushort value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(uint value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(uint value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(ulong value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(ulong value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Append(Guid value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value);
		}

		public void Append(Guid value, string format)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Append(value, format);
		}

		public void Insert(int index, string value, int count)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Insert(index, value, count);
		}

		public void Insert(int index, string value)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Insert(index, value);
		}

		public void Insert(int index, ReadOnlySpan<char> value, int count)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Insert(index, value, count);
		}

		public void Replace(char oldChar, char newChar)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Replace(oldChar, newChar);
		}

		public void Replace(char oldChar, char newChar, int startIndex, int count)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Replace(oldChar, newChar, startIndex, count);
		}

		public void Replace(string oldValue, string newValue)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Replace(oldValue, newValue);
		}

		public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Replace(oldValue, newValue);
		}

		public void Replace(string oldValue, string newValue, int startIndex, int count)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Replace(oldValue, newValue, startIndex, count);
		}

		public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue, int startIndex, int count)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Replace(oldValue, newValue, startIndex, count);
		}

		public void ReplaceAt(char newChar, int replaceIndex)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).ReplaceAt(newChar, replaceIndex);
		}

		public void Remove(int startIndex, int length)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Remove(startIndex, length);
		}

		public bool TryCopyTo(Span<char> destination, out int charsWritten)
		{
			return ((Utf16ValueStringBuilder)(ref _vsb)).TryCopyTo(destination, ref charsWritten);
		}

		public override string ToString()
		{
			return ((object)(Utf16ValueStringBuilder)(ref _vsb)).ToString();
		}

		public Memory<char> GetMemory(int sizeHint)
		{
			return ((Utf16ValueStringBuilder)(ref _vsb)).GetMemory(sizeHint);
		}

		public Span<char> GetSpan(int sizeHint)
		{
			return ((Utf16ValueStringBuilder)(ref _vsb)).GetSpan(sizeHint);
		}

		public void Advance(int count)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Advance(count);
		}

		public void AppendFormat<T1>(ReadOnlySpan<char> format, T1 arg1)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1>(format, arg1);
		}

		public void AppendFormat<T1, T2>(ReadOnlySpan<char> format, T1 arg1, T2 arg2)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2>(format, arg1, arg2);
		}

		public void AppendFormat<T1, T2, T3>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3>(format, arg1, arg2, arg3);
		}

		public void AppendFormat<T1, T2, T3, T4>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4>(format, arg1, arg2, arg3, arg4);
		}

		public void AppendFormat<T1, T2, T3, T4, T5>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5>(format, arg1, arg2, arg3, arg4, arg5);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6>(format, arg1, arg2, arg3, arg4, arg5, arg6);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
		}

		public void AppendFormat<T1>(string format, T1 arg1)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1>(format, arg1);
		}

		public void AppendFormat<T1, T2>(string format, T1 arg1, T2 arg2)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2>(format, arg1, arg2);
		}

		public void AppendFormat<T1, T2, T3>(string format, T1 arg1, T2 arg2, T3 arg3)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3>(format, arg1, arg2, arg3);
		}

		public void AppendFormat<T1, T2, T3, T4>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4>(format, arg1, arg2, arg3, arg4);
		}

		public void AppendFormat<T1, T2, T3, T4, T5>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5>(format, arg1, arg2, arg3, arg4, arg5);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6>(format, arg1, arg2, arg3, arg4, arg5, arg6);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
		}

		public void AppendJoin<T>(char separator, params T[] values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, List<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, ReadOnlySpan<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, IEnumerable<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, ICollection<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, IList<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, IReadOnlyList<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(char separator, IReadOnlyCollection<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, params T[] values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, List<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, ReadOnlySpan<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, IEnumerable<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, ICollection<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, IList<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, IReadOnlyList<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		public void AppendJoin<T>(string separator, IReadOnlyCollection<T> values)
		{
			((Utf16ValueStringBuilder)(ref _vsb)).AppendJoin<T>(separator, values);
		}

		void IDisposable.Dispose()
		{
			((Utf16ValueStringBuilder)(ref _vsb)).Dispose();
			GC.SuppressFinalize(this);
		}
	}
	internal static class ZStringBuilderUtilities
	{
		internal const int DefaultBufferSize = 32768;

		internal static int CalcCapacity(Format format)
		{
			return format.Length + format.Items.Count * 8;
		}

		internal static ZStringBuilder CreateZStringBuilder()
		{
			return new ZStringBuilder(disposeImmediately: false);
		}

		internal static ZStringBuilder CreateZStringBuilder(Format format)
		{
			return CreateZStringBuilder(CalcCapacity(format));
		}

		internal static ZStringBuilder CreateZStringBuilder(int capacity)
		{
			ZStringBuilder zStringBuilder = new ZStringBuilder(disposeImmediately: false);
			if (capacity > 32768)
			{
				zStringBuilder.Grow(capacity - 32768);
			}
			return zStringBuilder;
		}
	}
	[ExcludeFromCodeCoverage]
	public sealed class ZStringWriter : TextWriter
	{
		private readonly ZStringWriter _zw;

		private Encoding? _encoding;

		public override Encoding Encoding => _encoding ?? (_encoding = new UnicodeEncoding(bigEndian: false, byteOrderMark: false));

		public ZStringWriter()
			: this(CultureInfo.CurrentCulture)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			_zw = new ZStringWriter((IFormatProvider)CultureInfo.CurrentCulture);
		}

		public ZStringWriter(IFormatProvider formatProvider)
			: base(formatProvider)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			_zw = new ZStringWriter(formatProvider);
		}

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

		protected override void Dispose(bool disposing)
		{
			((TextWriter)(object)_zw).Dispose();
			base.Dispose(disposing);
		}

		public override void Write(char value)
		{
			((TextWriter)(object)_zw).Write(value);
		}

		public override void Write(char[] buffer, int index, int count)
		{
			((TextWriter)(object)_zw).Write(buffer, index, count);
		}

		public override void Write(string? value)
		{
			((TextWriter)(object)_zw).Write(value ?? string.Empty);
		}

		public override void Write(bool value)
		{
			((TextWriter)(object)_zw).Write(value);
		}

		public override void Write(decimal value)
		{
			((TextWriter)(object)_zw).Write(value);
		}

		public override Task WriteAsync(char value)
		{
			return ((TextWriter)(object)_zw).WriteAsync(value);
		}

		public override Task WriteAsync(string? value)
		{
			return ((TextWriter)(object)_zw).WriteAsync(value ?? string.Empty);
		}

		public override Task WriteAsync(char[] buffer, int index, int count)
		{
			return ((TextWriter)(object)_zw).WriteAsync(buffer, index, count);
		}

		public override Task WriteLineAsync(char value)
		{
			return ((TextWriter)(object)_zw).WriteLineAsync(value);
		}

		public override Task WriteLineAsync(string? value)
		{
			return ((TextWriter)(object)_zw).WriteLineAsync(value ?? string.Empty);
		}

		public override Task WriteLineAsync(char[] buffer, int index, int count)
		{
			return ((TextWriter)(object)_zw).WriteLineAsync(buffer, index, count);
		}

		public override Task FlushAsync()
		{
			return ((TextWriter)(object)_zw).FlushAsync();
		}

		public override string ToString()
		{
			return ((object)_zw).ToString();
		}

		public override void Write(ReadOnlySpan<char> buffer)
		{
			((TextWriter)(object)_zw).Write(buffer);
		}

		public override void WriteLine(ReadOnlySpan<char> buffer)
		{
			((TextWriter)(object)_zw).WriteLine(buffer);
		}

		public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return ((TextWriter)(object)_zw).WriteAsync(buffer, cancellationToken);
		}

		public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return ((TextWriter)(object)_zw).WriteAsync(buffer, cancellationToken);
		}
	}
}
namespace SmartFormat.Utilities
{
	public class FormatDelegate : IFormattable
	{
		private readonly Func<string?, string>? _getFormat1;

		private readonly Func<string?, IFormatProvider?, string>? _getFormat2;

		public FormatDelegate(Func<string?, string> getFormat)
		{
			_getFormat1 = getFormat;
		}

		public FormatDelegate(Func<string?, IFormatProvider?, string> getFormat)
		{
			_getFormat2 = getFormat;
		}

		string IFormattable.ToString(string? format, IFormatProvider? formatProvider)
		{
			if (_getFormat1 != null)
			{
				return _getFormat1(format);
			}
			if (_getFormat2 != null)
			{
				return _getFormat2(format, formatProvider);
			}
			return string.Empty;
		}
	}
	public interface ILocalizationProvider
	{
		string? GetString(string name);

		string? GetString(string name, string cultureName);

		string? GetString(string name, CultureInfo cultureInfo);
	}
	public class LocalizationProvider : ILocalizationProvider
	{
		internal readonly Dictionary<string, ResourceManager> Resources = new Dictionary<string, ResourceManager>();

		public virtual CultureInfo? FallbackCulture { get; set; }

		public virtual bool ReturnNameIfNotFound { get; set; }

		public LocalizationProvider(bool isCaseSensitive = true, params ResourceManager[] resources)
		{
			foreach (ResourceManager resourceManager in resources)
			{
				DoAddResource(resourceManager, isCaseSensitive);
			}
		}

		public virtual void AddResource(ResourceManager resourceManager, bool isCaseSensitive = true)
		{
			DoAddResource(resourceManager, isCaseSensitive);
		}

		private void DoAddResource(ResourceManager resourceManager, bool isCaseSensitive = true)
		{
			if (!Resources.ContainsKey(resourceManager.BaseName))
			{
				resourceManager.IgnoreCase = !isCaseSensitive;
				Resources.Add(resourceManager.BaseName, resourceManager);
			}
		}

		public virtual bool Remove(string resourceBaseName)
		{
			return Resources.Remove(resourceBaseName);
		}

		public virtual void Clear()
		{
			Resources.Clear();
		}

		public virtual string? GetString(string name)
		{
			return GetString(name, (CultureInfo?)null);
		}

		public virtual string? GetString(string name, string cultureName)
		{
			return GetString(name, CultureInfo.GetCultureInfo(cultureName));
		}

		public virtual string? GetString(string name, CultureInfo? cultureInfo)
		{
			foreach (ResourceManager value in Resources.Values)
			{
				string text = ((cultureInfo != null) ? value.GetString(name, cultureInfo) : value.GetString(name));
				if (text == null && FallbackCulture != null)
				{
					text = value.GetString(name, FallbackCulture);
				}
				if (text != null)
				{
					return text;
				}
			}
			if (!ReturnNameIfNotFound)
			{
				return null;
			}
			return name;
		}
	}
	public static class PluralRules
	{
		public delegate int PluralRuleDelegate(decimal value, int pluralWordsCount);

		private static Dictionary<string, PluralRuleDelegate> DefaultLangToDelegate { get; } = new Dictionary<string, PluralRuleDelegate>
		{
			{ "az", Singular },
			{ "bm", Singular },
			{ "bo", Singular },
			{ "dz", Singular },
			{ "fa", Singular },
			{ "hu", Singular },
			{ "id", Singular },
			{ "ig", Singular },
			{ "ii", Singular },
			{ "ja", Singular },
			{ "jv", Singular },
			{ "ka", Singular },
			{ "kde", Singular },
			{ "kea", Singular },
			{ "km", Singular },
			{ "kn", Singular },
			{ "ko", Singular },
			{ "ms", Singular },
			{ "my", Singular },
			{ "root", Singular },
			{ "sah", Singular },
			{ "ses", Singular },
			{ "sg", Singular },
			{ "th", Singular },
			{ "to", Singular },
			{ "vi", Singular },
			{ "wo", Singular },
			{ "yo", Singular },
			{ "zh", Singular },
			{ "af", DualOneOther },
			{ "bem", DualOneOther },
			{ "bg", DualOneOther },
			{ "bn", DualOneOther },
			{ "brx", DualOneOther },
			{ "ca", DualOneOther },
			{ "cgg", DualOneOther },
			{ "chr", DualOneOther },
			{ "da", DualOneOther },
			{ "de", DualOneOther },
			{ "dv", DualOneOther },
			{ "ee", DualOneOther },
			{ "el", DualOneOther },
			{ "en", DualOneOther },
			{ "eo", DualOneOther },
			{ "es", DualOneOther },
			{ "et", DualOneOther },
			{ "eu", DualOneOther },
			{ "fi", DualOneOther },
			{ "fo", DualOneOther },
			{ "fur", DualOneOther },
			{ "fy", DualOneOther },
			{ "gl", DualOneOther },
			{ "gsw", DualOneOther },
			{ "gu", DualOneOther },
			{ "ha", DualOneOther },
			{ "haw", DualOneOther },
			{ "he", DualOneOther },
			{ "is", DualOneOther },
			{ "it", DualOneOther },
			{ "kk", DualOneOther },
			{ "kl", DualOneOther },
			{ "ku", DualOneOther },
			{ "lb", DualOneOther },
			{ "lg", DualOneOther },
			{ "lo", DualOneOther },
			{ "mas", DualOneOther },
			{ "ml", DualOneOther },
			{ "mn", DualOneOther },
			{ "mr", DualOneOther },
			{ "nah", DualOneOther },
			{ "nb", DualOneOther },
			{ "ne", DualOneOther },
			{ "nl", DualOneOther },
			{ "nn", DualOneOther },
			{ "no", DualOneOther },
			{ "nyn", DualOneOther },
			{ "om", DualOneOther },
			{ "or", DualOneOther },
			{ "pa", DualOneOther },
			{ "pap", DualOneOther },
			{ "ps", DualOneOther },
			{ "pt", DualOneOther },
			{ "rm", DualOneOther },
			{ "saq", DualOneOther },
			{ "so", DualOneOther },
			{ "sq", DualOneOther },
			{ "ssy", DualOneOther },
			{ "sw", DualOneOther },
			{ "sv", DualOneOther },
			{ "syr", DualOneOther },
			{ "ta", DualOneOther },
			{ "te", DualOneOther },
			{ "tk", DualOneOther },
			{ "tr", DualOneOther },
			{ "ur", DualOneOther },
			{ "wae", DualOneOther },
			{ "xog", DualOneOther },
			{ "zu", DualOneOther },
			{ "ak", DualWithZero },
			{ "am", DualWithZero },
			{ "bh", DualWithZero },
			{ "fil", DualWithZero },
			{ "guw", DualWithZero },
			{ "hi", DualWithZero },
			{ "ln", DualWithZero },
			{ "mg", DualWithZero },
			{ "nso", DualWithZero },
			{ "ti", DualWithZero },
			{ "tl", DualWithZero },
			{ "wa", DualWithZero },
			{ "ff", DualFromZeroToTwo },
			{ "fr", DualFromZeroToTwo },
			{ "kab", DualFromZeroToTwo },
			{ "ga", TripleOneTwoOther },
			{ "iu", TripleOneTwoOther },
			{ "ksh", TripleOneTwoOther },
			{ "kw", TripleOneTwoOther },
			{ "se", TripleOneTwoOther },
			{ "sma", TripleOneTwoOther },
			{ "smi", TripleOneTwoOther },
			{ "smj", TripleOneTwoOther },
			{ "smn", TripleOneTwoOther },
			{ "sms", TripleOneTwoOther },
			{ "be", RussianSerboCroatian },
			{ "bs", RussianSerboCroatian },
			{ "hr", RussianSerboCroatian },
			{ "ru", RussianSerboCroatian },
			{ "sh", RussianSerboCroatian },
			{ "sr", RussianSerboCroatian },
			{ "uk", RussianSerboCroatian },
			{ "ar", Arabic },
			{ "br", Breton },
			{ "cs", Czech },
			{ "cy", Welsh },
			{ "gv", Manx },
			{ "lag", Langi },
			{ "lt", Lithuanian },
			{ "lv", Latvian },
			{ "mb", Macedonian },
			{ "mo", Moldavian },
			{ "mt", Maltese },
			{ "pl", Polish },
			{ "ro", Romanian },
			{ "shi", Tachelhit },
			{ "sk", Slovak },
			{ "sl", Slovenian },
			{ "tzm", CentralMoroccoTamazight }
		};


		public static Dictionary<string, PluralRuleDelegate> IsoLangToDelegate { get; private set; } = new Dictionary<string, PluralRuleDelegate>(DefaultLangToDelegate);


		private static PluralRuleDelegate Singular => (decimal value, int pluralWordsCount) => 0;

		private static PluralRuleDelegate DualOneOther => (decimal value, int pluralWordsCount) => pluralWordsCount switch
		{
			2 => (!(value == 1m)) ? 1 : 0, 
			3 => (!(value == 0m)) ? ((value == 1m) ? 1 : 2) : 0, 
			4 => (!(value < 0m)) ? ((value == 0m) ? 1 : ((value == 1m) ? 2 : 3)) : 0, 
			_ => -1, 
		};

		private static PluralRuleDelegate DualWithZero => (decimal value, int pluralWordsCount) => (!(value == 0m) && !(value == 1m)) ? 1 : 0;

		private static PluralRuleDelegate DualFromZeroToTwo => delegate(decimal value, int pluralWordsCount)
		{
			switch (pluralWordsCount)
			{
			case 2:
				if (!(value >= 0m) || !(value < 2m))
				{
					return 1;
				}
				return 0;
			case 3:
				return GetWordsCount3Value(value);
			case 4:
				return GetWordsCount4Value(value);
			default:
				return -1;
			}
		};

		private static PluralRuleDelegate TripleOneTwoOther => (decimal value, int pluralWordsCount) => (!(value == 1m)) ? ((value == 2m) ? 1 : 2) : 0;

		private static PluralRuleDelegate RussianSerboCroatian => (decimal value, int pluralWordsCount) => (!(value % 10m == 1m) || !(value % 100m != 11m)) ? (((value % 10m).BetweenWithoutFraction(2m, 4m) && !(value % 100m).BetweenWithoutFraction(12m, 14m)) ? 1 : 2) : 0;

		private static PluralRuleDelegate Arabic => (decimal value, int pluralWordsCount) => (!(value == 0m)) ? ((value == 1m) ? 1 : ((!(value == 2m)) ? ((!(value % 100m).BetweenWithoutFraction(3m, 10m)) ? ((!(value % 100m).BetweenWithoutFraction(11m, 99m)) ? 5 : 4) : 3) : 2)) : 0;

		private static PluralRuleDelegate Breton => delegate(decimal value, int pluralWordsCount)
		{
			if (value <= 1m)
			{
				if (value == 0m)
				{
					return 0;
				}
				if (value == 1m)
				{
					return 1;
				}
			}
			else
			{
				if (value == 2m)
				{
					return 2;
				}
				if (value == 3m)
				{
					return 3;
				}
				if (value == 6m)
				{
					return 4;
				}
			}
			return 5;
		};

		private static PluralRuleDelegate Czech => (decimal value, int pluralWordsCount) => (!(value == 0m)) ? ((value == 1m) ? 1 : ((!value.BetweenWithoutFraction(2m, 4m)) ? ((!(value % 1m == 0m)) ? 4 : 3) : 2)) : 0;

		private static PluralRuleDelegate Welsh => delegate(decimal value, int pluralWordsCount)
		{
			if (value <= 1m)
			{
				if (value == 0m)
				{
					return 0;
				}
				if (value == 1m)
				{
					return 1;
				}
			}
			else
			{
				if (value == 2m)
				{
					return 2;
				}
				if (value == 3m)
				{
					return 3;
				}
				if (value == 6m)
				{
					return 4;
				}
			}
			return 5;
		};

		private static PluralRuleDelegate Manx => (decimal value, int pluralWordsCount) => (!(value % 10m).BetweenWithoutFraction(1m, 2m) && !(value % 20m == 0m)) ? 1 : 0;

		private static PluralRuleDelegate Langi => delegate(decimal value, int pluralWordsCount)
		{
			if (value > 0m)
			{
				if (value < 2m)
				{
					return 1;
				}
			}
			else if (value == 0m)
			{
				return 0;
			}
			return 2;
		};

		private static PluralRuleDelegate Lithuanian => (decimal value, int pluralWordsCount) => (!(value % 10m == 1m) || (value % 100m).BetweenWithoutFraction(11m, 19m)) ? (((value % 10m).BetweenWithoutFraction(2m, 9m) && !(value % 100m).BetweenWithoutFraction(11m, 19m)) ? 1 : 2) : 0;

		private static PluralRuleDelegate Latvian => (decimal value, int pluralWordsCount) => (!(value == 0m)) ? ((value % 10m == 1m && value % 100m != 11m) ? 1 : 2) : 0;

		private static PluralRuleDelegate Macedonian => (decimal value, int pluralWordsCount) => (!(value % 10m == 1m) || !(value != 11m)) ? 1 : 0;

		private static PluralRuleDelegate Moldavian => (decimal value, int pluralWordsCount) => (!(value == 1m)) ? ((value == 0m || (value != 1m && (value % 100m).BetweenWithoutFraction(1m, 19m))) ? 1 : 2) : 0;

		private static PluralRuleDelegate Maltese => (decimal value, int pluralWordsCount) => (!(value == 1m)) ? ((value == 0m || (value % 100m).BetweenWithoutFraction(2m, 10m)) ? 1 : ((!(value % 100m).BetweenWithoutFraction(11m, 19m)) ? 3 : 2)) : 0;

		private static PluralRuleDelegate Polish => (decimal value, int pluralWordsCount) => (!(value == 1m)) ? (((value % 10m).BetweenWithoutFraction(2m, 4m) && !(value % 100m).BetweenWithoutFraction(12m, 14m)) ? 1 : ((!(value % 10m).BetweenWithoutFraction(0m, 1m) && !(value % 10m).BetweenWithoutFraction(5m, 9m) && !(value % 100m).BetweenWithoutFraction(12m, 14m)) ? 3 : 2)) : 0;

		private static PluralRuleDelegate Romanian => (decimal value, int pluralWordsCount) => (!(value == 1m)) ? ((value == 0m || (value % 100m).BetweenWithoutFraction(1m, 19m)) ? 1 : 2) : 0;

		private static PluralRuleDelegate Tachelhit => (decimal value, int pluralWordsCount) => (!(value >= 0m) || !(value <= 1m)) ? (value.BetweenWithoutFraction(2m, 10m) ? 1 : 2) : 0;

		private static PluralRuleDelegate Slovak => (decimal value, int pluralWordsCount) => (!(value == 1m)) ? (value.BetweenWithoutFraction(2m, 4m) ? 1 : 2) : 0;

		private static PluralRuleDelegate Slovenian => (decimal value, int pluralWordsCount) => (!(value % 100m == 1m)) ? ((value % 100m == 2m) ? 1 : ((!(value % 100m).BetweenWithoutFraction(3m, 4m)) ? 3 : 2)) : 0;

		private static PluralRuleDelegate CentralMoroccoTamazight => (decimal value, int pluralWordsCount) => (!value.BetweenWithoutFraction(0m, 1m) && !value.BetweenWithoutFraction(11m, 99m)) ? 1 : 0;

		public static void RestoreDefault()
		{
			IsoLangToDelegate = new Dictionary<string, PluralRuleDelegate>(DefaultLangToDelegate);
		}

		private static int GetWordsCount3Value(decimal n)
		{
			if (n > 0m)
			{
				if (n < 2m)
				{
					return 1;
				}
			}
			else if (n == 0m)
			{
				return 0;
			}
			return 2;
		}

		private static int GetWordsCount4Value(decimal n)
		{
			if (!(n < 0m))
			{
				if (n < 2m)
				{
					if (n == 0m)
					{
						return 1;
					}
					return 2;
				}
				return 3;
			}
			return 0;
		}

		public static PluralRuleDelegate GetPluralRule(string? twoLetterIsoLanguageName)
		{
			if (twoLetterIsoLanguageName != null && IsoLangToDelegate.TryGetValue(twoLetterIsoLanguageName, out PluralRuleDelegate value))
			{
				return value;
			}
			throw new ArgumentException("IsoLangToDelegate not found for " + (twoLetterIsoLanguageName ?? "'null'"), "twoLetterIsoLanguageName");
		}

		private static bool BetweenWithoutFraction(this decimal value, decimal min, decimal max)
		{
			if (value % 1m == 0m && value >= min)
			{
				return value <= max;
			}
			return false;
		}
	}
	public static class SystemTime
	{
		public static Func<DateTime> Now { get; private set; } = () => DateTime.Now;


		public static Func<DateTimeOffset> OffsetNow { get; private set; } = () => DateTimeOffset.Now;


		public static void SetDateTime(DateTime dateTimeNow)
		{
			Now = () => dateTimeNow;
		}

		public static void SetDateTimeOffset(DateTimeOffset dateTimeOffset)
		{
			OffsetNow = () => dateTimeOffset;
		}

		public static void ResetDateTime()
		{
			Now = () => DateTime.Now;
			OffsetNow = () => DateTimeOffset.Now;
		}
	}
	public static class TupleExtensions
	{
		[CompilerGenerated]
		private sealed class <GetValueTupleItemObjectsFlattened>d__5 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object? <>2__current;

			private int <>l__initialThreadId;

			private object tuple;

			public object <>3__tuple;

			private IEnumerator<object?> <>7__wrap1;

			private IEnumerator<object?> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <GetValueTupleItemObjectsFlattened>d__5(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 || (uint)(num - 1) <= 2u)
				{
					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
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = tuple.GetValueTupleItemObjects().GetEnumerator();
						<>1__state = -3;
						goto IL_00fe;
					case 1:
						<>1__state = -4;
						goto IL_00a9;
					case 2:
						<>1__state = -3;
						goto IL_00fe;
					case 3:
						{
							<>1__state = -3;
							goto IL_00fe;
						}
						IL_00fe:
						if (<>7__wrap1.MoveNext())
						{
							object current = <>7__wrap1.Current;
							if (current != null && current.IsValueTuple())
							{
								<>7__wrap2 = current.GetValueTupleItemObjectsFlattened().GetEnumerator();
								<>1__state = -4;
								goto IL_00a9;
							}
							if (current == null)
							{
								<>2__current = null;
								<>1__state = 2;
								return true;
							}
							<>2__current = current;
							<>1__state = 3;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						return false;
						IL_00a9:
						if (<>7__wrap2.MoveNext())
						{
							object current2 = <>7__wrap2.Current;
							<>2__current = current2;
							<>1__state = 1;
							return true;
						}
						<>m__Finally2();
						<>7__wrap2 = null;
						goto IL_00fe;
					}
				}
				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<object> IEnumerable<object>.GetEnumerator()
			{
				<GetValueTupleItemObjectsFlattened>d__5 <GetValueTupleItemObjectsFlattened>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetValueTupleItemObjectsFlattened>d__ = this;
				}
				else
				{
					<GetValueTupleItemObjectsFlattened>d__ = new <GetValueTupleItemObjectsFlattened>d__5(0);
				}
				<GetValueTupleItemObjectsFlattened>d__.tuple = <>3__tuple;
				return <GetValueTupleItemObjectsFlattened>d__;
			}

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

		private static readonly HashSet<Type> ValueTupleTypes = new HashSet<Type>(new Type[8]
		{
			typeof(ValueTuple<>),
			typeof(ValueTuple<, >),
			typeof(ValueTuple<, , >),
			typeof(ValueTuple<, , , >),
			typeof(ValueTuple<, , , , >),
			typeof(ValueTuple<, , , , , >),
			typeof(ValueTuple<, , , , , , >),
			typeof(ValueTuple<, , , , , , , >)
		});

		public static bool IsValueTuple(this object obj)
		{
			return obj.GetType().IsValueTupleType();
		}

		public static bool IsValueTupleType(this Type type)
		{
			if (type.GetTypeInfo().IsGenericType)
			{
				return ValueTupleTypes.Contains(type.GetGenericTypeDefinition());
			}
			return false;
		}

		public static IEnumerable<object?> GetValueTupleItemObjects(this object tuple)
		{
			object tuple2 = tuple;
			return from f in tuple2.GetType().GetValueTupleItemFields()
				select f.GetValue(tuple2);
		}

		public static List<FieldInfo> GetValueTupleItemFields(this Type tupleType)
		{
			List<FieldInfo> list = new List<FieldInfo>();
			int num = 1;
			FieldInfo runtimeField;
			while ((runtimeField = tupleType.GetRuntimeField($"Item{num}")) != null)
			{
				num++;
				list.Add(runtimeField);
			}
			return list;
		}

		[IteratorStateMachine(typeof(<GetValueTupleItemObjectsFlattened>d__5))]
		public static IEnumerable<object?> GetValueTupleItemObjectsFlattened(this object tuple)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetValueTupleItemObjectsFlattened>d__5(-2)
			{
				<>3__tuple = tuple
			};
		}
	}
	internal static class Validation
	{
		private static readonly char[] Valid = new char[3] { '|', ',', '~' };

		public static char GetValidSplitCharOrThrow(char toCheck)
		{
			if (toCheck != Valid[0] && toCheck != Valid[1] && toCheck != Valid[2])
			{
				throw new ArgumentException($"Only '{Valid[0]}', '{Valid[1]}' and '{Valid[2]}' are valid split chars.");
			}
			return toCheck;
		}
	}
}
namespace SmartFormat.Pooling
{
	[Serializable]
	public class PoolingException : InvalidOperationException
	{
		public Type PoolType { get; }

		public PoolingException(string message, Type poolType)
			: base(message)
		{
			PoolType = poolType;
		}

		[Obsolete("This API supports obsolete formatter-based serialization. It will be removed in version 4.")]
		protected PoolingException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			PoolType = typeof(object);
		}
	}
	internal static class PoolRegistry
	{
		public static readonly ConcurrentDictionary<Type, object> Items = new ConcurrentDictionary<Type, object>();

		public static T GetOrAdd<T>(T pool) where T : class
		{
			return (T)Items.GetOrAdd(typeof(T), pool);
		}

		public static void TryRemove<T>(T pool) where T : class
		{
			Items.TryRemove(typeof(T), out object _);
		}

		public static T? Get<T>() where T : class
		{
			return (T)Items[typeof(T)];
		}
	}
}
namespace SmartFormat.Pooling.SpecializedPools
{
	internal class CollectionPool<TCollection, TItem> : SpecializedPoolAbstract<TCollection> where TCollection : class, ICollection<TItem>, new()
	{
		private static readonly Lazy<CollectionPool<TCollection, TItem>> Lazy = new Lazy<CollectionPool<TCollection, TItem>>(() => new CollectionPool<TCollection, TItem>(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static CollectionPool<TCollection, TItem> Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		protected CollectionPool()
		{
			Policy.FunctionOnCreate = () => new TCollection();
			Policy.ActionOnReturn = delegate(TCollection coll)
			{
				coll.Clear();
			};
		}
	}
	internal sealed class DictionaryPool<TKey, TValue> : CollectionPool<Dictionary<TKey, TValue>, KeyValuePair<TKey, TValue>> where TKey : notnull
	{
		private static readonly Lazy<DictionaryPool<TKey, TValue>> Lazy = new Lazy<DictionaryPool<TKey, TValue>>(() => new DictionaryPool<TKey, TValue>(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public new static DictionaryPool<TKey, TValue> Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private DictionaryPool()
		{
		}
	}
	internal sealed class HashSetPool<T> : CollectionPool<HashSet<T>, T>
	{
		private static readonly Lazy<HashSetPool<T>> Lazy = new Lazy<HashSetPool<T>>(() => new HashSetPool<T>(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public new static HashSetPool<T> Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private HashSetPool()
		{
		}
	}
	internal sealed class ListPool<T> : CollectionPool<List<T>, T>
	{
		private static readonly Lazy<ListPool<T>> Lazy = new Lazy<ListPool<T>>(() => new ListPool<T>(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public new static ListPool<T> Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private ListPool()
		{
		}
	}
	internal abstract class SpecializedPoolAbstract<T> : IDisposable where T : class
	{
		private bool _isThreadSafeMode = SmartSettings.IsThreadSafeMode;

		protected readonly PoolPolicy<T> Policy = new PoolPolicy<T>();

		internal ObjectPool<T> Pool { get; set; }

		public bool IsThreadSafeMode => _isThreadSafeMode;

		protected SpecializedPoolAbstract()
		{
			Pool = LazyCreateObjectPool();
		}

		internal void Reset(bool? isThreadSafeMode)
		{
			_isThreadSafeMode = isThreadSafeMode ?? SmartSettings.IsThreadSafeMode;
			PoolRegistry.TryRemove(this);
			Pool.Dispose();
			Pool = LazyCreateObjectPool();
		}

		private ObjectPool<T> LazyCreateObjectPool()
		{
			if (!_isThreadSafeMode)
			{
				return new Lazy<ObjectPoolSingleThread<T>>(() => new ObjectPoolSingleThread<T>(Policy), LazyThreadSafetyMode.None).Value;
			}
			return new Lazy<ObjectPoolConcurrent<T>>(() => new ObjectPoolConcurrent<T>(Policy), LazyThreadSafetyMode.PublicationOnly).Value;
		}

		public virtual T Get()
		{
			if (!PoolSettings.IsPoolingEnabled)
			{
				return Policy.FunctionOnCreate();
			}
			return Pool.Get();
		}

		public virtual PooledObject<T> Get(out T instance)
		{
			if (!PoolSettings.IsPoolingEnabled)
			{
				instance = Policy.FunctionOnCreate();
				return new PooledObject<T>(instance, Pool);
			}
			instance = Get();
			return new PooledObject<T>(instance, Pool);
		}

		public virtual void Return(T toReturn)
		{
			if (PoolSettings.IsPoolingEnabled)
			{
				Pool.Return(toReturn);
			}
		}

		public virtual void Clear()
		{
			Pool.Clear();
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				Reset(null);
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal sealed class StringBuilderPool : SpecializedPoolAbstract<StringBuilder>
	{
		private static readonly Lazy<StringBuilderPool> Lazy = new Lazy<StringBuilderPool>(() => new StringBuilderPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public int DefaultStringBuilderCapacity { get; set; } = 1024;


		public static StringBuilderPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private StringBuilderPool()
		{
			Policy.FunctionOnCreate = () => new StringBuilder(DefaultStringBuilderCapacity);
			Policy.ActionOnReturn = delegate(StringBuilder sb)
			{
				sb.Clear();
				sb.Capacity = DefaultStringBuilderCapacity;
			};
		}
	}
}
namespace SmartFormat.Pooling.SmartPools
{
	internal sealed class FormatDetailsPool : SmartPoolAbstract<FormatDetails>
	{
		private static readonly Lazy<FormatDetailsPool> Lazy = new Lazy<FormatDetailsPool>(() => new FormatDetailsPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static FormatDetailsPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private FormatDetailsPool()
		{
			Policy.FunctionOnCreate = () => new FormatDetails();
			Policy.ActionOnReturn = delegate(FormatDetails fd)
			{
				fd.Clear();
			};
		}

		public override void Return(FormatDetails toReturn)
		{
			if (toReturn == InitializationObject.FormatDetails)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal sealed class FormatPool : SmartPoolAbstract<Format>
	{
		private static readonly Lazy<FormatPool> Lazy = new Lazy<FormatPool>(() => new FormatPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static FormatPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private FormatPool()
		{
			Policy.FunctionOnCreate = () => new Format();
			Policy.ActionOnReturn = delegate(Format fmt)
			{
				fmt.ReturnToPool();
			};
		}

		public override void Return(Format toReturn)
		{
			if (toReturn == InitializationObject.Format)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal sealed class FormattingInfoPool : SmartPoolAbstract<FormattingInfo>
	{
		private static readonly Lazy<FormattingInfoPool> Lazy = new Lazy<FormattingInfoPool>(() => new FormattingInfoPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static FormattingInfoPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private FormattingInfoPool()
		{
			Policy.FunctionOnCreate = () => new FormattingInfo();
			Policy.ActionOnReturn = delegate(FormattingInfo fi)
			{
				fi.ReturnToPool();
			};
		}

		public override void Return(FormattingInfo toReturn)
		{
			if (toReturn == InitializationObject.FormattingInfo)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal static class InitializationObject
	{
		public static readonly IList<object?> ObjectList = new List<object>(1);

		public static readonly List<int> IntegerList = new List<int>(1);

		public static readonly SmartSettings SmartSettings = new SmartSettings();

		public static readonly SmartFormatter SmartFormatter = new SmartFormatter(SmartSettings);

		public static readonly Format Format = new Format().Initialize(SmartSettings, "init");

		public static readonly LiteralText LiteralText = new LiteralText().Initialize(SmartSettings, Format, string.Empty, 0, 0);

		public static readonly Placeholder Placeholder = new Placeholder().Initialize(Format, 0, 0);

		public static readonly Selector Selector = new Selector().Initialize(SmartSettings, Placeholder, string.Empty, 0, 0, 0, 0);

		public static readonly IOutput Output = new NullOutput();

		public static readonly FormatDetails FormatDetails = new FormatDetails().Initialize(SmartFormatter, Format, ObjectList, null, Output);

		public static readonly FormattingInfo FormattingInfo = new FormattingInfo().Initialize(FormatDetails, Format, null);

		public static readonly ParsingErrors ParsingErrors = new ParsingErrors().Initialize(Format);

		public static readonly SplitList SplitList = new SplitList().Initialize(Format, IntegerList);
	}
	internal sealed class LiteralTextPool : SmartPoolAbstract<LiteralText>
	{
		private static readonly Lazy<LiteralTextPool> Lazy = new Lazy<LiteralTextPool>(() => new LiteralTextPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static LiteralTextPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private LiteralTextPool()
		{
			Policy.FunctionOnCreate = () => new LiteralText();
			Policy.ActionOnReturn = delegate(LiteralText lt)
			{
				lt.Clear();
			};
		}

		public override void Return(LiteralText toReturn)
		{
			if (toReturn == InitializationObject.LiteralText)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal sealed class ParserStatePool : SmartPoolAbstract<ParserState>
	{
		private static readonly Lazy<ParserStatePool> Lazy = new Lazy<ParserStatePool>(() => new ParserStatePool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static ParserStatePool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private ParserStatePool()
		{
			Policy.FunctionOnCreate = () => new ParserState();
			Policy.ActionOnReturn = delegate(ParserState state)
			{
				state.Clear();
			};
		}
	}
	internal sealed class ParsingErrorsPool : SmartPoolAbstract<ParsingErrors>
	{
		private static readonly Lazy<ParsingErrorsPool> Lazy = new Lazy<ParsingErrorsPool>(() => new ParsingErrorsPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static ParsingErrorsPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private ParsingErrorsPool()
		{
			Policy.FunctionOnCreate = () => new ParsingErrors();
			Policy.ActionOnReturn = delegate(ParsingErrors pe)
			{
				pe.Clear();
			};
		}

		public override void Return(ParsingErrors toReturn)
		{
			if (toReturn == InitializationObject.ParsingErrors)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal sealed class PlaceholderPool : SmartPoolAbstract<Placeholder>
	{
		private static readonly Lazy<PlaceholderPool> Lazy = new Lazy<PlaceholderPool>(() => new PlaceholderPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static PlaceholderPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private PlaceholderPool()
		{
			Policy.FunctionOnCreate = () => new Placeholder();
			Policy.ActionOnReturn = delegate(Placeholder ph)
			{
				ph.ReturnToPool();
			};
		}

		public override void Return(Placeholder toReturn)
		{
			if (toReturn == InitializationObject.Placeholder)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal sealed class SelectorPool : SmartPoolAbstract<Selector>
	{
		private static readonly Lazy<SelectorPool> Lazy = new Lazy<SelectorPool>(() => new SelectorPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static SelectorPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private SelectorPool()
		{
			Policy.FunctionOnCreate = () => new Selector();
			Policy.ActionOnReturn = delegate(Selector selector)
			{
				selector.Clear();
			};
		}

		public override void Return(Selector toReturn)
		{
			if (toReturn == InitializationObject.Selector)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal abstract class SmartPoolAbstract<T> : SpecializedPoolAbstract<T> where T : class
	{
		public override T Get()
		{
			return base.Get();
		}

		public override PooledObject<T> Get(out T instance)
		{
			return base.Get(out instance);
		}
	}
	internal sealed class SplitListPool : SmartPoolAbstract<SplitList>
	{
		private static readonly Lazy<SplitListPool> Lazy = new Lazy<SplitListPool>(() => new SplitListPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static SplitListPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private SplitListPool()
		{
			Policy.FunctionOnCreate = () => new SplitList();
			Policy.ActionOnReturn = delegate(SplitList sl)
			{
				sl.Clear();
			};
		}

		public override void Return(SplitList toReturn)
		{
			if (toReturn == InitializationObject.SplitList)
			{
				throw new PoolingException("InitializationObjects cannot be returned to the pool.", GetType());
			}
			base.Return(toReturn);
		}
	}
	internal sealed class StringOutputPool : SmartPoolAbstract<StringOutput>
	{
		private static readonly Lazy<StringOutputPool> Lazy = new Lazy<StringOutputPool>(() => new StringOutputPool(), SmartSettings.IsThreadSafeMode ? LazyThreadSafetyMode.PublicationOnly : LazyThreadSafetyMode.None);

		public static StringOutputPool Instance => PoolRegistry.GetOrAdd(Lazy.Value);

		private StringOutputPool()
		{
			Policy.FunctionOnCreate = () => new StringOutput();
			Policy.ActionOnReturn = delegate(StringOutput so)
			{
				so.Clear();
			};
		}
	}
}
namespace SmartFormat.Pooling.ObjectPools
{
	internal interface IObjectPool<T> : IDisposable, IPoolCounters where T : class
	{
		IReadOnlyList<T> PoolItems { get; }

		T Get();

		PooledObject<T> Get(out T instance);

		void Return(T element);

		void Clear();
	}
	internal interface IPoolCounters
	{
		int CountAll { get; }

		int CountActive { get; }

		int CountInactive { get; }
	}
	internal class LinkedPool<T> : ObjectPool<T> where T : class
	{
		internal class LinkedPoolItem
		{
			internal LinkedPoolItem? PoolNext;

			internal T? Value;
		}

		[CompilerGenerated]
		private sealed class <GetAllPoolItems>d__17 : IEnumerable<LinkedPoolItem>, IEnumerable, IEnumerator<LinkedPoolItem>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private LinkedPoolItem <>2__current;

			private int <>l__initialThreadId;

			public LinkedPool<T> <>4__this;

			private LinkedPoolItem <item>5__2;

			LinkedPool<T>.LinkedPoolItem IEnumerator<LinkedPoolItem>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				LinkedPool<T> linkedPool = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_005a;
				}
				<>1__state = -1;
				<item>5__2 = linkedPool.PoolFirst;
				goto IL_006b;
				IL_005a:
				<item>5__2 = <item>5__2.PoolNext;
				goto IL_006b;
				IL_006b:
				if (<item>5__2 != null)
				{
					if (<item>5__2.Value != null)
					{
						<>2__current = <item>5__2;
						<>1__state = 1;
						return true;
					}
					goto IL_005a;
				}
				<item>5__2 = 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<LinkedPoolItem> IEnumerable<LinkedPoolItem>.GetEnumerator()
			{
				<GetAllPoolItems>d__17 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetAllPoolItems>d__17(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		internal LinkedPoolItem? PoolFirst;

		internal LinkedPoolItem? NextAvailableListItem;

		private int _countAll;

		private int _countInactive;

		public override bool IsThreadSafeMode => false;

		public override int CountAll => _countAll;

		public override IReadOnlyList<T> PoolItems => (from i in GetAllPoolItems()
			where i.Value != null
			select i.Value).ToList().AsReadOnly();

		public override int CountInactive => _countInactive;

		public LinkedPool(PoolPolicy<T> poolPolicy)
			: base(poolPolicy)
		{
		}

		public override T Get()
		{
			if (!PoolSettings.IsPoolingEnabled)
			{
				return base.PoolPolicy.FunctionOnCreate();
			}
			T result;
			if (PoolFirst == null)
			{
				result = base.PoolPolicy.FunctionOnCreate();
				_countAll++;
				return result;
			}
			LinkedPoolItem poolFirst = PoolFirst;
			result = poolFirst.Value;
			PoolFirst = poolFirst.PoolNext;
			poolFirst.PoolNext = NextAvailableListItem;
			NextAvailableListItem = poolFirst;
			NextAvailableListItem.Value = null;
			_countInactive--;
			base.PoolPolicy.ActionOnGet?.Invoke(result);
			return result;
		}

		public override void Return(T element)
		{
			if (!PoolSettings.IsPoolingEnabled)
			{
				return;
			}
			for (LinkedPoolItem linkedPoolItem = PoolFirst; linkedPoolItem != null; linkedPoolItem = linkedPoolItem.PoolNext)
			{
				if (PoolSettings.CheckReturnedObjectsExistInPool && linkedPoolItem.Value == element)
				{
					throw new PoolingException("Trying to return an object that has already been returned to the pool.", GetType());
				}
			}
			base.PoolPolicy.ActionOnReturn?.Invoke(element);
			if (CountInactive < base.PoolPolicy.MaximumPoolSize)
			{
				LinkedPoolItem linkedPoolItem2 = NextAvailableListItem;
				if (linkedPoolItem2 == null)
				{
					linkedPoolItem2 = new LinkedPoolItem();
				}
				else
				{
					NextAvailableListItem = linkedPoolItem2.PoolNext;
				}
				linkedPoolItem2.Value = element;
				linkedPoolItem2.PoolNext = PoolFirst;
				PoolFirst = linkedPoolItem2;
				_countInactive++;
			}
			else
			{
				base.PoolPolicy.ActionOnDestroy?.Invoke(element);
			}
		}

		public override void Clear()
		{
			if (base.PoolPolicy.ActionOnDestroy != null)
			{
				foreach (T item in from item in GetAllPoolItems()
					select item.Value)
				{
					if (item != null)
					{
						base.PoolPolicy.ActionOnDestroy(item);
					}
				}
			}
			PoolFirst = null;
			NextAvailableListItem = null;
			_countInactive = 0;
			_countAll = 0;
		}

		[IteratorStateMachine(typeof(LinkedPool<>.<GetAllPoolItems>d__17))]
		private IEnumerable<LinkedPoolItem> GetAllPoolItems()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllPoolItems>d__17(-2)
			{
				<>4__this = this
			};
		}
	}
	internal abstract class ObjectPool<T> : IObjectPool<T>, IDisposable, IPoolCounters where T : class
	{
		public abstract bool IsThreadSafeMode { get; }

		[Obsolete("Use PoolSettings.IsPoolingEnabled instead.")]
		public bool IsPoolingEnabled
		{
			get
			{
				return PoolSettings.IsPoolingEnabled;
			}
			internal set
			{
				PoolSettings.IsPoolingEnabled = value;
			}
		}

		protected PoolPolicy<T> PoolPolicy { get; }

		public abstract int CountAll { get; }

		public abstract IReadOnlyList<T> PoolItems { get; }

		public int CountActive => CountAll - CountInactive;

		public abstract int CountInactive { get; }

		protected ObjectPool(PoolPolicy<T> poolPolicy)
		{
			PoolPolicy = poolPolicy;
		}

		public abstract T Get();

		public PooledObject<T> Get(out T instance)
		{
			instance = Get();
			return new PooledObject<T>(instance, this);
		}

		public abstract void Return(T element);

		public abstract void Clear();

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				Clear();
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal class ObjectPoolConcurrent<T> : ObjectPool<T> where T : class
	{
		private readonly ConcurrentStack<T> _stack;

		private int _countAll;

		public override bool IsThreadSafeMode => true;

		public override int CountAll => _countAll;

		public override IReadOnlyList<T> PoolItems => _stack.ToList().AsReadOnly();

		public override int CountInactive => _stack.Count;

		public ObjectPoolConcurrent(PoolPolicy<T> poolPolicy)
			: base(poolPolicy)
		{
			_stack = new ConcurrentStack<T>();
		}

		public override T Get()
		{
			if (!PoolSettings.IsPoolingEnabled)
			{
				return base.PoolPolicy.FunctionOnCreate();
			}
			if (!_stack.TryPop(out var result))
			{
				result = base.PoolPolicy.FunctionOnCreate();
				Interlocked.Increment(ref _countAll);
				return result;
			}
			base.PoolPolicy.ActionOnGet?.Invoke(result);
			return result;
		}

		public override void Return(T element)
		{
			if (PoolSettings.IsPoolingEnabled)
			{
				if (PoolSettings.CheckReturnedObjectsExistInPool && !_stack.IsEmpty && _stack.Contains(element))
				{
					throw new PoolingException($"Trying to return an object of type '{element.GetType()}', that has already been returned to the pool.", GetType());
				}
				base.PoolPolicy.ActionOnReturn?.Invoke(element);
				if (CountInactive < base.PoolPolicy.MaximumPoolSize)
				{
					_stack.Push(element);
				}
				else
				{
					base.PoolPolicy.ActionOnDestroy?.Invoke(element);
				}
			}
		}

		public override void Clear()
		{
			if (base.PoolPolicy.ActionOnDestroy != null)
			{
				foreach (T item in _stack)
				{
					base.PoolPolicy.ActionOnDestroy(item);
				}
			}
			_stack.Clear();
			_countAll = 0;
		}
	}
	internal class ObjectPoolSingleThread<T> : ObjectPool<T> where T : class
	{
		private readonly Stack<T> _stack;

		private int _countAll;

		public override bool IsThreadSafeMode => false;

		public override int CountAll => _countAll;

		public override IReadOnlyList<T> PoolItems => _stack.ToList().AsReadOnly();

		public override int CountInactive => _stack.Count;

		public ObjectPoolSingleThread(PoolPolicy<T> poolPolicy)
			: base(poolPolicy)
		{
			_stack = new Stack<T>(poolPolicy.InitialPoolSize);
		}

		public override T Get()
		{
			if (!PoolSettings.IsPoolingEnabled)
			{
				return base.PoolPolicy.FunctionOnCreate();
			}
			T result;
			if (_stack.Count == 0)
			{
				result = base.PoolPolicy.FunctionOnCreate();
				_countAll++;
				return result;
			}
			try
			{
				result = _stack.Pop();
			}
			catch
			{
				result = base.PoolPolicy.FunctionOnCreate();
				Interlocked.Increment(ref _countAll);
				return result;
			}
			base.PoolPolicy.ActionOnGet?.Invoke(result);
			return result;
		}

		public override void Return(T element)
		{
			if (PoolSettings.IsPoolingEnabled)
			{
				if (PoolSettings.CheckReturnedObjectsExistInPool && _stack.Count > 0 && _stack.Contains(element))
				{
					throw new PoolingException($"Trying to return an object of type '{element.GetType()}', that has already been returned to the pool.", GetType());
				}
				base.PoolPolicy.ActionOnReturn?.Invoke(element);
				if (CountInactive < base.PoolPolicy.MaximumPoolSize)
				{
					_stack.Push(element);
				}
				else
				{
					base.PoolPolicy.ActionOnDestroy?.Invoke(element);
				}
			}
		}

		public override void Clear()
		{
			if (base.PoolPolicy.ActionOnDestroy != null)
			{
				foreach (T item in _stack)
				{
					base.PoolPolicy.ActionOnDestroy(item);
				}
			}
			_stack.Clear();
			_countAll = 0;
		}
	}
	internal readonly struct PooledObject<T> : IDisposable where T : class
	{
		private readonly T _value;

		private readonly IObjectPool<T> _pool;

		internal PooledObject(T value, IObjectPool<T> pool)
		{
			_value = value;
			_pool = pool;
		}

		void IDisposable.Dispose()
		{
			_pool.Return(_value);
		}
	}
	internal class PoolPolicy<T> where T : class
	{
		private uint _maximumPoolSize = 10000u;

		public uint MaximumPoolSize
		{
			get
			{
				return _maximumPoolSize;
			}
			set
			{
				if (value == 0)
				{
					throw new PoolingException("Policy for MaximumPoolSize size must be greater than 0", typeof(T));
				}
				_maximumPoolSize = value;
			}
		}

		public int InitialPoolSize { get; set; } = 10;


		public Func<T> FunctionOnCreate { get; set; } = delegate
		{
			throw new PoolingException("'FunctionOnCreate' is not set in PoolPolicy.", typeof(T));
		};


		public Action<T>? ActionOnDestroy { get; set; }

		public Action<T>? ActionOnGet { get; set; }

		public Action<T>? ActionOnReturn { get; set; }
	}
}
namespace SmartFormat.Extensions
{
	public class ChooseFormatter : IFormatter
	{
		private CultureInfo? _cultureInfo;

		private char _splitChar = '|';

		public char SplitChar
		{
			get
			{
				return _splitChar;
			}
			set
			{
				_splitChar = Validation.GetValidSplitCharOrThrow(value);
			}
		}

		[Obsolete("Use property \"Name\" instead", true)]
		public string[] Names { get; set; } = new string[2] { "choose", "c" };


		public string Name { get; set; } = "choose";


		public bool CanAutoDetect { get; set; }

		public CaseSensitivityType CaseSensitivity { get; set; }

		public bool TryEvaluateFormat(IFormattingInfo formattingInfo)
		{
			string[] chooseOptions = formattingInfo.FormatterOptions.Split(SplitChar);
			IList<Format> list = formattingInfo.Format?.Split(SplitChar);
			if (list == null || list.Count < 2)
			{
				if (string.IsNullOrEmpty(formattingInfo.Placeholder?.FormatterName))
				{
					return false;
				}
				throw new FormatException("Formatter named '" + formattingInfo.Placeholder?.FormatterName + "' requires at least 2 format options.");
			}
			_cultureInfo = (formattingInfo.FormatDetails.Provider as CultureInfo) ?? CultureInfo.CurrentUICulture;
			Format format = DetermineChosenFormat(formattingInfo, list, chooseOptions);
			formattingInfo.FormatAsChild(format, formattingInfo.CurrentValue);
			return true;
		}

		private Format DetermineChosenFormat(IFormattingInfo formattingInfo, IList<Format> choiceFormats, string[] chooseOptions)
		{
			string currentValueString;
			int num = GetChosenIndex(formattingInfo, chooseOptions, out currentValueString);
			if (choiceFormats.Count < chooseOptions.Length)
			{
				throw formattingInfo.FormattingException("You must specify at least " + chooseOptions.Length + " choices");
			}
			if (choiceFormats.Count > chooseOptions.Length + 1)
			{
				throw formattingInfo.FormattingException("You cannot specify more than " + (chooseOptions.Length + 1) + " choices");
			}
			if (num == -1 && choiceFormats.Count == chooseOptions.Length)
			{
				throw formattingInfo.FormattingException("\"" + currentValueString + "\" is not a valid choice, and a \"default\" choice was not supplied");
			}
			if (num == -1)
			{
				num = choiceFormats.Count - 1;
			}
			return choiceFormats[num];
		}

		private int GetChosenIndex(IFormattingInfo formattingInfo, string[] chooseOptions, out string currentValueString)
		{
			IFormattingInfo formattingInfo2 = formattingInfo;
			object currentValue = formattingInfo2.CurrentValue;
			string valAsString;
			if (currentValue != null)
			{
				if (currentValue is bool flag)
				{
					valAsString = (currentValueString = flag.ToString());
					return Array.FindIndex(chooseOptions, (string t) => t.Equals(valAsString, StringComparison.OrdinalIgnoreCase));
				}
				valAsString = (currentValueString = formattingInfo2.CurrentValue.ToString());
				return Array.FindIndex(chooseOptions, (string t) => AreEqual(t, valAsString, formattingInfo2.FormatDetails.Settings.CaseSensitivity));
			}
			valAsString = (currentValueString = "null");
			return Array.FindIndex(chooseOptions, (string t) => t.Equals(valAsString, StringComparison.OrdinalIgnoreCase));
		}

		private bool AreEqual(string s1, string s2, CaseSensitivityType caseSensitivityFromSettings)
		{
			CultureInfo cultureInfo = _cultureInfo;
			if (((caseSensitivityFromSettings == CaseSensitivity) ? caseSensitivityFromSettings : CaseSensitivity) != 0)
			{
				return cultureInfo.CompareInfo.Compare(s1, s2, CompareOptions.IgnoreCase) == 0;
			}
			return cultureInfo.CompareInfo.Compare(s1, s2, CompareOptions.None) == 0;
		}
	}
	public class ConditionalFormatter : IFormatter
	{
		private static readonly Regex _complexConditionPattern = new Regex("^  (?:   ([&/]?)   ([<>=!]=?)   ([0-9.-]+)   )+   \\?", RegexOptions.Compiled | RegexOptions.IgnorePatternWhitespace, TimeSpan.FromMilliseconds(500.0));

		private char _splitChar = '|';

		[Obsolete("Use property \"Name\" instead", true)]
		public string[] Names { get; set; } = new string[3]
		{
			"conditional",
			"cond",
			string.Empty
		};


		public string Name { get; set; } = "cond";


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


		public char SplitChar
		{
			get
			{
				return _splitChar;
			}
			set
			{
				_splitChar = Validation.GetValidSplitCharOrThrow(value);
			}
		}

		public bool TryEvaluateFormat(IFormattingInfo formattingInfo)
		{
			Format format = formattingInfo.Format;
			object currentValue = formattingInfo.CurrentValue;
			IList<Format> list2;
			if (format == null)
			{
				IList<Format> list = new List<Format>(0);
				list2 = list;
			}
			else
			{
				list2 = format.Split(SplitChar);
			}
			IList<Format> list3 = list2;
			if (format == null || list3.Count == 1)
			{
				if (string.IsNullOrEmpty(formattingInfo.Placeholder?.FormatterName))
				{
					return fa

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

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

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

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Cysharp.Text
{
	internal static class EnumUtil<T>
	{
		private const string InvalidName = "$";

		private static readonly Dictionary<T, string> names;

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

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

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

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

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

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

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

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

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

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

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

			public readonly ReadOnlySpan<char> FormatString;

			public readonly int LastIndex;

			public readonly int Alignment;

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

		internal const int ArgLengthLimit = 16;

		internal const int WidthLimit = 1000;

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

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

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

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

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

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

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

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

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) where TBufferWriter : IBufferWriter<byte>
		{
			Span<by

GTFO

AutogenRundown

Details

Categories

AmorLib.dll

GTFO-API.dll

Inas07.LocalProgression.dll

Newtonsoft.Json.dll

SmartFormat.dll

ZString.dll