using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;
using APIManager;
using AzuEPI;
using AzuEPI.Core.Input;
using AzuEPI.Core.InventoryHandlers;
using AzuEPI.Core.Slots;
using AzuEPI.Core.Text;
using AzuEPI.Core.Utilities.Extensions;
using AzuEPI.EPI;
using AzuEPI.Game.Compatibility;
using AzuEPI.Game.Compatibility.AdvBackpacks;
using AzuEPI.Game.Loadout;
using AzuEPI.Game.Panels;
using AzuEPI.Game.Panels.Stats;
using AzuEPI.Game.Panels.Vanity;
using AzuEPI.Game.Patches;
using AzuEPI.Game.PlayerPreview;
using AzuEPI.Game.Slots;
using AzuEPI.Game.Slots.QAB;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Preloader;
using BepInEx.Preloader.Patching;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AzuExtendedPlayerInventory")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyProduct("AzuExtendedPlayerInventory")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("2.4.2")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.4.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		public ExtensionMarkerAttribute(string name)
		{
		}
	}
}
public static class ToggleExtensions
{
	[SpecialName]
	public sealed class <G>$4F220943ABCF1C1726BA9F32F1C84BFA
	{
		[SpecialName]
		public static class <M>$B886148B8B9A8A91C986883EF65534E9
		{
		}

		[ExtensionMarker("<M>$B886148B8B9A8A91C986883EF65534E9")]
		public bool isOn()
		{
			throw null;
		}

		[ExtensionMarker("<M>$B886148B8B9A8A91C986883EF65534E9")]
		public bool isOff()
		{
			throw null;
		}
	}

	public static bool isOn(this AzuExtendedPlayerInventoryPlugin.Toggle toggle)
	{
		return toggle == AzuExtendedPlayerInventoryPlugin.Toggle.On;
	}

	public static bool isOff(this AzuExtendedPlayerInventoryPlugin.Toggle toggle)
	{
		return toggle == AzuExtendedPlayerInventoryPlugin.Toggle.Off;
	}
}
namespace AzuExtendedPlayerInventory
{
	[PublicAPI]
	public class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		private static readonly Dictionary<SlotAddedHandler, AzuEPI.API.SlotAddedHandler> _slotAddedMap = new Dictionary<SlotAddedHandler, AzuEPI.API.SlotAddedHandler>();

		private static readonly Dictionary<SlotRemovedHandler, AzuEPI.API.SlotRemovedHandler> _slotRemovedMap = new Dictionary<SlotRemovedHandler, AzuEPI.API.SlotRemovedHandler>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudAwakeMap = new Dictionary<Action<Hud>, Action<Hud>>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudAwakeCompleteMap = new Dictionary<Action<Hud>, Action<Hud>>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudUpdateMap = new Dictionary<Action<Hud>, Action<Hud>>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudUpdateCompleteMap = new Dictionary<Action<Hud>, Action<Hud>>();

		public static event SlotAddedHandler? SlotAdded
		{
			add
			{
				if (value == null || _slotAddedMap.ContainsKey(value))
				{
					return;
				}
				AzuEPI.API.SlotAddedHandler value2 = delegate(string s)
				{
					try
					{
						value(s);
					}
					catch
					{
					}
				};
				_slotAddedMap[value] = value2;
				AzuEPI.API.SlotAdded += value2;
			}
			remove
			{
				if (value != null && _slotAddedMap.TryGetValue(value, out AzuEPI.API.SlotAddedHandler value2))
				{
					AzuEPI.API.SlotAdded -= value2;
					_slotAddedMap.Remove(value);
				}
			}
		}

		public static event SlotRemovedHandler? SlotRemoved
		{
			add
			{
				if (value == null || _slotRemovedMap.ContainsKey(value))
				{
					return;
				}
				AzuEPI.API.SlotRemovedHandler value2 = delegate(string s)
				{
					try
					{
						value(s);
					}
					catch
					{
					}
				};
				_slotRemovedMap[value] = value2;
				AzuEPI.API.SlotRemoved += value2;
			}
			remove
			{
				if (value != null && _slotRemovedMap.TryGetValue(value, out AzuEPI.API.SlotRemovedHandler value2))
				{
					AzuEPI.API.SlotRemoved -= value2;
					_slotRemovedMap.Remove(value);
				}
			}
		}

		public static event Action<Hud>? OnHudAwake
		{
			add
			{
				AddHudEvent(value, _hudAwakeMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwake += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudAwakeMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwake -= h;
				});
			}
		}

		public static event Action<Hud>? OnHudAwakeComplete
		{
			add
			{
				AddHudEvent(value, _hudAwakeCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwakeComplete += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudAwakeCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwakeComplete -= h;
				});
			}
		}

		public static event Action<Hud>? OnHudUpdate
		{
			add
			{
				AddHudEvent(value, _hudUpdateMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdate += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudUpdateMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdate -= h;
				});
			}
		}

		public static event Action<Hud>? OnHudUpdateComplete
		{
			add
			{
				AddHudEvent(value, _hudUpdateCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdateComplete += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudUpdateCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdateComplete -= h;
				});
			}
		}

		private static void AddHudEvent(Action<Hud>? handler, Dictionary<Action<Hud>, Action<Hud>> map, Action<Action<Hud>> subscribe)
		{
			if (handler == null || map.ContainsKey(handler))
			{
				return;
			}
			Action<Hud> action = delegate(Hud h)
			{
				try
				{
					handler(h);
				}
				catch
				{
				}
			};
			map[handler] = action;
			subscribe(action);
		}

		private static void RemoveHudEvent(Action<Hud>? handler, Dictionary<Action<Hud>, Action<Hud>> map, Action<Action<Hud>> unsubscribe)
		{
			if (handler != null && map.TryGetValue(handler, out Action<Hud> value))
			{
				unsubscribe(value);
				map.Remove(handler);
			}
		}

		public static bool IsLoaded()
		{
			return AzuEPI.API.IsLoaded();
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			if (Localization.m_instance == null || Localization.m_instance.Localize(slotName).Contains("["))
			{
				Localizer.OnLocalizationComplete += delegate
				{
					AzuEPI.API.AddSlot(slotName, getItem, isValid, index);
				};
			}
			else
			{
				AzuEPI.API.AddSlot(slotName, getItem, isValid, index);
			}
			return true;
		}

		public static bool RemoveSlot(string slotName)
		{
			return AzuEPI.API.RemoveSlot(slotName);
		}

		public static SlotInfo GetSlots()
		{
			AzuEPI.SlotInfo slots = AzuEPI.API.GetSlots();
			return new SlotInfo
			{
				SlotNames = (slots.SlotNames ?? Array.Empty<string>()),
				SlotPositions = (slots.SlotPositions ?? Array.Empty<Vector2>()),
				GetItemFuncs = (slots.GetItemFuncs ?? Array.Empty<Func<Player, ItemData>>()),
				IsValidFuncs = (slots.IsValidFuncs ?? Array.Empty<Func<ItemData, bool>>())
			};
		}

		public static SlotInfo GetQuickSlots()
		{
			AzuEPI.SlotInfo quickSlots = AzuEPI.API.GetQuickSlots();
			return new SlotInfo
			{
				SlotNames = (quickSlots.SlotNames ?? Array.Empty<string>()),
				SlotPositions = (quickSlots.SlotPositions ?? Array.Empty<Vector2>()),
				GetItemFuncs = (quickSlots.GetItemFuncs ?? Array.Empty<Func<Player, ItemData>>()),
				IsValidFuncs = (quickSlots.IsValidFuncs ?? Array.Empty<Func<ItemData, bool>>())
			};
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return AzuEPI.API.GetQuickSlotsItems();
		}

		public static int GetAddedRows(int width)
		{
			return AzuEPI.API.GetAddedRows(width);
		}

		public static void HudAwake(Hud h)
		{
			SafeInvoke(delegate
			{
				AzuEPI.API.HudAwake(h);
			});
		}

		public static void HudAwakeComplete(Hud h)
		{
			SafeInvoke(delegate
			{
				AzuEPI.API.HudAwakeComplete(h);
			});
		}

		public static void HudUpdate(Hud h)
		{
			SafeInvoke(delegate
			{
				AzuEPI.API.HudUpdate(h);
			});
		}

		public static void HudUpdateComplete(Hud h)
		{
			SafeInvoke(delegate
			{
				AzuEPI.API.HudUpdateComplete(h);
			});
		}

		private static void SafeInvoke(Action a)
		{
			try
			{
				a();
			}
			catch
			{
			}
		}
	}
	[PublicAPI]
	public class SlotInfo
	{
		public string[] SlotNames { get; set; } = Array.Empty<string>();

		public Vector2[] SlotPositions { get; set; } = Array.Empty<Vector2>();

		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = Array.Empty<Func<Player, ItemData>>();

		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = Array.Empty<Func<ItemData, bool>>();
	}
}
namespace APIManager
{
	public static class Patcher
	{
		private class MonoAssemblyResolver : IAssemblyResolver, IDisposable
		{
			public AssemblyDefinition Resolve(AssemblyNameReference name)
			{
				return AssemblyDefinition.ReadAssembly(AppDomain.CurrentDomain.Load(name.FullName).Location);
			}

			public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
			{
				return Resolve(name);
			}

			public void Dispose()
			{
			}
		}

		private class AssemblyLoadInterceptor
		{
			private static string? assemblyPath;

			private static MethodInfo TargetMethod()
			{
				return AccessTools.DeclaredMethod(typeof(Assembly), "Load", new Type[1] { typeof(byte[]) }, (Type[])null);
			}

			private static bool Prefix(ref byte[] __0, ref Assembly? __result)
			{
				//IL_001d: 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_0032: Expected O, but got Unknown
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Expected O, but got Unknown
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Expected O, but got Unknown
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Expected O, but got Unknown
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Expected O, but got Unknown
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0207: Expected O, but got Unknown
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0260: Unknown result type (might be due to invalid IL or missing references)
				assemblyPath = null;
				if (modifyNextLoad)
				{
					modifyNextLoad = false;
					try
					{
						AssemblyDefinition val = AssemblyDefinition.ReadAssembly((Stream)new MemoryStream(__0), new ReaderParameters
						{
							AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
						});
						try
						{
							((Dictionary<string, string>)typeof(EnvVars).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.UnityPatches").GetProperty("AssemblyLocations").GetValue(null))[val.FullName] = currentAssemblyPath;
							FixupModuleReferences(val.MainModule);
							TypeDefinition val2 = val.MainModule.GetType("APIManager", "PatchedAttribute");
							if (val2 == null)
							{
								val2 = new TypeDefinition("APIManager", "PatchedAttribute", (TypeAttributes)3)
								{
									BaseType = val.MainModule.ImportReference(typeof(Attribute))
								};
								MethodDefinition val3 = new MethodDefinition(".ctor", (MethodAttributes)6278, val.MainModule.TypeSystem.Void);
								((MethodReference)val3).Parameters.Add(new ParameterDefinition(val.MainModule.TypeSystem.String));
								((MethodReference)val3).Parameters.Add(new ParameterDefinition(val.MainModule.TypeSystem.String));
								val3.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
								val2.Methods.Add(val3);
								val.MainModule.Types.Add(val2);
								CustomAttribute val4 = new CustomAttribute((MethodReference)(object)val3);
								val4.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)""));
								val4.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)val.MainModule.Mvid.ToString()));
								val.CustomAttributes.Add(val4);
							}
							CustomAttribute val5 = new CustomAttribute((MethodReference)(object)((IEnumerable<MethodDefinition>)val2.Methods).First((MethodDefinition m) => ((MemberReference)m).Name == ".ctor"));
							val5.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)modGUID));
							val5.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)patchingAssembly.ManifestModule.ModuleVersionId.ToString()));
							val.CustomAttributes.Add(val5);
							using MemoryStream memoryStream = new MemoryStream();
							val.Write((Stream)memoryStream);
							__0 = memoryStream.ToArray();
							string dumpedAssembliesPath = Patcher.dumpedAssembliesPath;
							char directorySeparatorChar = Path.DirectorySeparatorChar;
							string path = dumpedAssembliesPath + directorySeparatorChar + ((AssemblyNameReference)val.Name).Name + ".dll";
							Directory.CreateDirectory(Patcher.dumpedAssembliesPath);
							File.WriteAllBytes(path, __0);
							assemblyPath = path;
							__result = null;
							return false;
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					catch (BadImageFormatException)
					{
					}
					catch (Exception ex2)
					{
						Debug.LogError((object)("Failed patching ... " + ex2));
					}
				}
				return true;
			}

			private static void Postfix(ref Assembly? __result)
			{
				if (assemblyPath != null && __result == null)
				{
					__result = Assembly.LoadFrom(assemblyPath);
					assemblyPath = null;
				}
			}
		}

		private static PluginInfo? lastPluginInfo;

		private static bool modifyNextLoad = false;

		private static string modGUID = null;

		private static HashSet<string> redirectedNamespaces = null;

		private static readonly Assembly patchingAssembly = Assembly.GetExecutingAssembly();

		private static string currentAssemblyPath = null;

		private static readonly string dumpedAssembliesPath = (string)AccessTools.DeclaredField(typeof(AssemblyPatcher), "DumpedAssembliesPath").GetValue(null);

		private static void GrabPluginInfo(PluginInfo __instance)
		{
			lastPluginInfo = __instance;
		}

		[HarmonyPriority(700)]
		private static void CheckAssemblyLoadFile(string __0)
		{
			PluginInfo? obj = lastPluginInfo;
			if (__0 == ((obj != null) ? obj.Location : null) && lastPluginInfo.Dependencies.Any((BepInDependency d) => d.DependencyGUID == modGUID))
			{
				modifyNextLoad = true;
				currentAssemblyPath = __0;
			}
			lastPluginInfo = null;
		}

		[HarmonyPriority(500)]
		private static bool InterceptAssemblyLoadFile(string __0, ref Assembly? __result)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (modifyNextLoad && (object)__result == null)
			{
				string text = dumpedAssembliesPath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				string text2 = text + directorySeparatorChar + Path.GetFileName(__0);
				if (File.Exists(text2))
				{
					AssemblyDefinition val = AssemblyDefinition.ReadAssembly(text2, new ReaderParameters
					{
						AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
					});
					try
					{
						bool flag = false;
						Enumerator<CustomAttribute> enumerator = val.CustomAttributes.GetEnumerator();
						try
						{
							while (enumerator.MoveNext())
							{
								CustomAttribute current = enumerator.Current;
								TypeReference declaringType = ((MemberReference)current.Constructor).DeclaringType;
								if (declaringType.Namespace == "APIManager" && ((MemberReference)declaringType).Name == "PatchedAttribute")
								{
									CustomAttributeArgument val2 = current.ConstructorArguments[0];
									if ((string)((CustomAttributeArgument)(ref val2)).Value == modGUID)
									{
										val2 = current.ConstructorArguments[1];
										flag = (string)((CustomAttributeArgument)(ref val2)).Value == patchingAssembly.ManifestModule.ModuleVersionId.ToString();
										break;
									}
								}
							}
						}
						finally
						{
							((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
						}
						if (flag)
						{
							return true;
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				__result = Assembly.Load(File.ReadAllBytes(__0));
				return false;
			}
			return true;
		}

		[HarmonyPriority(499)]
		private static bool ReplaceAssemblyLoadWithCache(ref string __0, ref Assembly? __result)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_00d2: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			if (modifyNextLoad && (object)__result == null && !__0.StartsWith(dumpedAssembliesPath))
			{
				string text = dumpedAssembliesPath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				string text2 = text + directorySeparatorChar + Path.GetFileName(__0);
				AssemblyDefinition val = AssemblyDefinition.ReadAssembly(text2, new ReaderParameters
				{
					AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
				});
				AssemblyDefinition val2 = AssemblyDefinition.ReadAssembly(__0, new ReaderParameters
				{
					AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
				});
				Enumerator<CustomAttribute> enumerator = val.CustomAttributes.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						CustomAttribute current = enumerator.Current;
						TypeReference declaringType = ((MemberReference)current.Constructor).DeclaringType;
						if (declaringType.Namespace == "APIManager" && ((MemberReference)declaringType).Name == "PatchedAttribute")
						{
							CustomAttributeArgument val3 = current.ConstructorArguments[0];
							string text3 = (string)((CustomAttributeArgument)(ref val3)).Value;
							bool num;
							if (!(text3 == ""))
							{
								num = !Chainloader.PluginInfos.ContainsKey(text3);
							}
							else
							{
								val3 = current.ConstructorArguments[1];
								num = (string)((CustomAttributeArgument)(ref val3)).Value != val2.MainModule.Mvid.ToString();
							}
							if (num)
							{
								val2.Dispose();
								val.Dispose();
								__result = Assembly.Load(File.ReadAllBytes(__0));
								return false;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				((Dictionary<string, string>)typeof(EnvVars).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.UnityPatches").GetProperty("AssemblyLocations").GetValue(null))[val.FullName] = __0;
				val2.Dispose();
				val.Dispose();
				__0 = text2;
			}
			modifyNextLoad = false;
			return true;
		}

		private static void FixupModuleReferences(ModuleDefinition module)
		{
			foreach (TypeDefinition type3 in module.GetTypes())
			{
				if ((object)patchingAssembly.GetType(((MemberReference)type3).FullName) == null)
				{
					Dispatch(type3);
				}
			}
			static bool AreSame(TypeReference a, TypeReference b)
			{
				return (bool)typeof(MetadataResolver).Assembly.GetType("Mono.Cecil.MetadataResolver").GetMethod("AreSame", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(TypeReference),
					typeof(TypeReference)
				}, null).Invoke(null, new object[2] { a, b });
			}
			void Dispatch(TypeDefinition type)
			{
				if (type.BaseType != null && (object)type.BaseType.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(type.BaseType).Namespace))
				{
					Type type2 = patchingAssembly.GetType(((MemberReference)type.BaseType).FullName);
					if ((object)type2 != null)
					{
						type.BaseType = module.ImportReference(type2);
					}
				}
				DispatchGenericParameters((IGenericParameterProvider)(object)type, ((MemberReference)type).FullName);
				DispatchInterfaces(type, ((MemberReference)type).FullName);
				DispatchAttributes((ICustomAttributeProvider)(object)type, ((MemberReference)type).FullName);
				DispatchFields(type, ((MemberReference)type).FullName);
				DispatchProperties(type, ((MemberReference)type).FullName);
				DispatchEvents(type, ((MemberReference)type).FullName);
				DispatchMethods(type);
			}
			void DispatchAttributes(ICustomAttributeProvider provider, string referencingEntityName)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: 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_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				if (!provider.HasCustomAttributes)
				{
					return;
				}
				Enumerator<CustomAttribute> enumerator2 = provider.CustomAttributes.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						CustomAttribute current2 = enumerator2.Current;
						MethodReference val = importMethodReference(current2.Constructor);
						if (val != null)
						{
							current2.Constructor = val;
						}
						else
						{
							VisitMethod(current2.Constructor, referencingEntityName);
						}
						for (int i = 0; i < current2.ConstructorArguments.Count; i++)
						{
							CustomAttributeArgument val2 = current2.ConstructorArguments[i];
							current2.ConstructorArguments[i] = new CustomAttributeArgument(VisitType(((CustomAttributeArgument)(ref val2)).Type, referencingEntityName), ((CustomAttributeArgument)(ref val2)).Value);
						}
						CustomAttributeArgument argument;
						for (int j = 0; j < current2.Properties.Count; j++)
						{
							CustomAttributeNamedArgument val3 = current2.Properties[j];
							Collection<CustomAttributeNamedArgument> properties = current2.Properties;
							int num = j;
							string name = ((CustomAttributeNamedArgument)(ref val3)).Name;
							argument = ((CustomAttributeNamedArgument)(ref val3)).Argument;
							TypeReference? obj = VisitType(((CustomAttributeArgument)(ref argument)).Type, referencingEntityName);
							argument = ((CustomAttributeNamedArgument)(ref val3)).Argument;
							properties[num] = new CustomAttributeNamedArgument(name, new CustomAttributeArgument(obj, ((CustomAttributeArgument)(ref argument)).Value));
						}
						for (int k = 0; k < current2.Fields.Count; k++)
						{
							CustomAttributeNamedArgument val4 = current2.Fields[k];
							Collection<CustomAttributeNamedArgument> fields = current2.Fields;
							int num2 = k;
							string name2 = ((CustomAttributeNamedArgument)(ref val4)).Name;
							argument = ((CustomAttributeNamedArgument)(ref val4)).Argument;
							TypeReference? obj2 = VisitType(((CustomAttributeArgument)(ref argument)).Type, referencingEntityName);
							argument = ((CustomAttributeNamedArgument)(ref val4)).Argument;
							fields[num2] = new CustomAttributeNamedArgument(name2, new CustomAttributeArgument(obj2, ((CustomAttributeArgument)(ref argument)).Value));
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchEvents(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<EventDefinition> enumerator2 = type.Events.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						EventDefinition current2 = enumerator2.Current;
						((EventReference)current2).EventType = VisitType(((EventReference)current2).EventType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchFields(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<FieldDefinition> enumerator2 = type.Fields.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						FieldDefinition current2 = enumerator2.Current;
						((FieldReference)current2).FieldType = VisitType(((FieldReference)current2).FieldType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchGenericArguments(IGenericInstance genericInstance, string referencingEntityName)
			{
				for (int i = 0; i < genericInstance.GenericArguments.Count; i++)
				{
					genericInstance.GenericArguments[i] = VisitType(genericInstance.GenericArguments[i], referencingEntityName);
				}
			}
			void DispatchGenericParameters(IGenericParameterProvider provider, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<GenericParameter> enumerator2 = provider.GenericParameters.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						GenericParameter current2 = enumerator2.Current;
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
						for (int i = 0; i < current2.Constraints.Count; i++)
						{
							current2.Constraints[i] = VisitType(current2.Constraints[i], referencingEntityName);
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchInterfaces(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<InterfaceImplementation> enumerator2 = type.Interfaces.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						InterfaceImplementation current2 = enumerator2.Current;
						current2.InterfaceType = VisitType(current2.InterfaceType, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchMethod(MethodDefinition method)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				((MethodReference)method).ReturnType = VisitType(((MethodReference)method).ReturnType, ((MemberReference)method).FullName);
				DispatchAttributes((ICustomAttributeProvider)(object)((MethodReference)method).MethodReturnType, ((MemberReference)method).FullName);
				DispatchGenericParameters((IGenericParameterProvider)(object)method, ((MemberReference)method).FullName);
				Enumerator<ParameterDefinition> enumerator2 = ((MethodReference)method).Parameters.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						ParameterDefinition current2 = enumerator2.Current;
						((ParameterReference)current2).ParameterType = VisitType(((ParameterReference)current2).ParameterType, ((MemberReference)method).FullName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, ((MemberReference)method).FullName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
				for (int i = 0; i < method.Overrides.Count; i++)
				{
					MethodReference val = importMethodReference(method.Overrides[i]);
					if (val != null)
					{
						method.Overrides[i] = val;
					}
					else
					{
						VisitMethod(method.Overrides[i], ((MemberReference)method).FullName);
					}
				}
				if (method.HasBody)
				{
					DispatchMethodBody(method.Body);
				}
			}
			void DispatchMethodBody(MethodBody body)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<VariableDefinition> enumerator2 = body.Variables.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						VariableDefinition current2 = enumerator2.Current;
						((VariableReference)current2).VariableType = VisitType(((VariableReference)current2).VariableType, ((MemberReference)body.Method).FullName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
				Enumerator<Instruction> enumerator3 = body.Instructions.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						Instruction current3 = enumerator3.Current;
						object operand = current3.Operand;
						FieldReference val = (FieldReference)((operand is FieldReference) ? operand : null);
						if (val == null)
						{
							MethodReference val2 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val2 == null)
							{
								TypeReference val3 = (TypeReference)((operand is TypeReference) ? operand : null);
								if (val3 != null)
								{
									current3.Operand = VisitType(val3, ((MemberReference)body.Method).FullName);
								}
							}
							else
							{
								MethodReference val4 = importMethodReference(val2);
								if (val4 != null)
								{
									current3.Operand = val4;
								}
								else
								{
									VisitMethod(val2, ((MemberReference)body.Method).FullName);
								}
							}
						}
						else
						{
							FieldReference val5 = importFieldReference(val);
							if (val5 != null)
							{
								current3.Operand = val5;
							}
							else
							{
								VisitField(val, ((MemberReference)body.Method).FullName);
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchMethods(TypeDefinition type)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<MethodDefinition> enumerator2 = type.Methods.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						MethodDefinition current2 = enumerator2.Current;
						DispatchMethod(current2);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchProperties(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<PropertyDefinition> enumerator2 = type.Properties.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						PropertyDefinition current2 = enumerator2.Current;
						((PropertyReference)current2).PropertyType = VisitType(((PropertyReference)current2).PropertyType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			TypeReference FixupType(TypeReference type)
			{
				if ((object)type.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(type).Namespace))
				{
					if (type.IsNested)
					{
						return FixupType(((MemberReference)type).DeclaringType);
					}
					Type type2 = patchingAssembly.GetType(((MemberReference)type).FullName);
					if ((object)type2 != null)
					{
						return module.ImportReference(type2);
					}
				}
				return type;
			}
			void VisitField(FieldReference? field, string referencingEntityName)
			{
				if (field != null)
				{
					field.FieldType = VisitType(field.FieldType, referencingEntityName);
					if (!(field is FieldDefinition))
					{
						((MemberReference)field).DeclaringType = VisitType(((MemberReference)field).DeclaringType, referencingEntityName);
					}
				}
			}
			void VisitMethod(MethodReference? method, string referencingEntityName)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (method != null)
				{
					GenericInstanceMethod val = (GenericInstanceMethod)(object)((method is GenericInstanceMethod) ? method : null);
					if (val != null)
					{
						DispatchGenericArguments((IGenericInstance)(object)val, referencingEntityName);
					}
					method.ReturnType = VisitType(method.ReturnType, referencingEntityName);
					Enumerator<ParameterDefinition> enumerator2 = method.Parameters.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							ParameterDefinition current2 = enumerator2.Current;
							((ParameterReference)current2).ParameterType = VisitType(((ParameterReference)current2).ParameterType, referencingEntityName);
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
					if (!(method is MethodSpecification))
					{
						((MemberReference)method).DeclaringType = VisitType(((MemberReference)method).DeclaringType, referencingEntityName);
					}
				}
			}
			TypeReference? VisitType(TypeReference? type, string referencingEntityName)
			{
				if (type == null)
				{
					return type;
				}
				if (type.GetElementType().IsGenericParameter)
				{
					return type;
				}
				GenericInstanceType val = (GenericInstanceType)(object)((type is GenericInstanceType) ? type : null);
				if (val != null)
				{
					DispatchGenericArguments((IGenericInstance)(object)val, referencingEntityName);
				}
				return FixupType(type);
			}
			static TypeReference baseDeclaringType(TypeReference type)
			{
				while (((MemberReference)type).DeclaringType != null)
				{
					type = ((MemberReference)type).DeclaringType;
				}
				return type;
			}
			FieldReference? importFieldReference(FieldReference field)
			{
				if ((object)((MemberReference)field).DeclaringType.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(((MemberReference)field).DeclaringType).Namespace))
				{
					FieldInfo fieldInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)field).DeclaringType).FullName)?.GetField(((MemberReference)field).Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if ((object)fieldInfo != null)
					{
						return module.ImportReference(fieldInfo);
					}
				}
				return null;
			}
			MethodReference? importMethodReference(MethodReference method)
			{
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Expected O, but got Unknown
				if ((object)((MemberReference)method).DeclaringType.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(((MemberReference)method).DeclaringType).Namespace))
				{
					if (((MemberReference)method).Name == ".cctor")
					{
						ConstructorInfo[] array = patchingAssembly.GetType(((MemberReference)((MemberReference)method).DeclaringType).FullName)?.GetConstructors(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						if (array != null && array.Length == 1)
						{
							return module.ImportReference((MethodBase)array[0]);
						}
					}
					else if (((MemberReference)method).Name == ".ctor")
					{
						ConstructorInfo constructorInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)method).DeclaringType).FullName)?.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(CompareMethods);
						if ((object)constructorInfo != null)
						{
							return module.ImportReference((MethodBase)constructorInfo);
						}
					}
					else
					{
						MethodInfo methodInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)method).DeclaringType).FullName)?.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo m)
						{
							if (m.Name != ((MemberReference)method).Name)
							{
								return false;
							}
							return (((MemberReference)method.ReturnType).ContainsGenericParameter == m.ReturnType.IsGenericParameter || AreSame(method.ReturnType, module.ImportReference(m.ReturnType))) && CompareMethods(m);
						});
						if ((object)methodInfo != null)
						{
							MethodReference val = module.ImportReference((MethodBase)methodInfo);
							MethodReference obj = method;
							GenericInstanceMethod val2 = (GenericInstanceMethod)(object)((obj is GenericInstanceMethod) ? obj : null);
							if (val2 != null)
							{
								GenericInstanceMethod val3 = new GenericInstanceMethod(val);
								for (int num = 0; num < val2.GenericArguments.Count; num++)
								{
									val2.GenericArguments[num] = VisitType(val2.GenericArguments[num], ((MemberReference)method).FullName);
									val3.GenericArguments.Add(val2.GenericArguments[num]);
								}
								val = (MethodReference)(object)val3;
							}
							return val;
						}
					}
				}
				return null;
				bool CompareMethods(MethodBase m)
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (method.IsGenericInstance != m.IsGenericMethodDefinition || parameters.Length != 0 != method.HasParameters)
					{
						return false;
					}
					if (method.HasParameters)
					{
						if (method.Parameters.Count != parameters.Length)
						{
							return false;
						}
						for (int i = 0; i < method.Parameters.Count; i++)
						{
							if (parameters[i].ParameterType.IsGenericParameter ? (!((ParameterReference)method.Parameters[i]).ParameterType.IsGenericParameter) : (!AreSame(((ParameterReference)method.Parameters[i]).ParameterType, module.ImportReference(parameters[i].ParameterType))))
							{
								return false;
							}
						}
					}
					return true;
				}
			}
		}

		public static bool PreventHarmonyInteropFixLoad(Assembly? __0)
		{
			return __0 == null;
		}

		public static void Patch(IEnumerable<string>? extraNamespaces = null)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			Harmony val = new Harmony("org.bepinex.plugins.APIManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PluginInfo), "ToString", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "GrabPluginInfo", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "InterceptAssemblyLoadFile", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "CheckAssemblyLoadFile", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "ReplaceAssemblyLoadWithCache", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			new PatchClassProcessor(val, typeof(AssemblyLoadInterceptor), true).Patch();
			Type type = typeof(AssemblyPatcher).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.HarmonyInteropFix");
			if ((object)type != null)
			{
				val.Patch((MethodBase)AccessTools.DeclaredMethod(type, "OnAssemblyLoad", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "PreventHarmonyInteropFixLoad", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			IEnumerable<TypeInfo> source;
			try
			{
				source = patchingAssembly.DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			BaseUnityPlugin val2 = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in extraNamespaces ?? Array.Empty<string>())
			{
				hashSet.Add(item);
			}
			hashSet.Add(((object)val2).GetType().Namespace);
			redirectedNamespaces = hashSet;
			modGUID = val2.Info.Metadata.GUID;
		}
	}
}
namespace LocalizationManager
{
	[PublicAPI]
	public class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

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

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

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

		private static BaseUnityPlugin? _plugin;

		private static readonly List<string> fileExtensions;

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

		public static event Action? OnLocalizationComplete;

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

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

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

		public static void Load()
		{
			_ = plugin;
		}

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

		public static void SafeCallLocalizeComplete()
		{
			Localizer.OnLocalizationComplete?.Invoke();
		}

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

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

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

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace ItemDataManager
{
	[PublicAPI]
	public abstract class ItemData
	{
		internal static WeakReference<ItemInfo> constructingInfo = null;

		internal WeakReference<ItemInfo>? info;

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

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

		public string CustomDataKey { get; internal set; }

		protected virtual bool AllowStackingIdenticalValues { get; set; }

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

		public string Key { get; internal set; }

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

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

		public ItemData Item => Info.ItemData;

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

		public virtual void FirstLoad()
		{
		}

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

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

		public virtual void Unload()
		{
		}

		public virtual void Upgraded()
		{
		}

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

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

		internal static string? _modGuid;

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

		private static HashSet<string> knownTypes;

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

		private WeakReference<ItemInfo>? selfReference;

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

		private static ItemData? awakeningItem;

		private static Assembly primaryAssembly;

		private static Dictionary<Assembly, string> assemblyNameCache;

		private static Dictionary<Type, string> classKeyCache;

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

		private static MethodInfo removeMethod;

		private static ItemData? checkingForStackableItemData;

		private static Dictionary<string, string>? newValuesOnStackable;

		private static ItemData? currentlyUpgradingItem;

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

		public string Mod => modGuid;

		public ItemData ItemData { get; private set; }

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

		internal static void addTypeToInheritorsCache(Type type, string typeKey)
		{
			if (!knownTypes.Contains(typeKey))
			{
				knownTypes.Add(typeKey);
				Type type2 = type;
				while ((object)type2 != null)
				{
					AddInterfaces(type2);
					type2 = type2.BaseType;
				}
			}
			void AddInterfaces(Type baseType)
			{
				if (!typeInheritorsCache.TryGetValue(baseType, out HashSet<Type> value))
				{
					HashSet<Type> hashSet = (typeInheritorsCache[baseType] = new HashSet<Type>());
					value = hashSet;
				}
				value.Add(type);
				Type[] interfaces = baseType.GetInterfaces();
				for (int i = 0; i < interfaces.Length; i++)
				{
					AddInterfaces(interfaces[i]);
				}
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static IEnumerable<CodeInstruction> CheckStackableInFindFreeStackMethods(IEnumerable<CodeInstruction> instructionsEnumerable)
		{
			CodeInstruction[] instructions = instructionsEnumerable.ToArray();
			Label target = (Label)instructions.First((CodeInstruction val) => val.opcode == OpCodes.Br || val.opcode == OpCodes.Br_S).operand;
			CodeInstruction targetedInstr = instructions.First((CodeInstruction val) => val.labels.Contains(target));
			Label? label = default(Label?);
			CodeInstruction lastBranch = instructions.Reverse().First((CodeInstruction val) => CodeInstructionExtensions.Branches(val, ref label) && targetedInstr.labels.Contains(label.Value));
			CodeInstruction loadingInstruction = null;
			int i = 0;
			while (i < instructions.Length)
			{
				yield return instructions[i];
				if (loadingInstruction == null && instructions[i].opcode == OpCodes.Call && ((MethodInfo)instructions[i].operand).Name == "get_Current")
				{
					loadingInstruction = instructions[i + 1].Clone();
					loadingInstruction.opcode = new Dictionary<OpCode, OpCode>
					{
						{
							OpCodes.Stloc_0,
							OpCodes.Ldloc_0
						},
						{
							OpCodes.Stloc_1,
							OpCodes.Ldloc_1
						},
						{
							OpCodes.Stloc_2,
							OpCodes.Ldloc_2
						},
						{
							OpCodes.Stloc_3,
							OpCodes.Ldloc_3
						},
						{
							OpCodes.Stloc_S,
							OpCodes.Ldloc_S
						}
					}[loadingInstruction.opcode];
				}
				if (instructions[i] == lastBranch)
				{
					yield return loadingInstruction;
					yield return new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "checkingForStackableItemData"));
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataIsStackableFindFree", (Type[])null, (Type[])null));
					yield return new CodeInstruction(OpCodes.Brfalse, (object)target);
				}
				int num = i + 1;
				i = num;
			}
		}

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

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

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

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

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

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

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

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

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

		private static IEnumerable<CodeInstruction> TransferCustomItemDataOnUpgrade(IEnumerable<CodeInstruction> instructions, ILGenerator ilg)
		{
			MethodInfo itemDeleter = AccessTools.DeclaredMethod(typeof(Inventory), "RemoveItem", new Type[1] { typeof(ItemData) }, (Type[])null);
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(instruction, (MemberInfo)itemDeleter))
				{
					yield return new CodeInstruction(OpCodes.Dup, (object)null);
					yield return new CodeInstruction(OpCodes.Stsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "currentlyUpgradingItem"));
				}
				yield return instruction;
			}
		}

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

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

		private static IEnumerable<CodeInstruction> ImportCustomDataOnUpgrade(IEnumerable<CodeInstruction> instructionList)
		{
			List<CodeInstruction> list = instructionList.ToList();
			foreach (CodeInstruction instruction in list)
			{
				yield return instruction;
				if (instruction.opcode == OpCodes.Stfld && CodeInstructionExtensions.OperandIs(instruction, (MemberInfo)AccessTools.DeclaredField(typeof(ItemData), "m_dropPrefab")))
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CopyCustomDataFromUpgradedItem", (Type[])null, (Type[])null));
				}
			}
		}

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

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

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

		public ItemData ItemData { get; private set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[PublicAPI]
	public static class ItemExtensions
	{
		[SpecialName]
		public sealed class <G>$89A7D4A522B437A8B95320B2CAC6531E
		{
			[SpecialName]
			public static class <M>$091BBA0B72542A51B2CEA87B8CA8E7DC
			{
			}

			[ExtensionMarker("<M>$091BBA0B72542A51B2CEA87B8CA8E7DC")]
			public ItemInfo Data()
			{
				throw null;
			}

			[ExtensionMarker("<M>$091BBA0B72542A51B2CEA87B8CA8E7DC")]
			public ForeignItemInfo? Data(string mod)
			{
				throw null;
			}
		}

		private const string className = "ItemDataManager.ItemExtensions";

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

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

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

		public static ForeignItemInfo? Data(this ItemData item, string mod)
		{
			Dictionary<string, ForeignItemInfo> orCreateValue = ItemExtensions.foreignItemInfo.GetOrCreateValue(item);
			if (orCreateValue.TryGetValue(mod, out var value))
			{
				return value;
			}
			if (!Chainloader.PluginInfos.TryGetValue(mod, out var value2))
			{
				return null;
			}
			object obj = ((object)value2.Instance).GetType().Assembly.GetType("ItemDataManager.ItemExtensions")?.GetMethod("Data", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, Array.Empty<ParameterModifier>())?.Invoke(null, new object[1] { item });
			if (obj != null)
			{
				return orCreateValue[mod] = new ForeignItemInfo(item, obj);
			}
			Debug.LogWarning((object)("Mod " + mod + " has an ItemDataManager.ItemExtensions class, but no Data(ItemDrop.ItemData) method could be called on it."));
			return orCreateValue[mod] = null;
		}
	}
}
namespace AzuEPI
{
	[BepInPlugin("Azumatt.AzuExtendedPlayerInventory", "AzuExtendedPlayerInventory", "2.4.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("shudnal.ExtraSlots")]
	[BepInIncompatibility("shudnal.ExtraSlotsCustomSlots")]
	[BepInIncompatibility("aedenthorn.ExtendedPlayerInventory")]
	[BepInIncompatibility("com.bruce.valheim.comfyquickslots")]
	[BepInIncompatibility("randyknapp.mods.equipmentandquickslots")]
	[BepInIncompatibility("moreslots")]
	[BepInIncompatibility("randyknapp.mods.auga")]
	[BepInIncompatibility("toombe.EquipMultipleUtilityItemsUpdate")]
	[BepInIncompatibility("aedenthorn.EquipMultipleUtilityItems")]
	public class AzuExtendedPlayerInventoryPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;

			[UsedImplicitly]
			public int? Order;
		}

		private class AcceptableShortcuts : AcceptableValueBase
		{
			public AcceptableShortcuts()
				: base(typeof(KeyboardShortcut))
			{
			}

			public override object Clamp(object value)
			{
				return value;
			}

			public override bool IsValid(object value)
			{
				return true;
			}

			public override string ToDescriptionString()
			{
				return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
			}
		}

		internal const string ModName = "AzuExtendedPlayerInventory";

		internal const string ModVersion = "2.4.2";

		internal const string Author = "Azumatt";

		internal const string ModGUID = "Azumatt.AzuExtendedPlayerInventory";

		private static readonly string ConfigFileName;

		private static readonly string ConfigFileFullPath;

		internal static string ConnectionError;

		public static readonly ManualLogSource AzuExtendedPlayerInventoryLogger;

		private static readonly ConfigSync ConfigSync;

		internal static AzuExtendedPlayerInventoryPlugin context;

		internal static bool WbInstalled;

		internal readonly Harmony _harmony = new Harmony("Azumatt.AzuExtendedPlayerInventory");

		private FileSystemWatcher _cfgWatcher;

		private System.Timers.Timer _debounce;

		public static readonly int FakeType;

		private int _configOrder = 100;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		public static ConfigEntry<Toggle> AutoEquip;

		public static ConfigEntry<Toggle> WishboneSlot;

		public static ConfigEntry<Toggle> WispLightSlot;

		public static ConfigEntry<string> RemovedEquipmentSlots;

		public static ConfigEntry<string> UserAddedSlots;

		public static ConfigEntry<Toggle> EPISlotsAddArmor;

		public static ConfigEntry<Toggle> UtilityEPIAddArmor;

		public static ConfigEntry<Toggle> AddEquipmentRow;

		public static ConfigEntry<Toggle> DisplayEquipmentRowSeparate;

		public static ConfigEntry<int> QuickSlotsAmount;

		public static ConfigEntry<Toggle> ShowQuickSlots;

		public static ConfigEntry<Toggle> MakeDropAllButton;

		public static ConfigEntry<Vector2> DropAllButtonPosition;

		public static ConfigEntry<string> SelectedPlayerStats;

		public static ConfigEntry<string> SelectedLiveStats;

		public static ConfigEntry<int> ExtraRows;

		public static ConfigEntry<string> HelmetText;

		public static ConfigEntry<string> ChestText;

		public static ConfigEntry<string> LegsText;

		public static ConfigEntry<string> BackText;

		public static ConfigEntry<string> TrinketText;

		public static ConfigEntry<string> UtilityText;

		public static ConfigEntry<float> QuickAccessScale;

		public static ConfigEntry<KeyboardShortcut> QuickslotDragKeys;

		public static ConfigEntry<KeyboardShortcut> ModKeyTwo;

		public static ConfigEntry<KeyboardShortcut>[] Hotkeys;

		public static ConfigEntry<string>[] HotkeyTexts;

		public static ConfigEntry<Vector2> QuickAccessLocation;

		public static ConfigEntry<int> QuickSlotsPerRow;

		public static ConfigEntry<Toggle> AlwaysShowQuickSlotsInUI;

		public static ConfigEntry<Vector2> UIAnchor;

		public static ConfigEntry<Vector3> LocalScale;

		public static ConfigEntry<Toggle> VanityOption;

		public static ConfigEntry<Toggle> LoadoutOption;

		public static ConfigEntry<Toggle> OldLayout;

		public static ConfigEntry<KeyCode> VanityToggleGamepadKey;

		public static ConfigEntry<KeyCode> LoadoutToggleGamepadKey;

		public static ConfigEntry<KeyCode> StatsToggleGamepadKey;

		private static string _newSlotName;

		private static string _newSlotPrefabs;

		private static Vector2 _slotsScrollPosition;

		private static Vector2 _prefabScrollPosition;

		private static bool _showPrefabList;

		private int NextOrder => _configOrder--;

		static AzuExtendedPlayerInventoryPlugin()
		{
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			ConfigFileName = "Azumatt.AzuExtendedPlayerInventory.cfg";
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			AzuExtendedPlayerInventoryLogger = Logger.CreateLogSource("AzuExtendedPlayerInventory");
			ConfigSync = new ConfigSync("Azumatt.AzuExtendedPlayerInventory")
			{
				DisplayName = "AzuExtendedPlayerInventory",
				CurrentVersion = "2.4.2",
				MinimumRequiredVersion = "2.4.2"
			};
			context = null;
			FakeType = StringExtensionMethods.GetStableHashCode("AzuEPIFakeType");
			_serverConfigLocked = null;
			AutoEquip = null;
			WishboneSlot = null;
			WispLightSlot = null;
			RemovedEquipmentSlots = null;
			UserAddedSlots = null;
			EPISlotsAddArmor = null;
			UtilityEPIAddArmor = null;
			AddEquipmentRow = null;
			DisplayEquipmentRowSeparate = null;
			QuickSlotsAmount = null;
			ShowQuickSlots = null;
			MakeDropAllButton = null;
			DropAllButtonPosition = null;
			SelectedPlayerStats = null;
			SelectedLiveStats = null;
			ExtraRows = null;
			HelmetText = null;
			ChestText = null;
			LegsText = null;
			BackText = null;
			TrinketText = null;
			UtilityText = null;
			QuickAccessScale = null;
			QuickslotDragKeys = null;
			ModKeyTwo = null;
			Hotkeys = null;
			HotkeyTexts = null;
			QuickAccessLocation = null;
			QuickSlotsPerRow = null;
			AlwaysShowQuickSlotsInUI = null;
			UIAnchor = null;
			LocalScale = null;
			VanityOption = null;
			LoadoutOption = null;
			OldLayout = null;
			VanityToggleGamepadKey = null;
			LoadoutToggleGamepadKey = null;
			StatsToggleGamepadKey = null;
			_newSlotName = "";
			_newSlotPrefabs = "";
			_slotsScrollPosition = Vector2.zero;
			_prefabScrollPosition = Vector2.zero;
			_showPrefabList = false;
			AppDomain.CurrentDomain.AssemblyResolve += (object s, ResolveEventArgs e) => (!(new AssemblyName(e.Name).Name == "AzuExtendedPlayerInventory")) ? null : typeof(AzuExtendedPlayerInventoryPlugin).Assembly;
		}

		private unsafe void Awake()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Expected O, but got Unknown
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Expected O, but got Unknown
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Expected O, but got Unknown
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_068a: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			Localizer.Load();
			Patcher.Patch(new <>z__ReadOnlyArray<string>(new string[2] { "AzuExtendedPlayerInventory", "AzuExtendedPlayerInventory.EPI.Patches" }));
			context = this;
			ResetConfigOrder();
			_serverConfigLocked = config("1 - Server & Sync", "Lock Configuration", Toggle.On, "When enabled, only server admins can modify configuration settings. All players will use the server's settings.", NextOrder);
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			ResetConfigOrder();
			ExtraRows = config("2 - Inventory", "Extra Inventory Rows", 0, new ConfigDescription("Add extra rows to your inventory (0-5).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5), Array.Empty<object>()), NextOrder);
			AddEquipmentRow = config("2 - Inventory", "Enable Equipment Row", Toggle.On, "Adds a dedicated row for equipped items and quick slots. IMPORTANT: Turn OFF if using Randy Knapp's Equipment and Quick Slots mod to avoid conflicts.", NextOrder);
			DisplayEquipmentRowSeparate = config("2 - Inventory", "Display Equipment in Separate Panel", Toggle.On, "Shows equipped items and quick slots in their own dedicated panel instead of inline. IMPORTANT: Turn OFF if using Randy Knapp's Equipment and Quick Slots mod.", NextOrder);
			AutoEquip = config("2 - Inventory", "Auto-Equip Items", Toggle.On, "Automatically equip items when picked up, moved from containers, or recovered from tombstones. Disable if you prefer manual equipping.", NextOrder);
			ResetConfigOrder();
			QuickSlotsAmount = config("3 - Quick Slots", "Number of Quick Slots", 3, new ConfigDescription("How many quick slots to add (0-8). Quick slots let you hotkey items for instant access. Default is 3.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 8), Array.Empty<object>()), NextOrder);
			ShowQuickSlots = config("3 - Quick Slots", "Show Quick Slots on HUD", Toggle.On, "Display the quick slots bar on your screen during gameplay. Turn off to hide the bar while keeping the slots functional.", NextOrder);
			AlwaysShowQuickSlotsInUI = config("3 - Quick Slots", "Always Show All Slots", Toggle.On, "Display all available quick slots on the HUD. When disabled, only shows slots up to the highest occupied one.", NextOrder);
			QuickSlotsPerRow = config("3 - Quick Slots", "Slots Per Row", 8, new ConfigDescription("How many quick slots to show per row. Set to your total slots for horizontal layout, or use lower values (3-4) for vertical stacking.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>()), NextOrder, synchronizedSetting: false);
			ResetConfigOrder();
			WishboneSlot = config("4 - Special Equipment Slots", "Enable Wishbone Slot", Toggle.On, "Adds a dedicated equipment slot specifically for the Wishbone. When equipped here, the Wishbone's detection works without occupying utility slots.", NextOrder);
			WispLightSlot = config("4 - Special Equipment Slots", "Enable Demister Slot", Toggle.On, "Adds a dedicated equipment slot specifically for the Demister/Wisplight. Keeps the mist clear without using utility slots.", NextOrder);
			ResetConfigOrder();
			config("4.5 - Equipment Slot Management", "Slot Manager (UI)", "", new ConfigDescription("If you are using the Configuration Manager, this will be a custom drawer. Use this for easier slot management with buttons and prefab browser.\nIf you aren't, edit the configs below directly", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = EquipmentSlotsConfigDrawer,
					Order = NextOrder
				}
			}), NextOrder);
			RemovedEquipmentSlots = config("4.5 - Equipment Slot Management", "Removed Equipment Slots", "", new ConfigDescription("Comma or semicolon-separated list of equipment slot names to remove from the game.\nWARNING: Removing slots will unequip items in those slots!\nExample: Head, Utility, Trinket\nBuilt-in slots: Head, Chest, Legs, Back, Utility, Trinket, Wishbone, Demister", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = NextOrder,
					Browsable = false
				}
			}), NextOrder);
			UserAddedSlots = config("4.5 - Equipment Slot Management", "Custom Equipment Slots", "", new ConfigDescription("Add custom equipment slots. Format: SlotName:PrefabName1,PrefabName2;SlotName2:Prefab3\nSemicolon separates different slots. Colon separates slot name from prefabs. Comma separates multiple prefabs for one slot.\nExample: Ring:RingIron,RingGold;Quiver:QuiverBone,QuiverLeather", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = NextOrder,
					Browsable = false
				}
			}), NextOrder);
			EPISlotsAddArmor = config("4.5 - Equipment Slot Management", "Slots Use Armor", Toggle.On, "If On, the armor on items in the custom slots is applied to the player. If off, the armor is not calculated, which is better for vanilla balance, but not expected. Default is set to On for this reason", NextOrder);
			UtilityEPIAddArmor = config("4.5 - Equipment Slot Management", "Utility Slots Use Armor", Toggle.Off, "If On & Slots Use Armor config is on, the armor on utility items in the custom slots is applied to the player. If off, the armor is not calculated, which is better for vanilla balance. Default is off for this reason.", NextOrder);
			ResetConfigOrder();
			OldLayout = config("5 - UI Features", "Use Legacy Layout", Toggle.Off, "Reverts to the old inventory layout from previous versions. Only enable if you prefer the classic style or have compatibility issues.", NextOrder);
			VanityOption = config("5 - UI Features", "Show Vanity Button", Toggle.On, "Shows the vanity button (\ud83d\udc54) in the inventory. Use this to customize your character's appearance with cosmetic overrides.", NextOrder);
			LoadoutOption = config("5 - UI Features", "Show Loadout Button", Toggle.On, "Shows the loadout button (\ud83c\udfaf) in the inventory. Use this to save and quickly swap between different equipment sets.", NextOrder);
			string value = string.Join(",", from PlayerStatType stat in Enum.GetValues(typeof(PlayerStatType))
				where (int)stat != 105
				select ((object)(*(PlayerStatType*)(&stat))/*cast due to .constrained prefix*/).ToString());
			SelectedPlayerStats = config("5 - UI Features", "Player Stats to Display", value, new ConfigDescription("Choose which character stats to display in the stats panel (\ud83d\udccb button). Use the config manager UI to select/deselect stats.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = StatsConfigDrawer
				}
			}), NextOrder, synchronizedSetting: false);
			string value2 = string.Join(",", from LiveStatType stat in Enum.GetValues(typeof(LiveStatType))
				select stat.ToString());
			SelectedLiveStats = config("5 - UI Features", "Live Stats to Display", value2, new ConfigDescription("Choose which live character stats to display in the stats panel (\ud83d\udccb button). These include health, damage modifiers, resistances, etc. Use the config manager UI to select/deselect stats.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = LiveStatsConfigDrawer
				}
			}), NextOrder, synchronizedSetting: false);
			ResetConfigOrder();
			HelmetText = config("6 - Equipment Slot Labels", "Head Slot Label", "", "Customize the display text for the helmet/head equipment slot. Use a localization key (starts with $) to use translations, or set custom text.", NextOrder, synchronizedSetting: false);
			ChestText = config("6 - Equipment Slot Labels", "Chest Slot Label", "", "Customize the display text for the chest armor equipment slot. Use a localization key (starts with $) to use translations, or set custom text.", NextOrder, synchronizedSetting: false);
			LegsText = config("6 - Equipment Slot Labels", "Legs Slot Label", "", "Customize the display text for the leg armor equipment slot. Use a localization key (starts with $) to use translations, or set custom text.", NextOrder, synchronizedSetting: false);
			BackText = config("6 - Equipment Slot Labels", "Back Slot Label", "", "Customize the display text for the cape/back equipment slot. Use a localization key (starts with $) to use translations, or set custom text.", NextOrder, synchronizedSetting: false);
			UtilityText = config("6 - Equipment Slot Labels", "Utility Slot Label", "", "Customize the display text for the utility equipment slot. Use a localization key (starts with $) to use translations, or set custom text.", NextOrder, synchronizedSetting: false);
			TrinketText = config("6 - Equipment Slot Labels", "Trinket Slot Label", "", "Customize the display text for the trinket equipment slot. Use a localization key (starts with $) to use translations, or set custom text.", NextOrder, synchronizedSetting: false);
			ResetConfigOrder();
			QuickAccessScale = config("7 - Quick Slots Customization", "HUD Size", 1f, "Scale/size multiplier for the quick slots bar on your HUD. 1.0 = default size, 0.5 = half size, 2.0 = double size.", NextOrder, synchronizedSetting: false);
			QuickAccessLocation = config<Vector2>("7 - Quick Slots Customization", "HUD Position", Vector2.one, "Screen position of the quick slots bar. Use the drag keys (default: CTRL+LeftClick) to reposition, or set to (9999, 9999) for automatic positioning.", NextOrder, synchronizedSetting: false);
			QuickslotDragKeys = config<KeyboardShortcut>("7 - Quick Slots Customization", "Drag to Reposition Keys", new KeyboardShortcut((KeyCode)323, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Key combination to drag and reposition the quick slots bar on screen. Default: Hold CTRL and drag with left mouse button.", NextOrder, synchronizedSetting: false);
			ResetConfigOrder();
			VanityToggleGamepadKey = config<KeyCode>("8.5 - Panel Toggle Keys (Gamepad)", "Vanity Panel Toggle Key", (KeyCode)338, "Gamepad button to toggle the Vanity panel. Default: Left Stick Press (JoyLStick).", NextOrder, synchronizedSetting: false);
			LoadoutToggleGamepadKey = config<KeyCode>("8.5 - Panel Toggle Keys (Gamepad)", "Loadout Panel Toggle Key", (KeyCode)339, "Gamepad button to toggle the Loadout panel. Default: Right Stick Press (JoyRStick).", NextOrder, synchronizedSetting: false);
			StatsToggleGamepadKey = config<KeyCode>("8.5 - Panel Toggle Keys (Gamepad)", "Stats Panel Toggle Key", (KeyCode)333, "Gamepad button to toggle the Stats panel. Default: Y (JoyButtonY).", NextOrder, synchronizedSetting: false);
			ResetConfigOrder();
			MakeDropAllButton = config("9 - Additional Features", "Enable Drop All Button", Toggle.Off, "Adds a 'Drop All' button to your inventory for quickly dropping all items. USE WITH CAUTION!", NextOrder, synchronizedSetting: false);
			DropAllButtonPosition = config<Vector2>("9 - Additional Features", "Drop All Button Position", new Vector2(880f, 10f), "Position of the Drop All button in the inventory window (X, Y coordinates).", NextOrder, synchronizedSetting: false);
			Initializers.InitSlotsAndKeys();
			Initializers.SetupEventHandlers();
			_harmony.PatchAll();
			InitializeConfigWatcher();
			if (WishboneSlot.Value.isOn() && !IsSlotMarkedForRemoval("$item_wishbone"))
			{
				API.AddSlot("$item_wishbone", "Wishbone", 5);
			}
			if (WispLightSlot.Value.isOn() && !IsSlotMarkedForRemoval("$item_demister"))
			{
				API.AddSlot("$item_demister", "Demister", WishboneSlot.Value.isOn() ? 6 : 5);
			}
			int index = ExtendedPlayerInventory.slots.Count - QuickSlotsAmount.Value;
			API.UpdateSlots(index, 1);
			ExtendedPlayerInventory.slots.Insert(index, new Model.EquipmentSlot
			{
				Name = TrinketText.Value,
				OriginalName = "$azu_epi_trinket",
				IsQuickSlot = false,
				Get = (Player player) => ((Humanoid)player).m_trinketItem,
				Valid = (ItemData item) => item != null && (int)item.m_shared.m_itemType == 24
			});
			SlotHelpers.ResizeSlots();
			SlotBackupManager.InitializeBuiltInSlotBackups();
			ApplySlotChanges();
			Localization.OnLanguageChange = (Action)Delegate.Combine(Localization.OnLanguageChange, new Action(API.RelocalizeSlots));
			Localizer.OnLocalizationComplete += API.RelocalizeSlots;
		}

		internal void FullRebuild()
		{
			try
			{
				InventoryGuiPatches.UpdateInventory_Patch.RebuildQuickslots();
				SlotHelpers.ResizeSlots();
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryLogger.LogError((object)("Error during FullRebuild (slot rebuild): " + ex.Message + "\n" + ex.StackTrace));
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)InventoryGui.instance == (Object)null)
			{
				AzuExtendedPlayerInventoryLogger.LogDebug((object)"FullRebuild skipped GUI phase - player or inventory not initialized");
				return;
			}
			try
			{
				Layout.UpdateInventorySize();
				InventoryHealth.FixHiddenItems();
				SlotHelpers.UpdateEquipmentBackgroundAnchors();
				UIBuilder.RebuildUI();
				QuickAccessBar.ForceRefresh();
				API.RelocalizeSlots();
			}
			catch (Exception ex2)
			{
				AzuExtendedPlayerInventoryLogger.LogError((object)("Error during FullRebuild (GUI phase): " + ex2.Message + "\n" + ex2.StackTrace));
			}
		}

		internal static void RefreshPanelButtonBindings()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)VanityPanelController.VanityButtonGo != (Object)null)
			{
				PanelUtilities.UpdateButtonBinding(VanityPanelController.VanityButtonGo, VanityToggleGamepadKey.Value);
			}
			if ((Object)(object)PersonalLoadoutGui.LoadoutsToggleButton != (Object)null)
			{
				PanelUtilities.UpdateButtonBinding(PersonalLoadoutGui.LoadoutsToggleButton, LoadoutToggleGamepadKey.Value);
			}
			if ((Object)(object)StatsPanelController.StatsButtonGo != (Object)null)
			{
				PanelUtilities.UpdateButtonBinding(StatsPanelController.StatsButtonGo, StatsToggleGamepadKey.Value);
			}
		}

		private void Start()
		{
			EAQ.CheckRandy();
			WeightBase.CheckWeightBase();
			Localizer.OnLocalizationComplete += delegate
			{
				AdvBackpacksCompat.Init();
				JudesEquipmentCompat.Init();
				Hunter_LegacyCompat.Init();
				WizardryCompat.Init();
				EpicLootCompat.Init();
				JewelcraftingCompat.Init();
			};
			ArmoireCompat.CheckForArmoire();
			ZenUICompat.DisableEquipmentSlots();
			ValheimPlusCompat.Initialize();
		}

		private void OnDestroy()
		{
			if (_cfgWatcher != null)
			{
				_cfgWatcher.EnableRaisingEvents = false;
				_cfgWatcher.Dispose();
			}
			if (_debounce != null)
			{
				_debounce.Stop();
				_debounce.Dispose();
			}
			try
			{
				Localization.OnLanguageChange = (Action)Delegate.Remove(Localization.OnLanguageChange, new Action(API.RelocalizeSlots));
				Localizer.OnLocalizationComplete -= API.RelocalizeSlots;
			}
			catch
			{
			}
			JewelcraftingCompat.Cleanup();
			try
			{
				if (QuickSlotsAmount != null)
				{
					ClearSettingChangedEvent<int>(QuickSlotsAmount);
				}
				if (ExtraRows != null)
				{
					ClearSettingChangedEvent<int>(ExtraRows);
				}
				if (AddEquipmentRow != null)
				{
					ClearSettingChangedEvent<Toggle>(AddEquipmentRow);
				}
				if (DisplayEquipmentRowSeparate != null)
				{
					ClearSettingChangedEvent<Toggle>(DisplayEquipmentRowSeparate);
				}
				if (ShowQuickSlots != null)
				{
					ClearSettingChangedEvent<Toggle>(ShowQuickSlots);
				}
				if (SelectedPlayerStats != null)
				{
					ClearSettingChangedEvent<string>(SelectedPlayerStats);
				}
				if (QuickSlotsPerRow != null)
				{
					ClearSettingChangedEvent<int>(QuickSlotsPerRow);
				}
				if (RemovedEquipmentSlots != null)
				{
					ClearSettingChangedEvent<string>(RemovedEquipmentSlots);
				}
				if (UserAddedSlots != null)
				{
					ClearSettingChangedEvent<string>(UserAddedSlots);
				}
				if (WishboneSlot != null)
				{
					ClearSettingChangedEvent<Toggle>(WishboneSlot);
				}
				if (WispLightSlot != null)
				{
					ClearSettingChangedEvent<Toggle>(WispLightSlot);
				}
				if (VanityOption != null)
				{
					ClearSettingChangedEvent<Toggle>(VanityOption);
				}
				if (LoadoutOption != null)
				{
					ClearSettingChangedEvent<Toggle>(LoadoutOption);
				}
				if (VanityToggleGamepadKey != null)
				{
					ClearSettingChangedEvent<KeyCode>(VanityToggleGamepadKey);
				}
				if (LoadoutToggleGamepadKey != null)
				{
					ClearSettingChangedEvent<KeyCode>(LoadoutToggleGamepadKey);
				}
				if (StatsToggleGamepadKey != null)
				{
					ClearSettingChangedEvent<KeyCode>(StatsToggleGamepadKey);
				}
				if (OldLayout != null)
				{
					ClearSettingChangedEvent<Toggle>(OldLayout);
				}
				if (HotkeyTexts != null)
				{
					ConfigEntry<string>[] hotkeyTexts = HotkeyTexts;
					foreach (ConfigEntry<string> val in hotkeyTexts)
					{
						if (val != null)
						{
							ClearSettingChangedEvent<string>(val);
						}
					}
				}
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error during event cleanup: " + ex.Message));
			}
			((BaseUnityPlugin)this).Config.Save();
		}

		private static void ClearSettingChangedEvent<T>(ConfigEntry<T> configEntry)
		{
			FieldInfo field = typeof(ConfigEntry<T>).GetField("SettingChanged", BindingFlags.Instance | BindingFlags.Public);
			if (field != null)
			{
				field.SetValue(configEntry, null);
			}
		}

		private void InitializeConfigWatcher()
		{
			_debounce = new System.Timers.Timer(150.0)
			{
				AutoReset = false
			};
			_debounce.Elapsed += delegate
			{
				ReadConfigValues(null, null);
			};
			_cfgWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName)
			{
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite),
				IncludeSubdirectories = false,
				SynchronizingObject = ThreadingHelper.SynchronizingObject,
				EnableRaisingEvents = true
			};
			_cfgWatcher.Changed += delegate
			{
				_debounce?.Start();
			};
			_cfgWatcher.Created += delegate
			{
				_debounce?.Start();
			};
			_cfgWatcher.Renamed += delegate
			{
				_debounce?.Start();
			};
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				AzuExtendedPlayerInventoryLogger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch (Exception arg)
			{
				AzuExtendedPlayerInventoryLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				AzuExtendedPlayerInventoryLogger.LogError((object)$"Please check your config entries for spelling and format!{Environment.NewLine}{arg}");
			}
		}

		private void ResetConfigOrder(int order = 100)
		{
			_configOrder = order;
		}

		internal ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		internal ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		internal ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, int order, bool synchronizedSetting = true)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes
			{
				Order = order
			};
			object[] array = ((description.Tags.Length != 0) ? description.Tags.Append(configurationManagerAttributes).ToArray() : new object[1] { configurationManagerAttributes });
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, array);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		internal ConfigEntry<T> config<T>(string group, string name, T value, string description, int order, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), order, synchronizedSetting);
		}

		private unsafe static void StatsConfigDrawer(ConfigEntryBase entry)
		{
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			PlayerStatType[] source = (PlayerStatType[])Enum.GetValues(typeof(PlayerStatType));
			source = source.Where((PlayerStatType x) => (int)x != 105).ToArray();
			List<PlayerStatType> list = ParseStatsList(SelectedPlayerStats.Value);
			GUILayout.Space(5f);
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Select All", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				SelectedPlayerStats.Value = string.Join(",", source.Select((PlayerStatType s) => ((object)(*(PlayerStatType*)(&s))/*cast due to .constrained prefix*/).ToString()));
			}
			if (GUILayout.Button("Clear All", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				SelectedPlayerStats.Value = "";
			}
			GUILayout.EndHorizontal();
			int num = 3;
			int num2 = Mathf.CeilToInt((float)source.Length / (float)num);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			for (int num3 = 0; num3 < num; num3++)
			{
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				int num4 = num3 * num2;
				int num5 = Math.Min(num4 + num2, source.Length);
				for (int num6 = num4; num6 < num5 && num6 < source.Length; num6++)
				{
					PlayerStatType item = source[num6];
					bool flag = list.Contains(item);
					bool flag2 = GUILayout.Toggle(flag, ((object)(*(PlayerStatType*)(&item))/*cast due to .constrained prefix*/).ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
					if (flag2 != flag)
					{
						if (flag2)
						{
							list.Add(item);
						}
						else
						{
							list.Remove(item);
						}
						SelectedPlayerStats.Value = string.Join(",", list.Select((PlayerStatType s) => ((object)(*(PlayerStatType*)(&s))/*cast due to .constrained prefix*/).ToString()));
					}
				}
				GUILayout.EndVertical();
			}
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		public static List<PlayerStatType> ParseStatsList(string statsString)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerStatType> list = new List<PlayerStatType>();
			if (string.IsNullOrWhiteSpace(statsString))
			{
				return list;
			}
			string[] array = statsString.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				if (Enum.TryParse<PlayerStatType>(array[i].Trim(), out PlayerStatType result))
				{
					list.Add(result);
				}
			}
			return list;
		}

		private static void LiveStatsConfigDrawer(ConfigEntryBase entry)
		{
			LiveStatType[] array = (LiveStatType[])Enum.GetValues(typeof(LiveStatType));
			List<LiveStatType> list = ParseLiveStatsList(SelectedLiveStats.Value);
			GUILayout.Space(5f);
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Select All", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				SelectedLiveStats.Value = string.Join(",", array.Select((LiveStatType s) => s.ToString()));
			}
			if (GUILayout.Button("Clear All", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				SelectedLiveStats.Value = "";
			}
			GUILayout.EndHorizontal();
			int num = 3;
			int num2 = Mathf.CeilToInt((float)array.Length / (float)num);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			for (int num3 = 0; num3 < num; num3++)
			{
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				int num4 = num3 * num2;
				int num5 = Math.Min(num4 + num2, array.Length);
				for (int num6 = num4; num6 < num5 && num6 < array.Length; num6++)
				{
					LiveStatType liveStatType = array[num6];
					bool flag = list.Contains(liveStatType);
					bool flag2 = GUILayout.Toggle(flag, FormatLiveStatName(liveStatType), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
					if (flag2 != flag)
					{
						if (flag2)
						{
							list.Add(liveStatType);
						}
						else
						{
							list.Remove(liveStatType);
						}
						SelectedLiveStats.Value = string.Join(",", list.Select((LiveStatType s) => s.ToString()));
					}
				}
				GUILayout.EndVertical();
			}
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		public static List<LiveStatType> ParseLiveStatsList(string statsString)
		{
			List<LiveStatType> list = new List<LiveStatType>();
			if (string.IsNullOrWhiteSpace(statsString))
			{
				return list;
			}
			string[] array = statsString.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				if (Enum.TryParse<LiveStatType>(array[i].Trim(), out var result))
				{
					list.Add(result);
				}
			}
			return list;
		}

		private static string FormatLiveStatName(LiveStatType stat)
		{
			return Regex.Replace(stat.ToString(), "([a-z])([A-Z])", "$1 $2");
		}

		private static void EquipmentSlotsConfigDrawer(ConfigEntryBase entry)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Expected O, but got Unknown
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Expected O, but got Unknown
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Expected O, but got Unknown
			//IL_08dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f3: Expected O, but got Unknown
			//IL_0902: Unknown result type (might be due to invalid IL or missing references)
			//IL_0907: Unknown result type (might be due to invalid IL or missing references)
			//IL_0919: Expected O, but got Unknown
			//IL_0928: Unknown result type (might be due to invalid IL or missing references)
			//IL_092d: Unknown result type (might be due to invalid IL or missing references)
			//IL_093f: Expected O, but got Unknown
			//IL_094e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0953: Unknown result type (might be due to invalid IL or missing references)
			//IL_0965: Expected O, but got Unknown
			//IL_096f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0974: Unknown result type (might be due to invalid IL or missing references)
			//IL_0985: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0701: Expected O, but got Unknown
			//IL_071a: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Expected O, but got Unknown
			//IL_09e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_0308: Expected O, but got Unknown
			//IL_07a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Expected O, but got Unknown
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Expected O, but got Unknown
			//IL_0810: Expected O, but got Unknown
			//IL_0854: Unknown result type (might be due to invalid IL or missing references)
			//IL_0859: Unknown result type (might be due to invalid IL or missing references)
			//IL_0861: Unknown result type (might be due to invalid IL or missing references)
			//IL_0868: Unknown result type (might be due to invalid IL or missing references)
			//IL_0879: Expected O, but got Unknown
			List<string> allCurrentSlots = GetAllCurrentSlots();
			List<string> list = ParseSlotList(RemovedEquipmentSlots.Value);
			List<string> builtInSlotNames = GetBuiltInSlotNames();
			List<string> userAddedSlotNames = GetUserAddedSlotNames();
			GUILayout.Space(5f);
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.Label("REMOVE EQUIPMENT SLOTS", new GUIStyle(GUI.skin.label)
			{
				fontStyle = (FontStyle)1,
				alignment = (TextAnchor)4
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.Label("Click to remove slots (WARNING: unequips items!):", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.Space(5f);
			_slotsScrollPosition = GUILayout.BeginScrollView(_slotsScrollPosition, GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(200f) });
			foreach (string slot in allCurrentSlots)
			{
				bool flag = list.Contains(slot);
				bool flag2 = builtInSlotNames.Contains(slot);
				bool flag3 = userAddedSlotNames.Contains(slot);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				Color backgroundColor = GUI.backgroundColor;
				if (flag)
				{
					GUI.backgroundColor = Color.red;
				}
				if (GUILayout.Button(flag ? "✓ Removed" : "Remove", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) }))
				{
					if (flag)
					{
						list.Remove(slot);
						RemovedEquipmentSlots.Value = string.Join(", ", from s in list.Distinct()
							orderby s
							select s);
					}
					else if (flag3)
					{
						List<string> list2 = ParseUserAddedSlots();
						list2.RemoveAll((string s) => s.StartsWith(slot.Trim() + ":"));
						UserAddedSlots.Value = string.Join(";", list2.Distinct());
					}
					else
					{
						if (!list.Contains(slot))
						{
							list.Add(slot);
						}
						RemovedEquipmentSlots.Value = string.Join(", ", from s in list.Distinct()
							orderby s
							select s);
					}
				}
				GUI.backgroundColor = backgroundColor;
				GUILayout.Label(slot ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
				if (flag2)
				{
					GUILayout.Label("(Built-in)", new GUIStyle(GUI.skin.label)
					{
						fontSize = 10,
						fontStyle = (FontStyle)2
					}, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
				}
				else if (flag3)
				{
					GUILayout.Label("(Your Custom)", new GUIStyle(GUI.skin.label)
					{
						fontSize = 10,
						fontStyle = (FontStyle)2,
						normal = new GUIStyleState
						{
							textColor = Color.cyan
						}
					}, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
				}
				else
				{
					GUILayout.Label("(API/Mod)", new GUIStyle(GUI.skin.label)
					{
						fontSize = 10
					}, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
			GUILayout.Space(15f);
			GUILayout.Label("ADD CUSTOM EQUIPMENT SLOTS", new GUIStyle(GUI.skin.label)
			{
				fontStyle = (FontStyle)1,
				alignment = (TextAnchor)4
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Slot Name:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			_newSlotName = GUILayout.TextField(_newSlotName, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Prefab Names:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			_newSlotPrefabs = GUILayout.TextField(_newSlotPrefabs, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (GUILayout.Button("?", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(25f) }))
			{
				_showPrefabList = !_showPrefabList;
			}
			GUILayout.EndHorizontal();
			GUILayout.Label("(Comma-separated list of item prefab names, e.g., 'HelmetBronze,HelmetIron')", new GUIStyle(GUI.skin.label)
			{
				fontSize = 10,
				fontStyle = (FontStyle)2
			}, Array.Empty<GUILayoutOption>());
			if (_showPrefabList)
			{
				GUILayout.Space(5f);
				GUILayout.Label("Available Item Prefabs:", new GUIStyle(GUI.skin.label)
				{
					fontStyle = (FontStyle)1
				}, Array.Empty<GUILayoutOption>());
				_prefabScrollPosition = GUILayout.BeginScrollView(_prefabScrollPosition, GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(150f) });
				foreach (string availableItemPrefab in GetAvailableItemPrefabs())
				{
					if (GUILayout.Button(availableItemPrefab, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
					{
						if (string.IsNullOrEmpty(_newSlotPrefabs))
						{
							_newSlotPrefabs = availableItemPrefab;
						}
						else if (!_newSlotPrefabs.Contains(availableItemPrefab))
						{
							_newSlotPrefabs = _newSlotPrefabs + ", " + availableItemPrefab;
						}
					}
				}
				GUILayout.EndScrollView();
			}
			GUILayout.Space(5f);
			if (GUILayout.Button("Add Slot", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }) && !string.IsNullOrWhiteSpace(_newSlotName) && !string.IsNullOrWhiteSpace(_newSlotPrefabs))
			{
				string trimmedSlotName = _newSlotName.Trim();
				string item = trimmedSlotName + ":" + _newSlotPrefabs.Trim();
				List<string> list3 = ParseUserAddedSlots();
				if (list.Contains(trimmedSlotName))
				{
					list.Remove(trimmedSlotName);
					RemovedEquipmentSlots.Value = string.Join(", ", from s in list.Distinct()
						orderby s
						select s);
				}
				list3.RemoveAll((string s) => s.StartsWith(trimmedSlotName + ":"));
				list3.Add(item);
				UserAddedSlots.Value = string.Join(";", list3.Distinct());
				_newSlotName = "";
				_newSlotPrefabs = "";
			}
			List<string> list4 = ParseUserAddedSlots();
			if (list4.Count > 0)
			{
				GUILayout.Space(10f);
				GUILayout.Label($"YOUR CUSTOM SLOTS ({list4.Count})", new GUIStyle(GUI.skin.label)
				{
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				}, Array.Empty<GUILayoutOption>());
				GUILayout.Space(3f);
				GUILayout.Label("Valid item prefabs for each custom slot:", new GUIStyle(GUI.skin.label)
				{
					fontSize = 10,
					fontStyle = (FontStyle)2,
					alignment = (TextAnchor)4
				}, Array.Empty<GUILayoutOption>());
				GUILayout.Space(5f);
				foreach (string item2 in list4)
				{
					string[] array = item2.Split(new char[1] { ':' });
					if (array.Length == 2)
					{
						GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
						GUILayout.Label("• " + array[0], new GUIStyle(GUI.skin.label)
						{
							fontStyle = (FontStyle)1
						}, Array.Empty<GUILayoutOption>());
						GUILayout.Label("   Accepts: " + array[1], new GUIStyle(GUI.skin.label)
						{
							fontSize = 10,
							normal = new GUIStyleState
							{
								textColor = new Color(0.7f, 0.7f, 0.7f)
							}
						}, Array.Empty<GUILayoutOption>());
						GUILayout.EndVertical();
						GUILayout.Space(2f);
					}
				}
				GUILayout.Space(3f);
				GUILayout.Label("(Use 'Remove Equipment Slots' section above to remove slots)", new GUIStyle(GUI.skin.label)
				{
					fontSize = 9,
					fontStyle = (FontStyle)2,
					alignment = (TextAnchor)4
				}, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(15f);
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.Label("RESET TO DEFAULTS", new GUIStyle(GUI.skin.label)
			{
				fontStyle = (FontStyle)1,
				alignment = (TextAnchor)4
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.Label("This will:", new GUIStyle(GUI.skin.label)
			{
				fontSize = 10
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Label("  • Remove all your custom slots", new GUIStyle(GUI.skin.label)
			{
				fontSize = 10
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Label("  • Restore all hidden built-in slots", new GUIStyle(GUI.skin.label)
			{
				fontSize = 10
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Label("  • Keep API/Mod-added slots (from other mods)", new GUIStyle(GUI.skin.label)
			{
				fontSize = 10
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			Color backgroundColor2 = GUI.backgroundColor;
			GUI.backgroundColor = new Color(1f, 0.5f, 0.5f);
			if (GUILayout.Button("Reset to Defaults", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				UserAddedSlots.Value = "";
				RemovedEquipmentSlots.Value = "";
				_newSlotName = "";
				_newSlotPrefabs = "";
				_showPrefabList = false;
			}
			GUI.backgroundColor = backgroundColor2;
			GUILayout.EndVertical();
			GUILayout.Space(5f);
			GUILayout.EndVertical();
		}

		private static List<string> GetAllCurrentSlots()
		{
			List<string> list = new List<string>();
			try
			{
				foreach (Model.Slot slot in ExtendedPlayerInventory.slots)
				{
					if (slot != null && !slot.IsQuickSlot && slot is Model.EquipmentSlot equipmentSlot)
					{
						string text = equipmentSlot.OriginalName ?? equipmentSlot.Name;
						if (!string.IsNullOrEmpty(text))
						{
							list.Add(text);
						}
					}
				}
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting current slots: " + ex.Message));
			}
			return list.Distinct().ToList();
		}

		public static List<string> GetBuiltInSlotNames()
		{
			return new List<string>(8) { "$azu_epi_helmet", "$azu_epi_chest", "$azu_epi_legs", "$azu_epi_shoulder", "$azu_epi_utility", "$item_wishbone", "$item_demister", "$azu_epi_trinket" };
		}

		private static List<string> GetUserAddedSlotNames()
		{
			return (from s in ParseUserAddedSlots()
				select s.Split(new char[1] { ':' })[0].Trim() into name
				where !string.IsNullOrEmpty(name)
				select name).ToList();
		}

		private static List<string> GetAvailableItemPrefabs()
		{
			List<string> list = new List<string>();
			try
			{
				if ((Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items != null)
				{
					foreach (GameObject item in ObjectDB.instance.m_items)
					{
						if ((Object)(object)item != (Object)null)
						{
							list.Add(((Object)item).name);
						}
					}
				}
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting item prefabs: " + ex.Message));
			}
			return list.OrderBy((string p) => p).ToList();
		}

		private static List<string> ParseSlotList(string slotsString)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(slotsString))
			{
				return list;
			}
			string[] array = slotsString.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!string.IsNullOrEmpty(text))
				{
					list.Add(text);
				}
			}
			return list;
		}

		private static List<string> ParseUserAddedSlots()
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(UserAddedSlots?.Value))
			{
				return list;
			}
			string[] array = UserAddedSlots.Value.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!string.IsNullOrEmpty(text))
				{
					list.Add(text);
				}
			}
			return list;
		}

		internal static bool IsSlotMarkedForRemoval(string slotName)
		{
			if (string.IsNullOrWhiteSpace(RemovedEquipmentSlots?.Value))
			{
				return false;
			}
			List<string> list = ParseSlotList(RemovedEquipmentSlots.Value);
			if (list.Contains(slotName))
			{
				return true;
			}
			if (Localization.m_instance == null)
			{
				return false;
			}
			if (slotName.StartsWith("$"))
			{
				string item = Localization.m_instance.Localize(slotName);
				if (list.Contains(item))
				{
					return true;
				}
			}
			else
			{
				string text = "$item_" + slotName.ToLower();
				if (list.Contains(text) || list.Contains(Localization.m_instance.Localize(text)))
				{
					return true;
				}
			}
			return false;
		}

		internal static void ApplySlotChanges()
		{
			try
			{
				List<string> list = ParseSlotList(RemovedEquipmentSlots?.Value ?? "");
				HashSet<string> hashSet = new HashSet<string>();
				foreach (string backupKey in SlotBackupManager.GetBackupKeys())
				{
					if (SlotBackupManager._userConfigSlotNames.Contains(backupKey))
					{
						continue;
					}
					bool flag = list.Contains(backupKey);
					if (!flag && Localization.m_instance != null)
					{
						if (backupKey.StartsWith("$"))
						{
							string item = Localization.m_instance.Localize(backupKey);
							flag = list.Contains(item);
						}
						else
						{
							string text = "$item_" + backupKey.ToLower();
							flag = list.Contains(text) || list.Contains(Localization.m_instance.Localize(text));
						}
					}
					if (!flag)
					{
						Model.Slot slot = ExtendedPlayerInventory.slots.FirstOrDefault((Model.Slot s) => (s is Model.EquipmentSlot equipmentSlot && equipmentSlot.OriginalName == backupKey) || s?.Name == backupKey);
						if (slot != null && list.Contains(slot.Name))
						{
							flag = true;
						}
					}
					if (flag)
					{
						hashSet.Add(backupKey);
					}
					else if (SlotBackupManager.RestoreSlotFromBackup(backupKey))
					{
						AzuExtendedPlayerInventoryLogger.LogInfo((object)("Restored slot '" + backupKey + "' from backup"));
					}
				}
				foreach (string item2 in hashSet)
				{
					if (API.RemoveSlot(item2))
					{
						AzuExtendedPlayerInventoryLogger.LogInfo((object)("Removed slot: " + item2));
					}
				}
				foreach (string item3 in list)
				{
					if (hashSet.Contains(item3))
					{
						continue;
					}
					bool flag2 = API.RemoveSlot(item3);
					if (!flag2 && Localization.m_instance != null)
					{
						if (item3.StartsWith("$"))
						{
							string text2 = Localization.m_instance.Localize(item3);
							if (text2 != item3)
							{
								flag2 = API.RemoveSlot(text2);
							}
						}
						else
						{
							flag2 = API.RemoveSlot("$item_" + item3.ToLower());
						}
					}
					if (flag2)
					{
						AzuExtendedPlayerInventoryLogger.LogInfo((object)("Removed slot: " + item3));
					}
				}
				List<string> list2 = ParseUserAddedSlots();
				HashSet<string> hashSet2 = new HashSet<string>();
				foreach (string item4 in list2)
				{
					string[] array = item4.Split(new char[1] { ':' });
					if (array.Length == 2)
					{
						hashSet2.Add(array[0].Trim());
					}
				}
				foreach (string item5 in SlotBackupManager._userConfigSlotNames.ToList())
				{
					if (!hashSet2.Contains(item5) && API.RemoveSlot(item5))
					{
						AzuExtendedPlayerInventoryLogger.LogInfo((object)("Removed user slot '" + item5 + "' (no longer in config)"));
					}
				}
				SlotBackupManager._userConfigSlotNames.Clear();
				SlotBackupManager._userConfigSlotNames.UnionWith(hashSet2);
				foreach (string item6 in list2)
				{
					string[] array2 = item6.Split(new char[1] { ':' });
					if (array2.Length != 2)
					{
						continue;
					}
					string text3 = array2[0].Trim();
					string[] array3 = (from p in array2[1].Split(new char[1] { ',' })
						select p.Trim() into p
						where !string.IsNullOrEmpty(p)
						select p).ToArray();
					if (string.IsNullOrEmpty(text3) || array3.Length == 0)
					{
						continue;
					}
					int index;
					if (IsSlotMarkedForRemoval(text3))
					{
						AzuExtendedPlayerInventoryLogger.LogWarning((object)("User slot '" + text3 + "' is in both add and remove lists - skipping addition (remove takes precedence)"));
					}
					else if (!API.TryGetSlotIndexByName(text3, out index, allowLocalized: false))
					{
						if (array3.Length == 1)
						{
							API.AddSlot(text3, array3[0]);
						}
						else
						{
							API.AddSlot(text3, array3);
						}
						AzuExtendedPlayerInventoryLogger.LogInfo((object)("Added user slot: " + text3 + " with prefabs: " + string.Join(", ", array3)));
					}
					else
					{
						AzuExtendedPlayerInventoryLogger.LogDebug((object)("User slot '" + text3 + "' already exists, skipping addition"));
					}
				}
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryLogger.LogError((object)("Error applying slot changes: " + ex.Message));
			}
		}
	}
	[PublicAPI]
	public class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		internal static HashSet<Model.EquipmentSlot?> CustomSlots { get; } = new HashSet<Model.EquipmentSlot>();

		public static event Action<Hud>? OnHudAwake;

		public static event Action<Hud>? OnHudAwakeComplete;

		public static event Action<Hud>? OnHudUpdate;

		public static event Action<Hud>? OnHudUpdateComplete;

		public static event Action? OnBeforeQuickSlotsAdded;

		public static event Action? OnQuickSlotsAdded;

		public static event SlotAddedHandler? SlotAdded;

		public static event SlotRemovedHandler? SlotRemoved;

		public static event Action<string>? OnRegisterVisualPrefab;

		public static bool IsLoaded()
		{
			return true;
		}

		public static ItemType GetFakeItemType()
		{
			return (ItemType)AzuExtendedPlayerInventoryPlugin.FakeType;
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			if (string.IsNullOrWhiteSpace(slotName) || (getItem == null && isValid == null))
			{
				return false;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("API.AddSlot called, asking to add slot " + slotName));
			if (AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval(slotName))
			{
				return false;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("API.AddSlot proceeding to add slot " + slotName));
			int num = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s != null && (s.Name == slotName || (Localization.m_instance != null && s.Name == Localization.m_instance.Localize(slotName))));
			if (num >= 0 && ExtendedPlayerInventory.slots[num] is Model.EquipmentSlot slot)
			{
				ComposeOntoSlot(slot, isValid, getItem);
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Extended slot " + slotName));
				return true;
			}
			Model.EquipmentSlot equipmentSlot = new Model.EquipmentSlot
			{
				Name = ((slotName.StartsWith("$") && Localization.m_instance != null) ? Localization.m_instance.Localize(slotName) : slotName),
				OriginalName = slotName,
				Get = getItem,
				Valid = isValid,
				IsAPIAdded = true
			};
			if (index < 0 || index > ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value)
			{
				index = ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			}
			UpdateSlots(index, 1);
			ExtendedPlayerInventory.slots.Insert(index, equipmentSlot);
			CustomSlots.Add(equipmentSlot);
			SlotBackupManager.BackupSlot(equipmentSlot);
			SlotHelpers.ResizeSlots();
			SlotHelpers.UpdateEquipmentBackgroundAnchors();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Added slot " + slotName + ", localized as '" + equipmentSlot.Name + "'"));
			API.SlotAdded?.Invoke(slotName);
			return true;
		}

		public static bool AddSlot(string slotName, string prefabName, int index = -1)
		{
			if (string.IsNullOrWhiteSpace(slotName) || string.IsNullOrWhiteSpace(prefabName))
			{
				return false;
			}
			bool flag = AddSlot(slotName, Get, IsValid, index);
			if (flag)
			{
				RegisterVisualsForSlot(slotName, prefabName);
			}
			return flag;
			ItemData? Get(Player p)
			{
				if (p == null)
				{
					return null;
				}
				Inventory inventory = ((Humanoid)p).GetInventory();
				if (inventory == null)
				{
					return null;
				}
				return inventory.GetEquippedItems()?.FirstOrDefault((Func<ItemData, bool>)((ItemData i) => i != null && Object.op_Implicit((Object)(object)i.m_dropPrefab) && ((Object)i.m_dropPrefab).name == prefabName));
			}
			bool IsValid(ItemData item)
			{
				if (item != null && Object.op_Implicit((Object)(object)item.m_dropPrefab))
				{
					return ((Object)item.m_dropPrefab).name == prefabName;
				}
				return false;
			}
		}

		public static bool AddSlot(string slotName, IEnumerable<string> prefabNames, int index = -1)
		{
			if (string.IsNullOrWhiteSpace(slotName) || prefabNames == null)
			{
				return false;
			}
			HashSet<string> set = new HashSet<string>(prefabNames.Where((string n) => !string.IsNullOrWhiteSpace(n)), StringComparer.Ordinal);
			if (set.Count == 0)
			{
				return false;
			}
			bool num = AddSlot(slotName, Get, IsValid, index);
			if (num)
			{
				RegisterVisualsForSlot(slotName, set.ToArray());
			}
			return num;
			ItemData? Get(Player p)
			{
				if (p == null)
				{
					return null;
				}
				Inventory inventory = ((Humanoid)p).GetInventory();
				if (inventory == null)
				{
					return null;
				}
				return inventory.GetEquippedItems()?.FirstOrDefault((Func<ItemData, bool>)((ItemData i) => i != null && Object.op_Implicit((Object)(object)i.m_dropPrefab) && set.Contains(((Object)i.m_dropPrefab).name)));
			}
			bool IsValid(ItemData item)
			{
				if (item != null && Object.op_Implicit((Object)(object)item.m_dropPrefab))
				{
					return set.Contains(((Object)item.m_dropPrefab).name);
				}
				return false;
			}
		}

		public static bool AddSlot(string slotName, Func<ItemData, bool> isValid, int index = -1, IEnumerable<string>? prefabNamesForVisuals = null)
		{
			if (string.IsNullOrWhiteSpace(slotName) || isValid == null)
			{
				return false;
			}
			bool num = AddSlot(slotName, AutoGet, isValid, index);
			if (num && prefabNamesForVisuals != null)
			{
				RegisterVisualsForSlot(slotName, prefabNamesForVisuals.ToArray());
			}
			return num;
			ItemData? AutoGet(Player p)
			{
				if (p == null)
				{
					return null;
				}
				Inventory inventory = ((Humanoid)p).GetInventory();
				if (inventory == null)
				{
					return null;
				}
				return inventory.GetEquippedItems()?.FirstOrDefault((Func<ItemData, bool>)((ItemData i) => i != null && isValid(i)));
			}
		}

		public static bool AddQuickSlot(string slotName, bool showName = false, int index = -1)
		{
			if (string.IsNullOrWhiteSpace(slotName))
			{
				return false;
			}
			int num = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s?.Name == slotName);
			if (num >= 0 && ExtendedPlayerInventory.slots[num] is Model.EquipmentSlot)
			{
				return true;
			}
			Model.EquipmentSlot item = new Model.EquipmentSlot
			{
				Name = ((!showName) ? "" : ((slotName.StartsWith("$") && Localization.m_instance != null) ? Localization.m_instance.Localize(slotName) : slotName)),
				Valid = (ItemData val) => true,
				IsAPIAdded = true,
				IsQuickSlot = true
			};
			if (index < 0 || index > ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value)
			{
				index = ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			}
			UpdateSlots(index, 1);
			ExtendedPlayerInventory.slots.Insert(index, item);
			CustomSlots.Add(item);
			SlotHelpers.ResizeSlots();
			SlotHelpers.UpdateEquipmentBackgroundAnchors();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Added slot " + slotName));
			API.SlotAdded?.Invoke(slotName);
			return true;
		}

		public static bool RemoveSlot(string slotName)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			int num = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s.Name == slotName || (s is Model.EquipmentSlot equipmentSlot2 && equipmentSlot2.OriginalName == slotName));
			if (num >= 0 && ExtendedPlayerInventory.slots[num] is Model.EquipmentSlot equipmentSlot)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					ItemData val = equipmentSlot.Get?.Invoke(Player.m_localPlayer);
					if (val != null)
					{
						((Humanoid)Player.m_localPlayer).UnequipItem(val, true);
					}
				}
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
					Vector2i val2 = inventory.EpiIndexToGridPos(num);
					ItemData itemAt = inventory.GetItemAt(val2.x, val2.y);
					if (itemAt != null)
					{
						inventory.RemoveItem(itemAt);
						Vector2i val3 = inventory.FindEmptyQuickAware(topFirst: true);
						if (val3.x >= 0 && val3.y >= 0)
						{
							itemAt.m_gridPos = val3;
							inventory.AddItem(itemAt);
							AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"Relocated {Localization.m_instance.Localize(itemAt.m_shared.m_name)} from removed slot to ({val3.x}, {val3.y})");
						}
						else
						{
							AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("No room for " + Localization.m_instance.Localize(itemAt.m_shared.m_name) + " after slot removal, dropping item."));
							((Humanoid)Player.m_localPlayer).DropItem(inventory, itemAt, itemAt.m_stack);
						}
					}
				}
				UpdateSlots(num, -1);
				ExtendedPlayerInventory.slots.RemoveAt(num);
				SlotHelpers.ResizeSlots();
				SlotHelpers.UpdateEquipmentBackgroundAnchors();
				InventoryHealth.FixHiddenItems();
				API.SlotRemoved?.Invoke(slotName);
				return true;
			}
			return false;
		}

		public static SlotInfo GetSlots()
		{
			return BuildSlotInfo((Model.Slot _) => true);
		}

		public static SlotInfo GetQuickSlots()
		{
			return BuildSlotInfo((Model.Slot s) => s.IsQuickSlot);
		}

		public static SlotInfo GetEquipmentSlots()
		{
			return BuildSlotInfo((Model.Slot s) => !s.IsQuickSlot && s.EquipmentSlot != null);
		}

		private static SlotInfo BuildSlotInfo(Func<Model.Slot, bool> filter)
		{
			Model.Slot[] source = ExtendedPlayerInventory.slots.Where((Model.Slot s) => s != null && filter(s)).ToArray();
			return new SlotInfo
			{
				SlotNames = source.Select((Model.Slot s) => s.Name).ToArray(),
				OriginalSlotNames = source.Select((Model.Slot s) => s.OriginalName).ToArray(),
				SlotPositions = source.Select((Model.Slot s) => s.Position).ToArray(),
				GetItemFuncs = source.Select((Model.Slot s) => s.EquipmentSlot?.Get).ToArray(),
				IsValidFuncs = source.Select((Model.Slot s) => s.EquipmentSlot?.Valid).ToArray()
			};
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			List<ItemData> list = new List<ItemData>();
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return list;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			inventory.GetWidth();
			Layout.GetBaseSlotIndex(inventory);
			foreach (SlotSnapshot quickSlotSnapshot in GetQuickSlotSnapshots(inventory))
			{
				ItemData itemAt = inventory.GetItemAt(quickSlotSnapshot.GridPos.x, quickSlotSnapshot.GridPos.y);
				if (itemAt != null)
				{
					list.Add(itemAt);
				}
			}
			return list;
		}

		public static int GetAddedRows(int width)
		{
			return Mathf.CeilToInt((float)ExtendedPlayerInventory.slots.Count / (float)width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetFullHeight(int width)
		{
			return 4 + AzuExtendedPlayerInventoryPlugin.ExtraRows.Value + (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOn() ? GetAddedRows(width) : 0);
		}

		public static void RegisterVisualPrefabs(string slotName, params (string prefabName, string visualName)[] pairs)
		{
			for (int i = 0; i < pairs.Length; i++)
			{
				var (text, visualName) = pairs[i];
				if (!string.IsNullOrWhiteSpace(text))
				{
					CustomEquipVisuals.Register(text);
					CustomEquipVisuals.RegisterForSlot(text, slotName, visualName);
					try
					{
						API.OnRegisterVisualPrefab?.Invoke(text);
					}
					catch
					{
					}
				}
			}
		}

		public static int GetSlotCount()
		{
			return ExtendedPlayerInventory.slots.Count;
		}

		public static bool TryGetSlotIndexByName(string slotName, out int index, bool allowLocalized = true)
		{
			index = -1;
			if (string.IsNullOrWhiteSpace(slotName))
			{
				return false;
			}
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			for (int i = 0; i < slots.Count; i++)
			{
				Model.Slot slot = slots[i];
				if (slot != null && (string.Equals(slot.OriginalName, slotName, StringComparison.Ordinal) || (allowLocalized && string.Equals(slot.Name, slotName, StringComparison.Ordinal))))
				{
					index = i;
					return true;
				}
			}
			return false;
		}

		public static bool TryGetSlotDescriptor(int index, out SlotDescriptor desc)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			desc = default(SlotDescriptor);
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			if ((uint)index >= (uint)slots.Count)
			{
				return false;
			}
			Model.Slot slot = slots[index];
			if (slot == null)
			{
				return false;
			}
			bool isEquipmentSlot = slot is Model.EquipmentSlot && !slot.IsQuickSlot;
			bool isQuickSlot = slot?.IsQuickSlot ?? false;
			bool isCustom = IsCustomSlot(slot as Model.EquipmentSlot);
			desc = new SlotDescriptor(index, slot.Name ?? string.Empty, slot.OriginalName ?? string.Empty, isQuickSlot, isEquipmentSlot, isCustom, slot.Position);
			return true;
		}

		public static int GetSlotGridLinearIndex(Inventory inv, int slotIndex)
		{
			if (inv == null)
			{
				return -1;
			}
			int slotCount = GetSlotCount();
			if ((uint)slotIndex >= (uint)slotCount)
			{
				return -1;
			}
			return Layout.GetBaseSlotIndex(inv) + slotIndex;
		}

		public static Vector2i GetSlotGridPos(Inventory inv, int slotIndex)
		{
			//IL_0021: 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 slotGridLinearIndex = GetSlotGridLinearIndex(inv, slotIndex);
			if (slotGridLinearIndex < 0)
			{
				return new Vector2i(-1, -1);
			}
			int width = inv.GetWidth();
			return new Vector2i(slotGridLinearIndex % width, slotGridLinearIndex / width);
		}

		public static bool TryGetSlotIndexAtGridPos(Inventory inv, Vector2i gridPos, out int slotIndex)
		{
			//IL_0016: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			slotIndex = -1;
			if (inv == null)
			{
				return false;
			}
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			if (gridPos.y < num)
			{
				return false;
			}
			int num2 = gridPos.y * width + gridPos.x;
			int num3 = num * width;
			int num4 = num2 - num3;
			int slotCount = GetSlotCount();
			if ((uint)num4 >= (uint)slotCount)
			{
				return false;
			}
			slotIndex = num4;
			return true;
		}

		public static bool IsEquipmentCell(Inventory inv, int x, int y, out int slotIndex)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetSlotIndexAtGridPos(inv, new Vector2i(x, y), out slotIndex))
			{
				return false;
			}
			if (TryGetSlotDescriptor(slotIndex, out var desc))
			{
				return desc.IsEquipmentSlot;
			}
			return false;
		}

		public static bool IsQuickCell(Inventory inv, int x, int y, out int slotIndex)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetSlotIndexAtGridPos(inv, new Vector2i(x, y), out slotIndex))
			{
				return false;
			}
			if (TryGetSlotDescriptor(slotIndex, out var desc))
			{
				return desc.IsQuickSlot;
			}
			return false;
		}

		public static bool TryGetSlotSnapshot(Inventory inv, int slotIndex, out SlotSnapshot snapshot)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			snapshot = default(SlotSnapshot);
			if (inv == null)
			{
				return false;
			}
			if (!TryGetSlotDescriptor(slotIndex, out var desc))
			{
				return false;
			}
			bool occupied = ExtendedPlayerInventory.slots[slotIndex]?.Occupied ?? false;
			Vector2i slotGridPos = GetSlotGridPos(inv, slotIndex);
			int slotGridLinearIndex = GetSlotGridLinearIndex(inv, slotIndex);
			snapshot = new SlotSnapshot(desc, occupied, slotGridPos, slotGridLinearIndex);
			return true;
		}

		public static IEnumerable<SlotDescriptor> EnumerateSlots()
		{
			int count = GetSlotCount();
			int i = 0;
			while (i < count)
			{
				if (TryGetSlotDescriptor(i, out var desc))
				{
					yield return desc;
				}
				int num = i + 1;
				i = num;
			}
		}

		public static IEnumerable<SlotSnapshot> GetAllSlotSnapshots(Inventory inv)
		{
			int count = GetSlotCount();
			int i = 0;
			while (i < count)
			{
				if (TryGetSlotSnapshot(inv, i, out var snapshot))
				{
					yield return snapshot;
				}
				int num = i + 1;
				i = num;
			}
		}

		public static IEnumerable<SlotSnapshot> GetQuickSlotSnapshots(Inventory inv)
		{
			foreach (SlotSnapshot allSlotSnapshot in GetAllSlotSnapshots(inv))
			{
				if (allSlotSnapshot.Descriptor.IsQuickSlot)
				{
					yield return allSlotSnapshot;
				}
			}
		}

		public static IEnumerable<SlotSnapshot> GetEquipmentSlotSnapshots(Inventory inv)
		{
			foreach (SlotSnapshot allSlotSnapshot in GetAllSlotSnapshots(inv))
			{
				if (allSlotSnapshot.Descriptor.IsEquipmentSlot)
				{
					yield return allSlotSnapshot;
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetSlotIndexByItem(Player player, ItemData item, out int slotIndex)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			slotIndex = -1;
			if (!Object.op_Implicit((Object)(object)player) || item == null)
			{
				return false;
			}
			int slotCount = GetSlotCount();
			for (int i = 0; i < slotCount; i++)
			{
				if (TryGetSlotDescriptor(i, out var desc) && desc.IsEquipmentSlot && TryGetEquippedItem(i, out ItemData item2) && item2 == item)
				{
					slotIndex = i;
					return true;
				}
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			foreach (SlotSnapshot quickSlotSnapshot in GetQuickSlotSnapshots(inventory))
			{
				if (inventory.GetItemAt(quickSlotSnapshot.GridPos.x, quickSlotSnapshot.GridPos.y) == item)
				{
					slotIndex = quickSlotSnapshot.Descriptor.Index;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetSlotIndexByItem(ItemData item, out int slotIndex)
		{
			return TryGetSlotIndexByItem(Player.m_localPlayer, item, out slotIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetSlotDescriptorByItem(Player player, ItemData item, out SlotDescriptor desc)
		{
			desc = default(SlotDescriptor);
			if (!TryGetSlotIndexByItem(player, item, out var slotIndex))
			{
				return false;
			}
			return TryGetSlotDescriptor(slotIndex, out desc);
		}

		public static bool SlotValidates(int slotIndex, ItemData item)
		{
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			if ((uint)slotIndex >= (uint)slots.Count)
			{
				return false;
			}
			if (slots[slotIndex] is Model.EquipmentSlot equipmentSlot)
			{
				if (equipmentSlot.Valid == null)
				{
					return false;
				}
				try
				{
					return equipmentSlot.Valid(item);
				}
				catch
				{
					return false;
				}
			}
			Model.Slot slot = slots[slotIndex];
			if (slot != null && slot.IsQuickSlot)
			{
				return true;
			}
			return false;
		}

		public static bool TryGetEquippedItem(int slotIndex, out ItemData? item)
		{
			item = null;
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			if ((uint)slotIndex >= (uint)slots.Count)
			{
				return false;
			}
			if (slots[slotIndex] is Model.EquipmentSlot equipmentSlot)
			{
				try
				{
					item = equipmentSlot.Get?.Invoke(Player.m_localPlayer);
					return item != null;
				}
				catch
				{
					item = null;
					return false;
				}
			}
			return false;
		}

		public static bool TryGetSlotDescriptorByName(string slotName, out SlotDescriptor desc, bool allowLocalized = true)
		{
			desc = default(SlotDescriptor);
			if (!TryGetSlotIndexByName(slotName, out var index, allowLocalized))
			{
				return false;
			}
			return TryGetSlotDescriptor(index, out desc);
		}

		private static void RegisterVisualsForSlot(string slotName, params string[] prefabNames)
		{
			if (string.IsNullOrWhiteSpace(slotName) || prefabNames == null)
			{
				return;
			}
			foreach (string item in prefabNames.Where((string s) => !string.IsNullOrWhiteSpace(s)))
			{
				CustomEquipVisuals.Register(item);
				CustomEquipVisuals.RegisterForSlot(item, slotName);
				try
				{
					API.OnRegisterVisualPrefab?.Invoke(item);
				}
				catch
				{
				}
			}
		}

		private static void ComposeOntoSlot(Model.EquipmentSlot slot, Func<ItemData, bool> isValid, Func<Player, ItemData?> getItem)
		{
			Func<ItemData, bool> originalValid = slot.Valid;
			Func<Player, ItemData?> originalGet = slot.Get;
			slot.Valid = delegate(ItemData item)
			{
				try
				{
					Func<ItemData, bool> func = originalValid;
					if (func != null && func(item))
					{
						return true;
					}
				}
				catch
				{
				}
				try
				{
					return isValid(item);
				}
				catch
				{
					return false;
				}
			};
			slot.Get = delegate(Player player)
			{
				try
				{
					ItemData val = originalGet?.Invoke(player);
					if (val != null)
					{
						return val;
					}
				}
				catch
				{
				}
				try
				{
					return getItem(player);
				}
				catch
				{
					return (ItemData?)null;
				}
			};
		}

		internal static bool IsCustomSlot(Model.EquipmentSlot? slot)
		{
			return CustomSlots.Contains(slot);
		}

		public static bool IsCustomSlot(SlotDescriptor d)
		{
			return d.IsCustom;
		}

		public static bool IsQuickSlot(SlotDescriptor d)
		{
			return d.IsQuickSlot;
		}

		public static bool IsEquipmentSlot(SlotDescriptor d)
		{
			return d.IsEquipmentSlot;
		}

		public static void HudAwake(Hud __instance)
		{
			API.OnHudAwake?.Invoke(__instance);
		}

		public static void HudAwakeComplete(Hud __instance)
		{
			API.OnHudAwakeComplete?.Invoke(__instance);
		}

		public static void HudUpdate(Hud __instance)
		{
			API.OnHudUpdate?.Invoke(__instance);
		}

		public static void HudUpdateComplete(Hud __instance)
		{
			API.OnHudUpdateComplete?.Invoke(__instance);
		}

		public static void BeforeQuickSlotsAdded()
		{
			API.OnBeforeQuickSlotsAdded?.Invoke();
		}

		public static void QuickSlotsAdded()
		{
			API.OnQuickSlotsAdded?.Invoke();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryGetModelSlot(int slotIndex, out Model.Slot? slot)
		{
			slot = null;
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			if ((uint)slotIndex >= (uint)slots.Count)
			{
				return false;
			}
			slot = slots[slotIndex];
			return slot != null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryGetEquipmentModelSlot(int slotIndex, out Model.EquipmentSlot? equipmentSlot)
		{
			equipmentSlot = null;
			if (!TryGetModelSlot(slotIndex, out Model.Slot slot))
			{
				return false;
			}
			equipmentSlot = slot as Model.EquipmentSlot;
			return equipmentSlot != null;
		}

		internal static bool TryGetModelSlotByName(string slotName, out Model.Slot? slot, bool allowLocalized = true)
		{
			slot = null;
			if (!TryGetSlotIndexByName(slotName, out var index, allowLocalized))
			{
				return false;
			}
			return TryGetModelSlot(index, out slot);
		}

		internal static bool TryGetModelSlotByItem(Player player, ItemData item, out Model.Slot? slot)
		{
			slot = null;
			if (!TryGetSlotIndexByItem(player, item, out var slotIndex))
			{
				return false;
			}
			return TryGetModelSlot(slotIndex, out slot);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryGetModelSlotByItem(ItemData item, out Model.Slot? slot)
		{
			return TryGetModelSlotByItem(Player.m_localPlayer, item, out slot);
		}

		internal static bool TryGetModelSlotAtGridPos(Inventory inv, Vector2i gridPos, out Model.Slot? slot)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			slot = null;
			if (!TryGetSlotIndexAtGridPos(inv, gridPos, out var slotIndex))
			{
				return false;
			}
			return TryGetModelSlot(slotIndex, out slot);
		}

		internal static Model.Slot?[] GetModelSlotsSnapshot()
		{
			return ExtendedPlayerInventory.slots.ToArray();
		}

		internal static IEnumerable<Model.Slot?> EnumerateModelSlots()
		{
			List<Model.Slot?> slots = ExtendedPlayerInventory.slots;
			int i = 0;
			while (i < slots.Count)
			{
				yield return slots[i];
				int num = i + 1;
				i = num;
			}
		}

		internal static void UpdateSlots(int index, int shift)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).m_inventory;
			int width = inventory.GetWidth();
			int num = 4 + AzuExtendedPlayerInventoryPlugin.ExtraRows.Value;
			foreach (ItemData item in inventory.m_inventory)
			{
				if ((item.m_gridPos.y - num) * width + item.m_gridPos.x >= index)
				{
					_ = item.m_gridPos;
					item.m_gridPos.x += shift;
					if (item.m_gridPos.x < 0)
					{
						item.m_gridPos.x = width - 1;
						item.m_gridPos.y--;
					}
					if (item.m_gridPos.x >= width)
					{
						item.m_gridPos.x = 0;
						item.m_gridPos.y++;
					}
				}
			}
			inventory.m_height = num + Mathf.CeilToInt((float)(ExtendedPlayerInventory.slots.Count + shift) / (float)width);
		}

		internal static void RelocalizeSlots()
		{
			if (Localization.m_instance == null)
			{
				return;
			}
			List<string> builtInSlotNames = AzuExtendedPlayerInventoryPlugin.GetBuiltInSlotNames();
			foreach (Model.Slot slot in ExtendedPlayerInventory.slots)
			{
				if (slot == null || string.IsNullOrWhiteSpace(slot.OriginalName) || !slot.OriginalName.StartsWith("$", StringComparison.Ordinal))
				{
					continue;
				}
				bool flag = builtInSlotNames.Contains(slot.OriginalName);
				string text = Localization.m_instance.Localize(slot.OriginalName);
				if (slot.Name == text && !flag)
				{
					continue;
				}
				if (flag)
				{
					switch (slot.OriginalName)
					{
					case "$azu_epi_helmet":
						slot.Name = (string.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.HelmetText.Value) ? text : (AzuExtendedPlayerInventoryPlugin.HelmetText.Value.StartsWith("$", StringComparison.Ordinal) ? Localization.m_instance.Localize(AzuExtendedPlayerInventoryPlugin.HelmetText.Value) : AzuExtendedPlayerInventoryPlugin.HelmetText.Value));
						break;
					case "$azu_epi_chest":
						slot.Name = (string.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.ChestText.Value) ? text : (AzuExtendedPlayerInventoryPlugin.ChestText.Value.StartsWith("$", StringComparison.Ordinal) ? Localization.m_instance.Localize(AzuExtendedPlayerInventoryPlugin.ChestText.Value) : AzuExtendedPlayerInventoryPlugin.ChestText.Value));
						break;
					case "$azu_epi_legs":
						slot.Name = (string.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.LegsText.Value) ? text : (AzuExtendedPlayerInventoryPlugin.LegsText.Value.StartsWith("$", StringComparison.Ordinal) ? Localization.m_instance.Localize(AzuExtendedPlayerInventoryPlugin.LegsText.Value) : AzuExtendedPlayerInventoryPlugin.LegsText.Value));
						break;
					case "$azu_epi_shoulder":
						slot.Name = (string.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.BackText.Value) ? text : (AzuExtendedPlayerInventoryPlugin.BackText.Value.StartsWith("$", StringComparison.Ordinal) ? Localization.m_instance.Localize(AzuExtendedPlayerInventoryPlugin.BackText.Value) : AzuExtendedPlayerInventoryPlugin.BackText.Value));
						break;
					case "$azu_epi_utility":
						slot.Name = (string.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.UtilityText.Value) ? text : (AzuExtendedPlayerInventoryPlugin.UtilityText.Value.StartsWith("$", StringComparison.Ordinal) ? Localization.m_instance.Localize(AzuExtendedPlayerInventoryPlugin.UtilityText.Value) : AzuExtendedPlayerInventoryPlugin.UtilityText.Value));
						break;
					case "$azu_epi_trinket":
						slot.Name = (string.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.TrinketText.Value) ? text : (AzuExtendedPlayerInventoryPlugin.TrinketText.Value.StartsWith("$", StringComparison.Ordinal) ? Localization.m_instance.Localize(AzuExtendedPlayerInventoryPlugin.TrinketText.Value) : AzuExtendedPlayerInventoryPlugin.TrinketText.Value));
						break;
					default:
						slot.Name = text;
						break;
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Relocalizing slot '" + slot.Name + "' to '" + text + "' from key '" + slot.OriginalName + "'"));
				}
				else
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Relocalizing slot '" + slot.Name + "' to '" + text + "' from key '" + slot.OriginalName + "'"));
					slot.Name = text;
				}
			}
		}
	}
	[PublicAPI]
	public class SlotInfo
	{
		public string[] SlotNames { get; set; } = Array.Empty<string>();

		public string[] OriginalSlotNames { get; set; } = Array.Empty<string>();

		public Vector2[] SlotPositions { get; set; } = Array.Empty<Vector2>();

		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = Array.Empty<Func<Player, ItemData>>();

		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = Array.Empty<Func<ItemData, bool>>();
	}
	[PublicAPI]
	public struct SlotDescriptor
	{
		public int Index { get; }

		public string Name { get; }

		public string OriginalName { get; }

		public bool IsQuickSlot { get; }

		public bool IsEquipmentSlot { get; }

		public bool IsCustom { get; }

		public Vector2 UiPosition { get; }

		public SlotDescriptor(int index, string name, string originalName, bool isQuickSlot, bool isEquipmentSlot, bool isCustom, Vector2 uiPosition)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Index = index;
			Name = name ?? string.Empty;
			OriginalName = originalName ?? string.Empty;
			IsQuickSlot = isQuickSlot;
			IsEquipmentSlot = isEquipmentSlot;
			IsCustom = isCustom;
			UiPosition = uiPosition;
		}
	}
	[PublicAPI]
	public struct SlotSnapshot
	{
		public SlotDescriptor Descriptor { get; }

		public bool Occupied { get; }

		public Vector2i GridPos { get; }

		public int LinearGridIndex { get; }

		public SlotSnapshot(SlotDescriptor descriptor, bool occupied, Vector2i gridPos, int linearGridIndex)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Descriptor = descriptor;
			Occupied = occupied;
			GridPos = gridPos;
			LinearGridIndex = linearGridIndex;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Validates(ItemData item)
		{
			return API.SlotValidates(Descriptor.Index, item);
		}
	}
}
namespace AzuEPI.Game.Slots
{
	internal static class SlotBackupManager
	{
		private class SlotBackup
		{
			public Model.EquipmentSlot Slot { get; set; }

			public int OriginalIndex { get; set; }
		}

		internal static readonly HashSet<string> _userConfigSlotNames = new HashSet<string>();

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

		internal static void InitializeBuiltInSlotBackups()
		{
			foreach (Model.Slot slot in ExtendedPlayerInventory.slots)
			{
				if (slot is Model.EquipmentSlot { IsQuickSlot: false } equipmentSlot)
				{
					BackupSlot(equipmentSlot);
				}
			}
		}

		public static void BackupSlot(Model.EquipmentSlot slot)
		{
			string text = (string.IsNullOrWhiteSpace(slot.OriginalName) ? slot.Name : slot.OriginalName);
			if (!_slotBackups.ContainsKey(text))
			{
				int num = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s == slot);
				_slotBackups[text] = new SlotBackup
				{
					OriginalIndex = num,
					Slot = new Model.EquipmentSlot
					{
						Name = slot.Name,
						OriginalName = slot.OriginalName,
						Get = slot.Get,
						Valid = slot.Valid,
						IsAPIAdded = slot.IsAPIAdded,
						IsQuickSlot = slot.IsQuickSlot
					}
				};
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Created backup for slot '{text}' at index {num}");
			}
		}

		public static bool RestoreSlotFromBackup(string slotKey)
		{
			if (!_slotBackups.TryGetValue(slotKey, out SlotBackup value))
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("No backup found for slot '" + slotKey + "'"));
				return false;
			}
			Model.EquipmentSlot slot = value.Slot;
			if (API.TryGetSlotIndexByName(slot.Name, out var index, allowLocalized: false) || (!string.IsNullOrWhiteSpace(slot.OriginalName) && API.TryGetSlotIndexByName(slot.OriginalName, out index, allowLocalized: false)))
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Slot '" + slotKey + "' already exists, skipping restore"));
				return false;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"Restoring slot '{slotKey}' from backup to index {value.OriginalIndex}");
			Model.EquipmentSlot equipmentSlot = RecreateSlotWithDelegates(slot);
			int val = ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			int index2 = Math.Max(0, Math.Min(value.OriginalIndex, val));
			API.UpdateSlots(index2, 1);
			ExtendedPlayerInventory.slots.Insert(index2, equipmentSlot);
			if (equipmentSlot.IsAPIAdded)
			{
				API.CustomSlots.Add(equipmentSlot);
			}
			SlotHelpers.ResizeSlots();
			SlotHelpers.UpdateEquipmentBackgroundAnchors();
			return true;
		}

		public static IEnumerable<string> GetBackupKeys()
		{
			return _slotBackups.Keys.ToList();
		}

		private static Model.EquipmentSlot RecreateSlotWithDelegates(Model.EquipmentSlot slotData)
		{
			return new Model.EquipmentSlot
			{
				Name = slotData.Name,
				OriginalName = slotData.OriginalName,
				IsAPIAdded = slotData.IsAPIAdded,
				IsQuickSlot = slotData.IsQuickSlot,
				Get = slotData.Get,
				Valid = slotData.Valid
			};
		}
	}
}
namespace AzuEPI.Game.Slots.QAB
{
	public class HudPatches
	{
		[HarmonyPatch(typeof(Hud), "Awake")]
		private static class HudAwakePatch
		{
			private static void Postfix(Hud __instance)
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff())
				{
					return;
				}
				API.HudAwake(__instance);
				Transform val = __instance.m_rootObject.transform.Find("HotKeyBar");
				if (Object.op_Implicit((Object)(object)val))
				{
					RectTransform val2 = default(RectTransform);
					((Component)val).TryGetComponent<RectTransform>(ref val2);
					if (Object.op_Implicit((Object)(object)val2))
					{
						RectTransform obj = Object.Instantiate<RectTransform>(val2, __instance.m_rootObject.transform, true);
						((Object)obj).name = "AzuEPI_QuickAccessBar";
						((Transform)obj).localPosition = Vector3.zero;
						((Transform)obj).SetSiblingIndex(((Transform)val2).GetSiblingIndex() + 1);
					}
				}
				API.HudAwakeComplete(__instance);
			}
		}

		[HarmonyPatch(typeof(Hud), "Update")]
		private static class HudUpdatePatch
		{
			private static Transform _cachedHudrootTransform;

			private static Transform _cachedQuickAccessBarTransform;

			private static RectTransform _cachedQuickAccessBarRect;

			private static void Postfix(Hud __instance)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_021e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
				if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				API.HudUpdate(__instance);
				float largeGuiScale = GuiScaler.m_largeGuiScale;
				Vector3 mousePosition = Input.mousePosition;
				QuickAccessBar.SetElementPositions();
				if (ExtendedPlayerInventory.lastMousePos == Vector3.zero)
				{
					ExtendedPlayerInventory.lastMousePos = mousePosition;
				}
				if ((Object)(object)_cachedHudrootTransform == (Object)null)
				{
					_cachedHudrootTransform = ((Component)Hud.instance).transform.Find("hudroot");
				}
				if ((Object)(object)_cachedQuickAccessBarTransform == (Object)null)
				{
					_cachedQuickAccessBarTransform = _cachedHudrootTransform.Find("AzuEPI_QuickAccessBar");
				}
				if ((Object)(object)_cachedQuickAccessBarRect == (Object)null && (Object)(object)_cachedQuickAccessBarTransform != (Object)null)
				{
					_cachedQuickAccessBarRect = ((Component)_cachedQuickAccessBarTransform).GetComponent<RectTransform>();
				}
				if (InventoryGui.IsVisible())
				{
					return;
				}
				KeyboardShortcut value = AzuExtendedPlayerInventoryPlugin.QuickslotDragKeys.Value;
				if (((KeyboardShortcut)(ref value)).IsPressed() && (Object)(object)_cachedQuickAccessBarTransform != (Object)null)
				{
					RectTransform cachedQuickAccessBarRect = _cachedQuickAccessBarRect;
					Vector2 anchoredPosition = cachedQuickAccessBarRect.anchoredPosition;
					Vector2 sizeDelta = cachedQuickAccessBarRect.sizeDelta;
					float value2 = AzuExtendedPlayerInventoryPlugin.QuickAccessScale.Value;
					Rect val = default(Rect);
					((Rect)(ref val))..ctor(anchoredPosition.x * largeGuiScale, anchoredPosition.y * largeGuiScale + (float)Screen.height - sizeDelta.y * largeGuiScale * value2, (float)((double)(sizeDelta.x * largeGuiScale * value2) * 0.375), sizeDelta.y * largeGuiScale * value2);
					bool flag = ((Rect)(ref val)).Contains(ExtendedPlayerInventory.lastMousePos);
					if (flag)
					{
						string currentlyDragging = ExtendedPlayerInventory.currentlyDragging;
						bool flag2 = (((currentlyDragging != null && currentlyDragging.Length == 0) || currentlyDragging == "AzuEPI_QuickAccessBar") ? true : false);
						flag = flag2;
					}
					if (flag)
					{
						float num = (mousePosition.x - ExtendedPlayerInventory.lastMousePos.x) / largeGuiScale;
						float num2 = (mousePosition.y - ExtendedPlayerInventory.lastMousePos.y) / largeGuiScale;
						AzuExtendedPlayerInventoryPlugin.QuickAccessLocation.Value = new Vector2(AzuExtendedPlayerInventoryPlugin.QuickAccessLocation.Value.x + num, AzuExtendedPlayerInventoryPlugin.QuickAccessLocation.Value.y + num2);
						ExtendedPlayerInventory.currentlyDragging = "AzuEPI_QuickAccessBar";
					}
					else
					{
						ExtendedPlayerInventory.currentlyDragging = "";
					}
				}
				else
				{
					ExtendedPlayerInventory.currentlyDragging = "";
				}
				ExtendedPlayerInventory.lastMousePos = mousePosition;
				API.HudUpdateComplete(__instance);
			}
		}

		[HarmonyPatch(typeof(MessageHud), "Awake")]
		private static class LowerTopLeftMessageMessageHudAwakePatch
		{
			private static void Postfix(MessageHud __instance)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				RectTransform val = default(RectTransform);
				if (((Component)__instance.m_messageText.transform.parent).TryGetComponent<RectTransform>(ref val))
				{
					RectTransform obj = val;
					obj.anchoredPosition += new Vector2(0f, -75f);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class SettingsMenuClosedRecentlyPatchs
	{
		[HarmonyPatch(typeof(Settings), "OnDestroy")]
		[HarmonyPatch(typeof(Settings), "OnOk")]
		[HarmonyPatch(typeof(Settings), "OnBack")]
		private static void Postfix(Settings __instance)
		{
			QuickAccessBar.SettingsMenuClosedRecently = true;
		}
	}
	[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
	internal static class QuickAccessBar
	{
		internal static bool SettingsMenuClosedRecently;

		[HarmonyPriority(0)]
		internal static bool Prefix(HotkeyBar __instance, Player player)
		{
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)__instance).name != "AzuEPI_QuickAccessBar")
			{
				return true;
			}
			if (AzuExtendedPlayerInventoryPlugin.ShowQuickSlots.Value.isOff())
			{
				ClearElements(__instance);
				return false;
			}
			if (!Object.op_Implicit((Object)(object)player) || ((Character)player).IsDead())
			{
				ClearElements(__instance);
			}
			else
			{
				if (SettingsMenuClosedRecently)
				{
					ClearElements(__instance);
					SettingsMenuClosedRecently = false;
				}
				__instance.m_items.Clear();
				Inventory inventory = ((Humanoid)player).GetInventory();
				int width = inventory.GetWidth();
				int num = (inventory.GetHeight() - API.GetAddedRows(width)) * width + ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
				for (int i = 0; i < AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value; i++)
				{
					int num2 = num + i;
					ItemData itemAt = inventory.GetItemAt(num2 % width, num2 / width);
					if (itemAt != null)
					{
						__instance.m_items.Add(itemAt);
					}
				}
				__instance.m_items.Sort((ItemData x, ItemData y) => (x.m_gridPos.x + x.m_gridPos.y * width).CompareTo(y.m_gridPos.x + y.m_gridPos.y * width));
				int num3 = 0;
				if (AzuExtendedPlayerInventoryPlugin.AlwaysShowQuickSlotsInUI.Value.isOn())
				{
					num3 = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
				}
				else
				{
					for (int num4 = 0; num4 < __instance.m_items.Count; num4++)
					{
						int num5 = __instance.m_items[num4].m_gridPos.x + __instance.m_items[num4].m_gridPos.y * width - num + 1;
						if (num5 > num3)
						{
							num3 = num5;
						}
					}
				}
				if (__instance.m_elements.Count != num3)
				{
					foreach (ElementData element in __instance.m_elements)
					{
						Object.Destroy((Object)(object)element.m_go);
					}
					__instance.m_elements.Clear();
					for (int num6 = 0; num6 < num3; num6++)
					{
						ElementData val = new ElementData
						{
							m_go = Object.Instantiate<GameObject>(__instance.m_elementPrefab, ((Component)__instance).transform)
						};
						int num7 = Mathf.Max(1, AzuExtendedPlayerInventoryPlugin.QuickSlotsPerRow.Value);
						int num8 = num6 % num7;
						int num9 = num6 / num7;
						val.m_go.transform.localPosition = new Vector3((float)num8 * __instance.m_elementSpace, (float)(-num9) * __instance.m_elementSpace, 0f);
						if (num6 < AzuExtendedPlayerInventoryPlugin.HotkeyTexts.Length && num6 < AzuExtendedPlayerInventoryPlugin.Hotkeys.Length)
						{
							SlotText.Set(Utility.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.HotkeyTexts[num6].Value) ? ((object)AzuExtendedPlayerInventoryPlugin.Hotkeys[num6].Value/*cast due to .constrained prefix*/).ToString() : AzuExtendedPlayerInventoryPlugin.HotkeyTexts[num6].Value, val.m_go.transform);
						}
						val.m_icon = ((Component)((Component)val.m_go.transform).transform.Find("icon")).GetComponent<Image>();
						val.m_durability = ((Component)val.m_go.transform.Find("durability")).GetComponent<GuiBar>();
						val.m_amount = ((Component)val.m_go.transform.Find("amount")).GetComponent<TMP_Text>();
						val.m_equiped = ((Component)val.m_go.transform.Find("equiped")).gameObject;
						val.m_queued = ((Component)val.m_go.transform.Find("queued")).gameObject;
						val.m_selection = ((Component)val.m_go.transform.Find("selected")).gameObject;
						__instance.m_elements.Add(val);
					}
				}
				foreach (ElementData element2 in __instance.m_elements)
				{
					element2.m_used = false;
				}
				bool flag = ZInput.IsGamepadActive();
				foreach (ItemData item in __instance.m_items)
				{
					int num10 = item.m_gridPos.x + item.m_gridPos.y * width - num;
					if (num10 < 0 || num10 >= __instance.m_elements.Count)
					{
						continue;
					}
					ElementData val2 = __instance.m_elements[num10];
					val2.m_used = true;
					((Component)val2.m_icon).gameObject.SetActive(true);
					val2.m_icon.sprite = item.GetIcon();
					bool flag2 = item.m_shared.m_useDurability && (double)item.m_durability < (double)item.GetMaxDurability();
					((Component)val2.m_durability).gameObject.SetActive(flag2);
					if (item.m_shared.m_useDurability && flag2)
					{
						if ((double)item.m_durability <= 0.0)
						{
							val2.m_durability.SetValue(1f);
							val2.m_durability.SetColor((Color)(((double)Mathf.Sin(Time.time * 10f) > 0.0) ? Color.red : new Color(0f, 0f, 0f, 0f)));
						}
						else
						{
							val2.m_durability.SetValue(item.GetDurabilityPercentage());
							val2.m_durability.ResetColor();
						}
					}
					val2.m_equiped.SetActive(item.m_equipped);
					val2.m_queued.SetActive(false);
					InventoryGridQueuedFillPatch.UpdateFillOverlay(val2.m_queued, null, player, item);
					if (item.m_shared.m_maxStackSize > 1)
					{
						((Component)val2.m_amount).gameObject.SetActive(true);
						if (val2.m_stackText != item.m_stack)
						{
							val2.m_amount.text = (AzuExtendedPlayerInventoryPlugin.WbInstalled ? Formatting.FormatNumberSimpleNoDecimal(item.m_stack) : $"{item.m_stack} / {item.m_shared.m_maxStackSize}");
							val2.m_stackText = item.m_stack;
						}
					}
					else
					{
						((Component)val2.m_amount).gameObject.SetActive(false);
					}
				}
				for (int num11 = 0; num11 < __instance.m_elements.Count; num11++)
				{
					ElementData val3 = __instance.m_elements[num11];
					val3.m_selection.SetActive(flag && num11 == __instance.m_selected);
					if (!val3.m_used)
					{
						((Component)val3.m_icon).gameObject.SetActive(false);
						((Component)val3.m_durability).gameObject.SetActive(false);
						val3.m_equiped.SetActive(false);
						val3.m_queued.SetActive(false);
						InventoryGridQueuedFillPatch.UpdateFillOverlay(val3.m_queued, null, player, null);
						((Component)val3.m_amount).gameObject.SetActive(false);
					}
				}
			}
			return false;
		}

		private static void ClearElements(HotkeyBar __instance, bool destroy = true)
		{
			foreach (ElementData element in __instance.m_elements)
			{
				if (destroy)
				{
					Object.Destroy((Object)(object)element.m_go);
					continue;
				}
				((Component)element.m_icon).gameObject.SetActive(false);
				((Component)element.m_durability).gameObject.SetActive(false);
				element.m_equiped.SetActive(false);
				element.m_queued.SetActive(false);
				((Component)element.m_amount).gameObject.SetActive(false);
			}
			if (destroy)
			{
				InventoryGridQueuedFillPatch.ClearCache();
			}
			__instance.m_elements.Clear();
		}

		public static void ForceRefresh()
		{
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				Transform obj = ((Component)Hud.instance).transform.Find("hudroot");
				object obj2;
				if (obj == null)
				{
					obj2 = null;
				}
				else
				{
					Transform obj3 = obj.Find("AzuEPI_QuickAccessBar");
					obj2 = ((obj3 != null) ? ((Component)obj3).GetComponent<HotkeyBar>() : null);
				}
				HotkeyBar val = (HotkeyBar)obj2;
				if ((Object)(object)val != (Object)null)
				{
					ClearElements(val);
				}
			}
		}

		public static void SetElementPositions()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)Hud.instance).transform.Find("hudroot");
			Transform obj = val.Find("AzuEPI_QuickAccessBar");
			if ((Object)(object)((obj != null) ? ((Component)obj).GetComponent<RectTransform>() : null) != (Object)null)
			{
				RectTransform component = ((Component)Hud.instance.m_healthPanel).GetComponent<RectTransform>();
				if (AzuExtendedPlayerInventoryPlugin.QuickAccessLocation.Value == Vector2.one)
				{
					AzuExtendedPlayerInventoryPlugin.QuickAccessLocation.Value = new Vector2(component.anchoredPosition.x - 2.5f, component.anchoredPosition.y - 380.87f);
				}
				((Component)val.Find("AzuEPI_QuickAccessBar")).GetComponent<RectTransform>().anchoredPosition = AzuExtendedPlayerInventoryPlugin.QuickAccessLocation.Value;
				((Transform)((Component)val.Find("AzuEPI_QuickAccessBar")).GetComponent<RectTransform>()).localScale = new Vector3(AzuExtendedPlayerInventoryPlugin.QuickAccessScale.Value, AzuExtendedPlayerInventoryPlugin.QuickAccessScale.Value, 1f);
			}
		}
	}
	public static class HotkeyBarController
	{
		[HarmonyPatch(typeof(Hud), "Update")]
		public static class Hud_Update_Patch
		{
			public static void Postfix(Hud __instance)
			{
				Player localPlayer = Player.m_localPlayer;
				if (ExtendedPlayerInventory.HotkeyBars == null)
				{
					try
					{
						ExtendedPlayerInventory.HotkeyBars = ((Component)((Component)__instance).transform.parent).GetComponentsInChildren<HotkeyBar>().ToList();
					}
					catch
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)("Failed to get hotkey bars from Hud. The parent transform may have changed. " + ((Object)((Component)__instance).transform.parent).name));
						return;
					}
				}
				if ((Object)(object)localPlayer != (Object)null)
				{
					if (IsValidHotkeyBarIndex())
					{
						HotkeyBar val = ExtendedPlayerInventory.HotkeyBars[ExtendedPlayerInventory.SelectedHotkeyBarIndex];
						if (val.m_elements == null || val.m_elements.Count == 0)
						{
							DeselectHotkeyBar();
							UpdateInitialHotkeyBarInput();
						}
						else
						{
							UpdateHotkeyBarInput(val);
						}
					}
					else
					{
						UpdateInitialHotkeyBarInput();
					}
				}
				bool flag = Time.frameCount % 2 == 0;
				foreach (HotkeyBar hotkeyBar in ExtendedPlayerInventory.HotkeyBars)
				{
					if ((Object)(object)hotkeyBar != (Object)null && hotkeyBar.m_elements != null)
					{
						ValidateHotkeyBarSelection(hotkeyBar);
						if (flag)
						{
							hotkeyBar.UpdateIcons(localPlayer);
						}
					}
				}
			}

			private static bool IsValidHotkeyBarIndex()
			{
				if (ExtendedPlayerInventory.SelectedHotkeyBarIndex >= 0)
				{
					return ExtendedPlayerInventory.SelectedHotkeyBarIndex < ExtendedPlayerInventory.HotkeyBars.Count;
				}
				return false;
			}

			private static void UpdateInitialHotkeyBarInput()
			{
				if (!ZInput.GetButtonDown("JoyDPadLeft") && !ZInput.GetButtonDown("JoyDPadRight"))
				{
					return;
				}
				for (int i = 0; i < ExtendedPlayerInventory.HotkeyBars.Count; i++)
				{
					if (ExtendedPlayerInventory.HotkeyBars[i].m_elements != null && ExtendedPlayerInventory.HotkeyBars[i].m_elements.Count > 0)
					{
						SelectHotkeyBar(i, fromRight: false);
						break;
					}
				}
			}

			public static void UpdateHotkeyBarInput(HotkeyBar hotkeyBar)
			{
				Player localPlayer = Player.m_localPlayer;
				if (hotkeyBar.m_selected >= 0 && (Object)(object)localPlayer != (Object)null && !InventoryGui.IsVisible() && !Menu.IsVisible() && !GameCamera.InFreeFly() && !Minimap.IsOpen() && !Hud.IsPieceSelectionVisible() && !StoreGui.IsVisible() && !Console.IsVisible() && !Chat.instance.HasFocus() && !PlayerCustomizaton.IsBarberGuiVisible() && !Hud.InRadial() && (Object)(object)localPlayer != (Object)null)
				{
					if (ZInput.GetButtonDown("JoyDPadLeft"))
					{
						if (hotkeyBar.m_selected == 0)
						{
							if (AzuExtendedPlayerInventoryPlugin.ShowQuickSlots.Value.isOn())
							{
								GotoHotkeyBar(ExtendedPlayerInventory.SelectedHotkeyBarIndex - 1, fromRight: true);
							}
							else if (hotkeyBar.m_elements.Count > 1)
							{
								hotkeyBar.m_selected = hotkeyBar.m_elements.Count - 1;
							}
						}
						else
						{
							hotkeyBar.m_selected--;
						}
					}
					else if (ZInput.GetButtonDown("JoyDPadRight"))
					{
						if (hotkeyBar.m_selected == hotkeyBar.m_elements.Count - 1)
						{
							if (AzuExtendedPlayerInventoryPlugin.ShowQuickSlots.Value.isOn())
							{
								GotoHotkeyBar(ExtendedPlayerInventory.SelectedHotkeyBarIndex + 1, fromRight: false);
							}
							else if (hotkeyBar.m_elements.Count > 1)
							{
								hotkeyBar.m_selected = 0;
							}
						}
						else
						{
							hotkeyBar.m_selected++;
						}
					}
					if (ZInput.GetButtonDown("JoyDPadUp") || ZInput.GetButtonDown("JoyHotbarUse"))
					{
						if (((Object)hotkeyBar).name == "AzuEPI_QuickAccessBar" && AzuExtendedPlayerInventoryPlugin.ShowQuickSlots.Value.isOn())
						{
							Inventory inventory = ((Humanoid)localPlayer).m_inventory;
							int width = inventory.GetWidth();
							int num = (inventory.GetHeight() - API.GetAddedRows(width)) * width + ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value + hotkeyBar.m_selected;
							ItemData itemAt = inventory.GetItemAt(num % width, num / width);
							if (itemAt != null)
							{
								((Humanoid)localPlayer).UseItem((Inventory)null, itemAt, false);
							}
						}
						else if (ZInput.GetButtonDown("JoyHotbarUse") && !ZInput.GetButton("JoyAltKeys"))
						{
							localPlayer.UseHotbarItem(hotkeyBar.m_selected + 1);
						}
					}
				}
				ValidateHotkeyBarSelection(hotkeyBar);
			}

			private static void ValidateHotkeyBarSelection(HotkeyBar hotkeyBar)
			{
				if (hotkeyBar.m_elements != null && hotkeyBar.m_selected > hotkeyBar.m_elements.Count - 1)
				{
					hotkeyBar.m_selected = Mathf.Max(0, hotkeyBar.m_elements.Count - 1);
				}
			}

			public static void GotoHotkeyBar(int newIndex, bool fromRight)
			{
				if (ExtendedPlayerInventory.HotkeyBars.Count == 0)
				{
					return;
				}
				int num = ((!fromRight) ? 1 : (-1));
				for (int i = 0; i < ExtendedPlayerInventory.HotkeyBars.Count; i++)
				{
					if (newIndex < 0)
					{
						newIndex = ExtendedPlayerInventory.HotkeyBars.Count - 1;
					}
					else if (newIndex >= ExtendedPlayerInventory.HotkeyBars.Count)
					{
						newIndex = 0;
					}
					if (ExtendedPlayerInventory.HotkeyBars[newIndex].m_elements != null && ExtendedPlayerInventory.HotkeyBars[newIndex].m_elements.Count > 0)
					{
						SelectHotkeyBar(newIndex, fromRight);
						break;
					}
					newIndex += num;
				}
			}

			public static void SelectHotkeyBar(int index, bool fromRight)
			{
				if (index < 0 || index >= ExtendedPlayerInventory.HotkeyBars.Count)
				{
					return;
				}
				ExtendedPlayerInventory.SelectedHotkeyBarIndex = index;
				for (int i = 0; i < ExtendedPlayerInventory.HotkeyBars.Count; i++)
				{
					HotkeyBar val = ExtendedPlayerInventory.HotkeyBars[i];
					if (i == index)
					{
						int num = val.m_elements?.Count ?? 0;
						val.m_selected = (fromRight ? Mathf.Max(0, num - 1) : 0);
					}
					else
					{
						val.m_selected = -1;
					}
				}
			}

			public static void DeselectHotkeyBar()
			{
				ExtendedPlayerInventory.SelectedHotkeyBarIndex = -1;
				foreach (HotkeyBar hotkeyBar in ExtendedPlayerInventory.HotkeyBars)
				{
					hotkeyBar.m_selected = -1;
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		public static class Hud_OnDestroy_Patch
		{
			public static void Postfix(Hud __instance)
			{
				ExtendedPlayerInventory.HotkeyBars = null;
				ExtendedPlayerInventory.SelectedHotkeyBarIndex = -1;
			}
		}
	}
	[HarmonyPatch(typeof(HotkeyBar), "Update")]
	public static class HotkeyBar_Update_Patch
	{
		public static bool Prefix(HotkeyBar __instance)
		{
			return false;
		}
	}
}
namespace AzuEPI.Game.PlayerPreview
{
	public class PlayerRotationController : MonoBehaviour, IDragHandler, IEventSystemHandler, IEndDragHandler, IScrollHandler
	{
		internal bool dragging;

		private Vector3 lastMousePosition;

		public float pitch;

		public float yaw;

		internal float zoom = -3f;

		public static PlayerRotationController instance;

		private void Awake()
		{
			instance = this;
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = AzuEPICharacterPanel.instance.render.rect;
			if (((Rect)(ref rect)).Contains(Vector2.op_Implicit(((Component)this).transform.InverseTransformPoint(ZInput.mousePosition))))
			{
				if (!dragging)
				{
					lastMousePosition = Input.mousePosition;
					dragging = true;
				}
				pitch = Mathf.Clamp(pitch + (lastMousePosition - Input.mousePosition).y, -80f, 80f);
				yaw -= (lastMousePosition - Input.mousePosition).x;
				((Component)AzuEPICharacterPanel.instance.cam).transform.rotation = Quaternion.AngleAxis(yaw, Vector3.up) * Quaternion.AngleAxis(pitch, Vector3.right);
				((Component)AzuEPICharacterPanel.instance.cam).transform.eulerAngles = new Vector3(((Component)AzuEPICharacterPanel.instance.cam).transform.eulerAngles.x, ((Component)AzuEPICharacterPanel.instance.cam).transform.eulerAngles.y, 0f);
				((Component)AzuEPICharacterPanel.instance.cam).transform.position = AzuEPICharacterPanel.instance.basePosition + ((Component)AzuEPICharacterPanel.instance.cam).transform.forward * zoom;
				lastMousePosition = Input.mousePosition;
			}
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			dragging = false;
		}

		public void OnScroll(PointerEventData eventData)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = AzuEPICharacterPanel.instance.render.rect;
			if (((Rect)(ref rect)).Contains(Vector2.op_Implicit(((Component)this).transform.InverseTransformPoint(ZInput.mousePosition))))
			{
				float axis = Input.GetAxis("Mouse ScrollWheel");
				if (axis != 0f)
				{
					zoom = Mathf.Clamp(zoom + axis * GameCamera.instance.m_zoomSens, -10f, -1f);
					((Component)AzuEPICharacterPanel.instance.cam).transform.position = AzuEPICharacterPanel.instance.basePosition + ((Component)AzuEPICharacterPanel.instance.cam).transform.forward * zoom;
				}
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	internal static class InventoryGuiHidePatch
	{
		private static void Postfix(InventoryGui __instance)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			PlayerRotationController.instance.pitch = 0f;
			PlayerRotationController.instance.yaw = 0f;
			PlayerRotationController.instance.zoom = -3f;
			PlayerRotationController.instance.dragging = false;
			if (Object.op_Implicit((Object)(object)AzuEPICharacterPanel.instance.cam))
			{
				((Component)AzuEPICharacterPanel.instance.cam).transform.rotation = Quaternion.Euler(0f, 0f, 0f);
				((Component)AzuEPICharacterPanel.instance.cam).transform.position = AzuEPICharacterPanel.instance.basePosition + ((Component)AzuEPICharacterPanel.instance.cam).transform.forward * PlayerRotationController.instance.zoom;
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Awake")]
	internal static class InitializePlayerPreviewInventoryGuiAwakePatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(InventoryGui __instance)
		{
			PlayerPreviewManager.InitializePlayerPreview();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Show")]
	internal static class ShowPlayerPreviewInventoryGuiShowPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(InventoryGui __instance)
		{
			PlayerPreviewManager.ShowPlayerPreview();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
	internal static class InventoryGuiOnDestroyPatch
	{
		private static void Prefix(InventoryGui __instance)
		{
			PlayerPreviewManager.DestroyPlayerPreview_All();
		}
	}
	[HarmonyPatch(typeof(Humanoid), "SetupAnimationState")]
	internal static class UpdatePlayerPreviewVisuals
	{
		private static void Postfix(Humanoid __instance)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && ((Character)__instance).IsPlayer() && (Object)(object)__instance == (Object)(object)Player.m_localPlayer && (Object)(object)AzuEPICharacterPanel.playerPreview != (Object)null)
			{
				PlayerPreviewManager.UpdatePlayerPreview(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	internal static class HidePlayerPreviewAndPanels
	{
		[HarmonyPriority(0)]
		private static void Postfix(InventoryGui __instance)
		{
			if (Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview))
			{
				AzuEPICharacterPanel.playerPreview.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)AzuEPICharacterPanel.instance?.cam))
			{
				((Behaviour)AzuEPICharacterPanel.instance.cam).enabled = false;
			}
			if (PersonalLoadoutGui.IsVisible())
			{
				PersonalLoadoutGui.Hide();
			}
			if (StatsPanelController.IsVisible())
			{
				StatsPanelController.Hide();
			}
			if (VanityPanelController.IsVisible())
			{
				VanityPanelController.SetVisible(visible: false);
			}
			PanelUtilities.HideCraftingElements(hide: false);
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
	internal static class PreviewInstantRefresh_VisEquipmentPatch
	{
		private static void Postfix(VisEquipment __instance)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Object)(object)__instance != (Object)(object)((Humanoid)Player.m_localPlayer).m_visEquipment) && !((Object)(object)AzuEPICharacterPanel.playerPreviewComp == (Object)null) && VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp))
			{
				PreviewLayerFix.ForceUILayer(((Humanoid)AzuEPICharacterPanel.playerPreviewComp).m_visEquipment);
				Camera val = AzuEPICharacterPanel.instance?.cam;
				if (Object.op_Implicit((Object)(object)val))
				{
					val.Render();
				}
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class PreviewInstantRefresh_EquipItem
	{
		private static void Postfix()
		{
			PlayerPreviewManager.TryRefresh();
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
	internal static class PreviewInstantRefresh_UnequipItem
	{
		private static void Postfix()
		{
			PlayerPreviewManager.TryRefresh();
		}
	}
	public class AzuEPICharacterPanel : MonoBehaviour, TextReceiver
	{
		public static AzuEPICharacterPanel instance;

		public RectTransform render;

		public RawImage renderRawImage;

		public Camera cam;

		public RenderTexture renderTexture;

		public readonly Vector3 basePosition = new Vector3(0f, -1000f, 1f);

		public static GameObject playerPreview;

		public static Player playerPreviewComp;

		public static TMP_Dropdown LoadoutDropdown;

		private void Awake()
		{
			instance = this;
		}

		public string GetText()
		{
			return string.Empty;
		}

		public void SetText(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Invalid loadout name.", 0, (Sprite)null, false);
			}
			else if (PersonalLoadoutGui.SaveLoadout(text))
			{
				List<string> availableLoadouts = PersonalLoadoutGui.GetAvailableLoadouts();
				LoadoutDropdown.value = availableLoadouts.Count;
				MessageHud.instance.ShowMessage((MessageType)2, "New loadout '" + text + "' created.", 0, (Sprite)null, false);
			}
			else
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Failed to create loadout '" + text + "'.", 0, (Sprite)null, false);
			}
		}
	}
	internal static class VECloneSync
	{
		private static int _lastStamp;

		public static void ResetStamp()
		{
			_lastStamp = 0;
		}

		public static bool MirrorFrom(Player srcPlayer, Player dstPreview)
		{
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)srcPlayer) || !Object.op_Implicit((Object)(object)dstPreview))
			{
				return false;
			}
			VisEquipment visEquipment = ((Humanoid)srcPlayer).m_visEquipment;
			VisEquipment visEquipment2 = ((Humanoid)dstPreview).m_visEquipment;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = visEquipment.m_shoulderItemVariant;
			int num6 = visEquipment.m_leftItemVariant;
			int num7 = visEquipment.m_leftBackItemVariant;
			ZDO val = (Object.op_Implicit((Object)(object)visEquipment.m_nview) ? visEquipment.m_nview.GetZDO() : null);
			int num8;
			int num9;
			int num10;
			int num11;
			int num12;
			int num13;
			int num14;
			int num15;
			if (val != null)
			{
				num8 = val.GetInt(ZDOVars.s_leftItem, 0);
				num9 = val.GetInt(ZDOVars.s_rightItem, 0);
				num10 = val.GetInt(ZDOVars.s_chestItem, 0);
				num11 = val.GetInt(ZDOVars.s_legItem, 0);
				num12 = val.GetInt(ZDOVars.s_helmetItem, 0);
				num13 = val.GetInt(ZDOVars.s_shoulderItem, 0);
				num14 = val.GetInt(ZDOVars.s_utilityItem, 0);
				num15 = val.GetInt(ZDOVars.s_trinketItem, 0);
				num = val.GetInt(ZDOVars.s_beardItem, 0);
				num2 = val.GetInt(ZDOVars.s_hairItem, 0);
				num3 = val.GetInt(ZDOVars.s_leftBackItem, 0);
				num4 = val.GetInt(ZDOVars.s_rightBackItem, 0);
				num5 = val.GetInt(ZDOVars.s_shoulderItemVariant, 0);
				num6 = val.GetInt(ZDOVars.s_leftItemVariant, 0);
				num7 = val.GetInt(ZDOVars.s_leftBackItemVariant, 0);
			}
			else
			{
				num8 = ((!string.IsNullOrEmpty(visEquipment.m_leftItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_leftItem) : 0);
				num9 = ((!string.IsNullOrEmpty(visEquipment.m_rightItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_rightItem) : 0);
				num10 = ((!string.IsNullOrEmpty(visEquipment.m_chestItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_chestItem) : 0);
				num11 = ((!string.IsNullOrEmpty(visEquipment.m_legItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_legItem) : 0);
				num12 = ((!string.IsNullOrEmpty(visEquipment.m_helmetItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_helmetItem) : 0);
				num13 = ((!string.IsNullOrEmpty(visEquipment.m_shoulderItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_shoulderItem) : 0);
				num14 = ((!string.IsNullOrEmpty(visEquipment.m_utilityItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_utilityItem) : 0);
				num15 = ((!string.IsNullOrEmpty(visEquipment.m_trinketItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_trinketItem) : 0);
				num = ((!string.IsNullOrEmpty(visEquipment.m_beardItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_beardItem) : 0);
				num2 = ((!string.IsNullOrEmpty(visEquipment.m_hairItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_hairItem) : 0);
				num3 = ((!string.IsNullOrEmpty(visEquipment.m_leftBackItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_leftBackItem) : 0);
				num4 = ((!string.IsNullOrEmpty(visEquipment.m_rightBackItem)) ? StringExtensionMethods.GetStableHashCode(visEquipment.m_rightBackItem) : 0);
			}
			int num16 = CombineHash(visEquipment.m_modelIndex, ((object)Unsafe.As<Vector3, Vector3>(ref visEquipment.m_skinColor)/*cast due to .constrained prefix*/).GetHashCode(), ((object)Unsafe.As<Vector3, Vector3>(ref visEquipment.m_hairColor)/*cast due to .constrained prefix*/).GetHashCode(), num8, num6, num9, num10, num11, num12, num13, num5, num14, num15, num, num2, num3, num4, num7);
			if (num16 == _lastStamp)
			{
				return false;
			}
			_lastStamp = num16;
			visEquipment2.SetRightItem(visEquipment.m_rightItem);
			visEquipment2.SetLeftItem(visEquipment.m_leftItem, visEquipment.m_leftItemVariant);
			visEquipment2.SetChestItem(visEquipment.m_chestItem);
			visEquipment2.SetLegItem(visEquipment.m_legItem);
			visEquipment2.SetHelmetItem(visEquipment.m_helmetItem);
			visEquipment2.SetShoulderItem(visEquipment.m_shoulderItem, visEquipment.m_shoulderItemVariant);
			visEquipment2.SetUtilityItem(visEquipment.m_utilityItem);
			visEquipment2.SetTrinketItem(visEquipment.m_trinketItem);
			visEquipment2.SetLeftBackItem(visEquipment.m_leftBackItem, visEquipment.m_leftBackItemVariant);
			visEquipment2.SetRightBackItem(visEquipment.m_rightBackItem);
			visEquipment2.SetBeardItem(visEquipment.m_beardItem);
			visEquipment2.SetHairItem(visEquipment.m_hairItem);
			visEquipment2.SetModel(visEquipment.m_modelIndex);
			visEquipment2.SetSkinColor(visEquipment.m_skinColor);
			visEquipment2.SetHairColor(visEquipment.m_hairColor);
			try
			{
				visEquipment2.UpdateVisuals();
				PreviewLayerFix.ForceUILayer(visEquipment2);
			}
			catch
			{
			}
			((Behaviour)visEquipment2).enabled = false;
			return true;
		}

		internal static int CombineHash(params int[] hashes)
		{
			int num = 17;
			foreach (int num2 in hashes)
			{
				num = num * 31 + num2;
			}
			return num;
		}
	}
	internal static class PreviewLayerFix
	{
		public static void ForceUILayer(VisEquipment ve)
		{
			int ui = LayerMask.NameToLayer("UI");
			Set(ve.m_leftItemInstance);
			Set(ve.m_rightItemInstance);
			Set(ve.m_helmetItemInstance);
			Set(ve.m_beardItemInstance);
			Set(ve.m_hairItemInstance);
			Set(ve.m_leftBackItemInstance);
			Set(ve.m_rightBackItemInstance);
			SetList(ve.m_chestItemInstances);
			SetList(ve.m_legItemInstances);
			SetList(ve.m_shoulderItemInstances);
			SetList(ve.m_utilityItemInstances);
			SetList(ve.m_trinketItemInstances);
			void Set(GameObject go)
			{
				if (Object.op_Implicit((Object)(object)go))
				{
					go.SetLayerForEntireHierarchy(ui);
				}
			}
			void SetList(List<GameObject> list)
			{
				if (list == null)
				{
					return;
				}
				foreach (GameObject item in list)
				{
					Set(item);
				}
			}
		}
	}
	public class PlayerPreviewManager
	{
		public static PlayerPreviewManager Instance { get; private set; }

		public AzuEPICharacterPanel CharacterPanel { get; set; }

		private PlayerPreviewManager()
		{
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new PlayerPreviewManager();
			}
			Instance.CharacterPanel = AzuEPICharacterPanel.instance;
		}

		public void UpdateRenderTexture()
		{
			//IL_002e: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			if (!((Object)(object)CharacterPanel == (Object)null) && !((Object)(object)CharacterPanel.render == (Object)null))
			{
				int num = Mathf.Max(2, Mathf.RoundToInt(CharacterPanel.render.sizeDelta.x));
				int num2 = Mathf.Max(2, Mathf.RoundToInt(CharacterPanel.render.sizeDelta.y));
				if ((Object)(object)CharacterPanel.renderTexture != (Object)null && (((Texture)CharacterPanel.renderTexture).width != num || ((Texture)CharacterPanel.renderTexture).height != num2))
				{
					CharacterPanel.renderTexture.Release();
					Object.Destroy((Object)(object)CharacterPanel.renderTexture);
					CharacterPanel.renderTexture = null;
				}
				if ((Object)(object)CharacterPanel.renderTexture == (Object)null)
				{
					CharacterPanel.renderTexture = new RenderTexture(num, num2, 16, (RenderTextureFormat)0);
					CharacterPanel.renderTexture.Create();
				}
				CharacterPanel.cam.targetTexture = CharacterPanel.renderTexture;
				CharacterPanel.renderRawImage.texture = (Texture)(object)CharacterPanel.renderTexture;
				CharacterPanel.cam.Render();
			}
		}

		internal static GameObject CreatePlayerPreview()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = ZNetScene.instance.GetPrefab("Player");
			ZNetView.m_forceDisableInit = true;
			GameObject clone = Object.Instantiate<GameObject>(prefab);
			Player component = clone.GetComponent<Player>();
			Player.s_players.Remove(component);
			clone.SetActive(false);
			clone.transform.SetPositionAndRotation(AzuEPICharacterPanel.instance.basePosition - Vector3.up, Quaternion.identity);
			DisableBehaviour<Player>();
			DisableBehaviour<PlayerController>();
			DisableBehaviour<ZNetView>();
			DisableBehaviour<ZSyncTransform>();
			DisableBehaviour<ZSyncAnimation>();
			DisableBehaviour<FootStep>();
			DisableBehaviour<Talker>();
			DisableBehaviour<Skills>();
			DisableBehaviour<FootStep>();
			DisableBehaviour<Container>();
			DisableBehaviour<CharacterAnimEvent>("Visual");
			ZNetView.m_forceDisableInit = false;
			Rigidbody component2 = clone.GetComponent<Rigidbody>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				component2.isKinematic = true;
			}
			clone.transform.rotation = Quaternion.LookRotation(-Vector3.forward, Vector3.up);
			clone.SetLayerForEntireHierarchy(LayerMask.NameToLayer("UI"));
			AzuEPICharacterPanel.playerPreview = clone;
			AzuEPICharacterPanel.playerPreviewComp = component;
			return clone;
			void DisableBehaviour<T>(string child = "") where T : notnull, Behaviour
			{
				object obj2;
				if (!string.IsNullOrEmpty(child))
				{
					Transform obj = clone.transform.Find(child);
					obj2 = ((obj != null) ? ((Component)obj).gameObject : null);
				}
				else
				{
					obj2 = clone;
				}
				GameObject val = (GameObject)obj2;
				if (!((Object)(object)val == (Object)null))
				{
					T component3 = val.GetComponent<T>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						((Behaviour)component3).enabled = false;
					}
				}
			}
		}

		internal static void InitializePlayerPreview()
		{
			if (Object.op_Implicit((Object)(object)ZNetScene.instance) && Object.op_Implicit((Object)(object)AzuEPICharacterPanel.instance))
			{
				if (!Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview))
				{
					AzuEPICharacterPanel.playerPreview = CreatePlayerPreview();
				}
				if (!Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreviewComp) && Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview))
				{
					AzuEPICharacterPanel.playerPreviewComp = AzuEPICharacterPanel.playerPreview.GetComponent<Player>();
				}
				if ((Object)(object)AzuEPICharacterPanel.instance?.cam == (Object)null)
				{
					Initialize();
					Instance.CreatePreviewCamera();
					Instance.CreatePreviewLights();
					Instance.UpdateRenderTexture();
				}
			}
		}

		internal static void ShowPlayerPreview()
		{
			//IL_00a6: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			VECloneSync.ResetStamp();
			if (!Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview) || !Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreviewComp))
			{
				InitializePlayerPreview();
			}
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreviewComp))
			{
				return;
			}
			AzuEPICharacterPanel instance = AzuEPICharacterPanel.instance;
			if ((Object)(object)instance?.cam == (Object)null)
			{
				InitializePlayerPreview();
				if ((Object)(object)instance?.cam == (Object)null)
				{
					return;
				}
			}
			AzuEPICharacterPanel.playerPreview.SetActive(true);
			((Behaviour)instance.cam).enabled = true;
			Player playerPreviewComp = AzuEPICharacterPanel.playerPreviewComp;
			((Humanoid)playerPreviewComp).m_visEquipment.SetHairItem(((Humanoid)localPlayer).m_hairItem);
			((Humanoid)playerPreviewComp).m_visEquipment.SetHairColor(localPlayer.m_hairColor);
			((Humanoid)playerPreviewComp).m_visEquipment.SetSkinColor(localPlayer.m_skinColor);
			((Humanoid)playerPreviewComp).m_visEquipment.SetModel(((Humanoid)localPlayer).m_visEquipment.m_currentModelIndex);
			((Humanoid)playerPreviewComp).m_visEquipment.m_isPlayer = true;
			((Character)playerPreviewComp).m_animator.SetBool("wakeup", false);
			((Character)playerPreviewComp).m_animator.Update(0f);
			VECloneSync.MirrorFrom(localPlayer, playerPreviewComp);
			((Component)playerPreviewComp).transform.rotation = Quaternion.LookRotation(-Vector3.forward, Vector3.up);
			AzuEPICharacterPanel.playerPreview.gameObject.SetLayerForEntireHierarchy(LayerMask.NameToLayer("UI"));
			instance.cam.Render();
		}

		[Obsolete("Split into InitializePlayerPreview (Awake) and ShowPlayerPreview (Show) for better performance")]
		internal static void CreatePlayerPreviewShow()
		{
			//IL_0181: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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)
			VECloneSync.ResetStamp();
			if (!Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview))
			{
				AzuEPICharacterPanel.playerPreview = CreatePlayerPreview();
			}
			if (!Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreviewComp) && Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview))
			{
				AzuEPICharacterPanel.playerPreviewComp = AzuEPICharacterPanel.playerPreview.GetComponent<Player>();
			}
			AzuEPICharacterPanel instance = AzuEPICharacterPanel.instance;
			if ((Object)(object)instance?.cam == (Object)null)
			{
				Initialize();
				Instance.CreatePreviewCamera();
				Instance.CreatePreviewLights();
				Instance.UpdateRenderTexture();
			}
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer) && Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreviewComp))
			{
				AzuEPICharacterPanel.playerPreview.SetActive(true);
				((Behaviour)instance.cam).enabled = true;
				Player playerPreviewComp = AzuEPICharacterPanel.playerPreviewComp;
				((Humanoid)playerPreviewComp).m_visEquipment.SetHairItem(((Humanoid)localPlayer).m_hairItem);
				((Humanoid)playerPreviewComp).m_visEquipment.SetHairColor(localPlayer.m_hairColor);
				((Humanoid)playerPreviewComp).m_visEquipment.SetSkinColor(localPlayer.m_skinColor);
				((Humanoid)playerPreviewComp).m_visEquipment.SetModel(((Humanoid)localPlayer).m_visEquipment.m_currentModelIndex);
				((Humanoid)playerPreviewComp).m_visEquipment.m_isPlayer = true;
				try
				{
					((Humanoid)playerPreviewComp).m_visEquipment.UpdateVisuals();
					PreviewLayerFix.ForceUILayer(((Humanoid)playerPreviewComp).m_visEquipment);
				}
				catch
				{
				}
				((Character)playerPreviewComp).m_animator.SetBool("wakeup", false);
				SyncAnimationState((Humanoid)(object)localPlayer, playerPreviewComp);
				((Character)playerPreviewComp).m_animator.Update(0f);
				VECloneSync.MirrorFrom(localPlayer, playerPreviewComp);
				UpdatePlayerPreview((Humanoid)(object)localPlayer);
				AzuEPICharacterPanel.playerPreview.gameObject.SetLayerForEntireHierarchy(LayerMask.NameToLayer("UI"));
				AzuEPICharacterPanel.playerPreview.transform.rotation = Quaternion.LookRotation(-Vector3.forward, Vector3.up);
				instance.cam.Render();
			}
		}

		internal static void DestroyPlayerPreview_All()
		{
			if (Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreview))
			{
				Object.Destroy((Object)(object)AzuEPICharacterPanel.playerPreview);
			}
			AzuEPICharacterPanel.playerPreview = null;
			AzuEPICharacterPanel.playerPreviewComp = null;
			AzuEPICharacterPanel instance = AzuEPICharacterPanel.instance;
			if (Object.op_Implicit((Object)(object)instance?.cam))
			{
				Object.Destroy((Object)(object)((Component)instance.cam).gameObject);
			}
			if (Object.op_Implicit((Object)(object)instance?.renderTexture))
			{
				instance.renderTexture.Release();
				Object.Destroy((Object)(object)instance.renderTexture);
				instance.renderTexture = null;
			}
		}

		internal static void TryRefresh()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || (Object)(object)AzuEPICharacterPanel.playerPreviewComp == (Object)null)
			{
				return;
			}
			VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
			SyncAnimationState((Humanoid)(object)Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
			PreviewLayerFix.ForceUILayer(((Humanoid)AzuEPICharacterPanel.playerPreviewComp).m_visEquipment);
			AzuEPICharacterPanel instance = AzuEPICharacterPanel.instance;
			if (instance != null)
			{
				Camera cam = instance.cam;
				if (cam != null)
				{
					cam.Render();
				}
			}
		}

		internal static void UpdatePlayerPreview(Humanoid pHumanoid)
		{
			//IL_001f: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			Player playerPreviewComp = AzuEPICharacterPanel.playerPreviewComp;
			if (Object.op_Implicit((Object)(object)pHumanoid) && Object.op_Implicit((Object)(object)playerPreviewComp))
			{
				((Component)playerPreviewComp).transform.rotation = Quaternion.LookRotation(-Vector3.forward, Vector3.up);
				VECloneSync.MirrorFrom((Player)pHumanoid, playerPreviewComp);
				if (!AzuEPICharacterPanel.playerPreview.activeSelf)
				{
					AzuEPICharacterPanel.playerPreview.SetActive(true);
				}
			}
		}

		internal static void SyncAnimationState(Humanoid p, Player playerPreviewComp)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected I4, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			Animator animator = ((Character)p).m_animator;
			Animator animator2 = ((Character)playerPreviewComp).m_animator;
			AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(0);
			animator2.Play(((AnimatorStateInfo)(ref currentAnimatorStateInfo)).shortNameHash, 0, ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime);
			AnimatorControllerParameter[] parameters = animator.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				AnimatorControllerParameterType type = val.type;
				switch (type - 1)
				{
				case 3:
					animator2.SetBool(val.name, animator.GetBool(val.name));
					continue;
				case 0:
					animator2.SetFloat(val.name, animator.GetFloat(val.name));
					continue;
				case 2:
					animator2.SetInteger(val.name, animator.GetInteger(val.name));
					continue;
				case 1:
					continue;
				}
				if ((int)type == 9 && animator.GetBool(val.name))
				{
					animator2.SetTrigger(val.name);
				}
			}
			animator2.Update(0f);
		}

		internal void CreatePreviewCamera()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Player Inspector Camera");
			val.transform.position = AzuEPICharacterPanel.instance.basePosition + Vector3.forward * -3f;
			CharacterPanel.cam = val.AddComponent<Camera>();
			CharacterPanel.cam.clearFlags = (CameraClearFlags)2;
			CharacterPanel.cam.backgroundColor = Color.clear;
			CharacterPanel.cam.cullingMask = 1 << LayerMask.NameToLayer("UI");
			CharacterPanel.cam.renderingPath = (RenderingPath)(-1);
			CharacterPanel.cam.useOcclusionCulling = false;
		}

		internal void CreatePreviewLights()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Item Inspector Light1");
			val.transform.position = CharacterPanel.basePosition + new Vector3(1.5f, 0.5f, -2f);
			Light obj = val.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.intensity = 3.5f;
			obj.range = 3f;
			GameObject val2 = new GameObject("Item Inspector Light2");
			val2.transform.position = CharacterPanel.basePosition + new Vector3(-1.5f, -0.5f, 1.5f);
			Light obj2 = val2.AddComponent<Light>();
			obj2.type = (LightType)2;
			obj2.intensity = 2.5f;
			obj2.range = 3f;
		}
	}
	public class CustomEquipVisuals
	{
		internal sealed class State
		{
			public readonly VisEquipment Vis;

			public readonly Dictionary<string, EquippedEntry> Equipped = new Dictionary<string, EquippedEntry>(StringComparer.Ordinal);

			public State(VisEquipment vis)
			{
				Vis = vis;
			}

			public bool ForceSetEquipped(string prefabName, int hashFromZdo)
			{
				if (!Equipped.TryGetValue(prefabName, out EquippedEntry value))
				{
					value = (Equipped[prefabName] = new EquippedEntry(prefabName));
				}
				if (value.CurrentHash == hashFromZdo)
				{
					return false;
				}
				if (value.Instances.Count > 0)
				{
					foreach (GameObject instance in value.Instances)
					{
						if (Object.op_Implicit((Object)(object)instance))
						{
							Object.Destroy((Object)(object)instance);
						}
					}
					value.Instances.Clear();
				}
				value.CurrentHash = hashFromZdo;
				if (hashFromZdo != 0)
				{
					value.Instances = Vis.AttachArmor(hashFromZdo, -1);
					if ((prefabName == "BackpackBlackForest" || prefabName == "BackpackMountains") ? true : false)
					{
						BoneReorder.ReorderBones(Vis, hashFromZdo, value.Instances);
					}
				}
				return true;
			}

			public bool UpdateAllVisuals()
			{
				bool flag = false;
				ZNetView nview = Vis.m_nview;
				ZDO val = (Object.op_Implicit((Object)(object)nview) ? nview.GetZDO() : null);
				bool flag2 = Object.op_Implicit((Object)(object)nview) && nview.IsOwner();
				foreach (string item in _registered)
				{
					bool flag3 = false;
					string text = "";
					if (Equipped.TryGetValue(item, out EquippedEntry value) && value.Item != null)
					{
						flag3 = value.Item.m_equipped;
						text = value.DisplayName ?? "";
					}
					else if (!flag2 && val != null)
					{
						flag3 = val.GetInt(ZdoKeyFor(item), 0) != 0;
					}
					if (!flag3)
					{
						if (flag2 && val != null)
						{
							val.Set(ZdoKeyFor(item), 0);
						}
						if (Equipped.TryGetValue(item, out EquippedEntry value2) && !string.IsNullOrEmpty(value2.DisplayName))
						{
							value2.DisplayName = "";
						}
						if (ForceSetEquipped(item, 0))
						{
							flag = true;
						}
						continue;
					}
					int num = 0;
					if (val != null)
					{
						num = val.GetInt(ZdoKeyFor(item), 0);
					}
					if (num == 0)
					{
						num = StringExtensionMethods.GetStableHashCode((!string.IsNullOrEmpty(text)) ? text : item);
						if (flag2 && val != null)
						{
							val.Set(ZdoKeyFor(item), num);
						}
					}
					if (ForceSetEquipped(item, num))
					{
						flag = true;
					}
				}
				if (flag)
				{
					Vis.UpdateLodgroup();
				}
				return flag;
			}

			public void SetDisplayName(string prefabName, string name)
			{
				if (!Equipped.TryGetValue(prefabName, out EquippedEntry value))
				{
					value = new EquippedEntry(prefabName);
					Equipped[prefabName] = value;
				}
				if (value.DisplayName == name)
				{
					return;
				}
				value.DisplayName = name;
				if (Object.op_Implicit((Object)(object)Vis.m_nview) && Vis.m_nview.IsOwner())
				{
					ZDO zDO = Vis.m_nview.GetZDO();
					if (zDO != null)
					{
						zDO.Set(ZdoKeyFor(prefabName), (!string.IsNullOrEmpty(name)) ? StringExtensionMethods.GetStableHashCode(name) : 0);
					}
				}
			}
		}

		internal sealed class EquippedEntry
		{
			public readonly string PrefabName;

			public ItemData Item;

			public string DisplayName = "";

			public List<GameObject> Instances = new List<GameObject>();

			public int CurrentHash;

			public EquippedEntry(string prefabName)
			{
				PrefabName = prefabName;
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		private static class PlayerAwake
		{
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance)
			{
				VisEquipment component = ((Component)__instance).GetComponent<VisEquipment>();
				if (Object.op_Implicit((Object)(object)component) && !_states.ContainsKey(component))
				{
					_states[component] = new State(component);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "OnEnable")]
		private static class VisOnEnable
		{
			private static void Postfix(VisEquipment __instance)
			{
				if (__instance.m_isPlayer && !_states.ContainsKey(__instance))
				{
					_states[__instance] = new State(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "OnDisable")]
		private static class VisOnDisable
		{
			private static void Postfix(VisEquipment __instance)
			{
				_states.Remove(__instance);
			}
		}

		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
		private static class SetupVis
		{
			private static void Prefix(Humanoid __instance)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				foreach (string item in _registered)
				{
					EquippedEntry value2;
					string name = (value.Equipped.TryGetValue(item, out value2) ? (value2.DisplayName ?? "") : "");
					value.SetDisplayName(item, name);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
		private static class VisUpdate
		{
			private static void Postfix(VisEquipment __instance)
			{
				if (__instance.m_isPlayer && _states.TryGetValue(__instance, out State value) && value.UpdateAllVisuals() && (Object)(object)__instance == (Object)(object)((Humanoid)(Player.m_localPlayer?)).m_visEquipment)
				{
					VECloneSync.ResetStamp();
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "GetSetCount")]
		private static class HumanoidGetSetCountPatch
		{
			private static void Postfix(Humanoid __instance, string setName, ref int __result)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				int num = 0;
				foreach (EquippedEntry value2 in value.Equipped.Values)
				{
					ItemData item = value2.Item;
					if (item != null && item.m_shared.m_setName == setName)
					{
						num++;
					}
				}
				__result += num;
			}
		}

		[HarmonyPatch(typeof(Player), "GetBodyArmor")]
		private static class EPIAddArmor_GetBodyArmorPatch
		{
			private static void Postfix(Player __instance, ref float __result)
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Invalid comparison between Unknown and I4
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Invalid comparison between Unknown and I4
				if (AzuExtendedPlayerInventoryPlugin.EPISlotsAddArmor.Value.isOff() || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)__instance).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				float num = 0f;
				foreach (EquippedEntry value2 in value.Equipped.Values)
				{
					ItemData item = value2.Item;
					if (item != null && item.m_equipped && !AdvBackpacksCompat.IsAbBackpack(item) && ((int)item.m_shared.m_itemType != 18 || (AzuExtendedPlayerInventoryPlugin.UtilityEPIAddArmor.Value.isOn() && (int)item.m_shared.m_itemType == 18)))
					{
						num += item.GetArmor();
					}
				}
				__result += num;
			}
		}

		[HarmonyPatch(typeof(Player), "GetEquipmentEitrRegenModifier")]
		private static class Player_GetEquipmentEitrRegenModifier_ExtraUtility
		{
			private static void Postfix(Player __instance, ref float __result)
			{
				if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || AzuExtendedPlayerInventoryPlugin.EPISlotsAddArmor.Value.isOff())
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)__instance).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				float num = 0f;
				foreach (EquippedEntry value2 in value.Equipped.Values)
				{
					ItemData item = value2.Item;
					if (item != null && item.m_equipped && !AdvBackpacksCompat.IsAbBackpack(item))
					{
						num += item.m_shared.m_eitrRegenModifier;
					}
				}
				__result += num;
			}
		}

		[HarmonyPatch(typeof(Player), "ApplyArmorDamageMods")]
		private static class EPISlotsAddArmorDamage_ApplyArmorDamageModsPatch
		{
			private static void Postfix(Player __instance, ref DamageModifiers mods)
			{
				if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)__instance).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				foreach (EquippedEntry value2 in value.Equipped.Values)
				{
					ItemData item = value2.Item;
					if (item != null && item.m_equipped && !AdvBackpacksCompat.IsAbBackpack(item))
					{
						((DamageModifiers)(ref mods)).Apply(item.m_shared.m_damageModifiers);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateModifiers")]
		private static class Player_UpdateModifiers_ExtraUtility
		{
			private static void Postfix(Player __instance)
			{
				if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || Player.s_equipmentModifierSourceFields == null)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)__instance).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				for (int i = 0; i < __instance.m_equipmentModifierValues.Length; i++)
				{
					foreach (EquippedEntry value2 in value.Equipped.Values)
					{
						ItemData item = value2.Item;
						if (item != null && item.m_equipped && !AdvBackpacksCompat.IsAbBackpack(item))
						{
							__instance.m_equipmentModifierValues[i] += (float)Player.s_equipmentModifierSourceFields[i].GetValue(item.m_shared);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UnequipAllItems")]
		private static class UnequipAll
		{
			private static void Prefix(Humanoid __instance)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				foreach (EquippedEntry item in value.Equipped.Values.ToList())
				{
					if (item.Item != null)
					{
						((Humanoid)val).UnequipItem(item.Item, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UpdateEquipmentStatusEffects")]
		private static class InjectStatusEffects
		{
			private static void Collect(Humanoid humanoid, HashSet<StatusEffect> set)
			{
				Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
				if (val == null)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					return;
				}
				foreach (EquippedEntry value2 in value.Equipped.Values)
				{
					ItemData item = value2.Item;
					StatusEffect val2 = item?.m_shared?.m_equipStatusEffect;
					if (val2 != null)
					{
						set.Add(val2);
					}
					if (item != null && humanoid.HaveSetEffect(item))
					{
						StatusEffect setStatusEffect = item.m_shared.m_setStatusEffect;
						if ((Object)(object)setStatusEffect != (Object)null)
						{
							set.Add(setStatusEffect);
						}
					}
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instrs)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				List<CodeInstruction> list = instrs.ToList();
				list.InsertRange(2, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(InjectStatusEffects), "Collect", (Type[])null, (Type[])null))
				}));
				return list;
			}
		}

		[HarmonyPatch(typeof(ItemData), "IsEquipable")]
		private static class IsEquipablePatch
		{
			private static void Postfix(ItemData __instance, ref bool __result)
			{
				if (!((Object)(object)__instance?.m_dropPrefab == (Object)null))
				{
					string name = ((Object)__instance.m_dropPrefab).name;
					if (_registered.Contains(name) && HasActiveSlot(__instance))
					{
						__result = true;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "IsItemEquiped")]
		private static class IsItemEquipedPatch
		{
			private static void Postfix(Humanoid __instance, ItemData item, ref bool __result)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null || item == null || (Object)(object)item.m_dropPrefab == (Object)null)
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (Object.op_Implicit((Object)(object)visEquipment) && _states.TryGetValue(visEquipment, out State value))
				{
					string name = ((Object)item.m_dropPrefab).name;
					if (_registered.Contains(name) && value.Equipped.TryGetValue(name, out EquippedEntry value2) && value2.Item == item)
					{
						__result = true;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		internal static class HideTypeWhileEquipping
		{
			internal static bool IsVanillaEquipping;

			private static bool IsReserved(ItemType t)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Invalid comparison between Unknown and I4
				//IL_0012: 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_0017: Invalid comparison between Unknown and I4
				//IL_0005: 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_0009: Invalid comparison between Unknown and I4
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Invalid comparison between Unknown and I4
				if ((int)t <= 11)
				{
					if (t - 6 <= 1 || (int)t == 11)
					{
						goto IL_001e;
					}
				}
				else if (t - 17 <= 1 || (int)t == 24)
				{
					goto IL_001e;
				}
				return false;
				IL_001e:
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix(Humanoid __instance, ItemData item, ref ItemType? __state)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				if (!(__instance is Player) || (Object)(object)item?.m_dropPrefab == (Object)null)
				{
					return;
				}
				if (!IsManaged(item) && IsReserved(item.m_shared.m_itemType))
				{
					IsVanillaEquipping = true;
				}
				if (IsManaged(item) && HasActiveSlot(item) && IsReserved(item.m_shared.m_itemType) && !__instance.IsItemEquiped(item))
				{
					__state = item.m_shared.m_itemType;
					item.m_shared.m_itemType = API.GetFakeItemType();
					if (Object.op_Implicit((Object)(object)__instance.m_visEquipment) && __instance.m_visEquipment.m_isPlayer)
					{
						item.m_shared.m_equipEffect.Create(((Component)__instance).transform.position + Vector3.up, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
					}
				}
			}

			[HarmonyPostfix]
			[HarmonyPriority(0)]
			private static void Postfix(Humanoid __instance, ItemData item, bool triggerEquipEffects, ItemType? __state, ref bool __result)
			{
				//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_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				IsVanillaEquipping = false;
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null || !__state.HasValue)
				{
					return;
				}
				ItemType valueOrDefault = __state.GetValueOrDefault();
				if (item == null || item.m_shared.m_itemType != API.GetFakeItemType())
				{
					return;
				}
				item.m_shared.m_itemType = valueOrDefault;
				if (!((Humanoid)val).IsItemEquiped(item))
				{
					__instance.SetupEquipment();
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (!Object.op_Implicit((Object)(object)visEquipment) || !_states.TryGetValue(visEquipment, out State value))
				{
					__instance.SetupEquipment();
					return;
				}
				string slotOf = GetSlotOf(item);
				if (!string.IsNullOrEmpty(slotOf))
				{
					foreach (KeyValuePair<string, EquippedEntry> item3 in value.Equipped.ToList())
					{
						EquippedEntry value2 = item3.Value;
						ItemData item2 = value2.Item;
						if (item2 != null && item2 != item && string.Equals(GetSlotOf(item2), slotOf, StringComparison.OrdinalIgnoreCase))
						{
							((Humanoid)val).UnequipItem(item2, triggerEquipEffects);
							value.ForceSetEquipped(item3.Key, 0);
							value2.Item = null;
							value2.DisplayName = "";
							value.SetDisplayName(item3.Key, "");
						}
					}
				}
				string name = ((Object)item.m_dropPrefab).name;
				if (_registered.Contains(name))
				{
					value.ForceSetEquipped(name, StringExtensionMethods.GetStableHashCode(name));
				}
				item.m_equipped = true;
				__result = true;
				__instance.SetupEquipment();
			}
		}

		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		private static class EquipItemPatch
		{
			private static void OnEquip(Humanoid humanoid, ItemData item, bool trigger)
			{
				Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
				if (val == null || (Object)(object)item?.m_dropPrefab == (Object)null)
				{
					return;
				}
				string name = ((Object)item.m_dropPrefab).name;
				if (!_registered.Contains(name))
				{
					return;
				}
				VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
				if (Object.op_Implicit((Object)(object)visEquipment) && _states.TryGetValue(visEquipment, out State value))
				{
					if (!value.Equipped.TryGetValue(name, out EquippedEntry value2))
					{
						value2 = (value.Equipped[name] = new EquippedEntry(name));
					}
					value2.Item = item;
					string text = name;
					if (_managed.TryGetValue(name, out (string, bool, string) value3) && !string.IsNullOrEmpty(value3.Item3))
					{
						text = value3.Item3;
					}
					value2.DisplayName = text;
					value.SetDisplayName(name, text);
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructionsEnumerable)
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				List<CodeInstruction> list = instructionsEnumerable.ToList();
				MethodInfo isItemEquiped = AccessTools.DeclaredMethod(typeof(Humanoid), "IsItemEquiped", (Type[])null, (Type[])null);
				int num = list.FindLastIndex((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, isItemEquiped));
				if (num <= 1)
				{
					return list;
				}
				CodeInstruction val = list[num - 2];
				list.InsertRange(num - 2, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					{
						labels = val.labels
					},
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(EquipItemPatch), "OnEquip", (Type[])null, (Type[])null))
				}));
				val.labels = new List<Label>();
				return list;
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		private static class UnequipItemPatch
		{
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static bool Prefix(Humanoid __instance, ItemData item)
			{
				if (!HideTypeWhileEquipping.IsVanillaEquipping)
				{
					return true;
				}
				if (!(__instance is Player))
				{
					return true;
				}
				if ((Object)(object)item?.m_dropPrefab == (Object)null)
				{
					return true;
				}
				string name = ((Object)item.m_dropPrefab).name;
				if (!_registered.Contains(name))
				{
					return true;
				}
				if (!_managed.TryGetValue(name, out (string, bool, string) value))
				{
					return true;
				}
				if (string.IsNullOrEmpty(value.Item1))
				{
					return true;
				}
				if (!API.TryGetSlotIndexByName(value.Item1, out var _))
				{
					return true;
				}
				return false;
			}

			private static void OnUnequip(Humanoid humanoid, ItemData item)
			{
				Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
				if (val == null || item == null || (Object)(object)item.m_dropPrefab == (Object)null)
				{
					return;
				}
				string name = ((Object)item.m_dropPrefab).name;
				if (_registered.Contains(name))
				{
					VisEquipment visEquipment = ((Humanoid)val).m_visEquipment;
					if (Object.op_Implicit((Object)(object)visEquipment) && _states.TryGetValue(visEquipment, out State value) && value.Equipped.TryGetValue(name, out EquippedEntry value2) && value2.Item == item)
					{
						value2.Item = null;
						value2.DisplayName = "";
						value.SetDisplayName(name, "");
					}
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructionEnumerable)
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Expected O, but got Unknown
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Expected O, but got Unknown
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				List<CodeInstruction> list = instructionEnumerable.ToList();
				MethodInfo setupEquipment = AccessTools.DeclaredMethod(typeof(Humanoid), "SetupEquipment", (Type[])null, (Type[])null);
				int num = list.FindIndex((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, setupEquipment));
				if (num < 1)
				{
					return list;
				}
				list.InsertRange(num - 1, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(UnequipItemPatch), "OnUnequip", (Type[])null, (Type[])null))
				}));
				return list;
			}
		}

		private static readonly Dictionary<string, (string slot, bool bypass, string visual)> _managed = new Dictionary<string, (string, bool, string)>(StringComparer.Ordinal);

		private static readonly HashSet<string> _registered = new HashSet<string>(StringComparer.Ordinal);

		internal static readonly Dictionary<VisEquipment, State> _states = new Dictionary<VisEquipment, State>();

		private const string ZdoKeyPrefix = "AzuEPICEV_";

		public static void Register(string prefabName)
		{
			if (!string.IsNullOrWhiteSpace(prefabName))
			{
				_registered.Add(prefabName);
			}
		}

		public static void RegisterForSlot(string prefabName, string slotName, string? visualName = null)
		{
			if (!string.IsNullOrWhiteSpace(prefabName))
			{
				_registered.Add(prefabName);
				_managed[prefabName] = (slotName ?? "", true, visualName ?? "");
			}
		}

		private static string GetSlotOf(string prefabName)
		{
			if (!_managed.TryGetValue(prefabName, out (string, bool, string) value))
			{
				return "";
			}
			return value.Item1 ?? "";
		}

		private static string GetSlotOf(ItemData item)
		{
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			string text = (string)obj;
			if (!string.IsNullOrEmpty(text))
			{
				return GetSlotOf(text);
			}
			return "";
		}

		internal static bool IsManaged(ItemData item)
		{
			if ((Object)(object)item?.m_dropPrefab != (Object)null)
			{
				return _managed.ContainsKey(((Object)item.m_dropPrefab).name);
			}
			return false;
		}

		internal static bool HasActiveSlot(ItemData item)
		{
			if ((Object)(object)item?.m_dropPrefab == (Object)null)
			{
				return false;
			}
			if (!_managed.TryGetValue(((Object)item.m_dropPrefab).name, out (string, bool, string) value))
			{
				return true;
			}
			if (string.IsNullOrEmpty(value.Item1))
			{
				return true;
			}
			if (API.TryGetSlotIndexByName(value.Item1, out var _))
			{
				return true;
			}
			if (IsJewelcraftingGem(item))
			{
				return false;
			}
			return true;
		}

		private static bool IsJewelcraftingGem(ItemData item)
		{
			if ((Object)(object)item?.m_dropPrefab == (Object)null)
			{
				return false;
			}
			string name = ((Object)item.m_dropPrefab).name;
			if (name == "Wishbone")
			{
				return JewelcraftingCompat.IsWishboneAGem();
			}
			if (name == "Demister")
			{
				return JewelcraftingCompat.IsWisplightAGem();
			}
			return false;
		}

		internal static string ZdoKeyFor(string prefabName)
		{
			return "AzuEPICEV_" + prefabName;
		}
	}
}
namespace AzuEPI.Game.Patches
{
	public class InventoryGuiPatches
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		private static class ReparentPlayerGridInventoryGuiAwakePatch
		{
			[HarmonyPriority(0)]
			private static void Postfix(InventoryGui __instance)
			{
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: 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_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: 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_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				GUICache._craftingBkgRT = ((Component)((Transform)__instance.m_crafting).Find("Bkg")).GetComponent<RectTransform>();
				GUICache._selectedFrameRT = ((Component)((Transform)__instance.m_crafting).Find("selected_frame")).GetComponent<RectTransform>();
				GUICache._repairSimpleRT = ((Component)((Transform)__instance.m_crafting).Find("RepairSimple")).GetComponent<RectTransform>();
				GUICache._repairButtonRT = ((Component)((Transform)__instance.m_crafting).Find("RepairButton")).GetComponent<RectTransform>();
				GUICache._enchantmentMenuButtonRT = (VESCompat.IsVesInstalled ? ((Component)((Transform)__instance.m_crafting).Find("enchantment_menu")).GetComponent<RectTransform>() : null);
				GUICache._enchantmentMenuBkgButtonRT = (VESCompat.IsVesInstalled ? ((Component)((Transform)__instance.m_crafting).Find("RepairSimple(Clone)")).GetComponent<RectTransform>() : null);
				GUICache._playerBkgRT = ((Component)((Transform)__instance.m_player).Find("Bkg")).GetComponent<RectTransform>();
				object playerGridRootRT;
				if (!Object.op_Implicit((Object)(object)__instance.m_playerGrid))
				{
					playerGridRootRT = null;
				}
				else
				{
					RectTransform gridRoot = __instance.m_playerGrid.m_gridRoot;
					playerGridRootRT = ((gridRoot != null) ? ((Component)gridRoot).GetComponent<RectTransform>() : null);
				}
				GUICache._playerGridRootRT = (RectTransform)playerGridRootRT;
				object playerGridRootImage;
				if (!Object.op_Implicit((Object)(object)__instance.m_playerGrid))
				{
					playerGridRootImage = null;
				}
				else
				{
					RectTransform gridRoot2 = __instance.m_playerGrid.m_gridRoot;
					playerGridRootImage = ((gridRoot2 != null) ? ((Component)gridRoot2).GetComponent<Image>() : null);
				}
				GUICache._playerGridRootImage = (Image?)playerGridRootImage;
				Layout.SelectedFrameOrigAnchMin = GUICache._selectedFrameRT.anchorMin;
				Layout.RepairSimpleOrigAnchoredPos = GUICache._repairSimpleRT.anchoredPosition;
				Layout.RepairButtonOrigAnchoredPos = GUICache._repairButtonRT.anchoredPosition;
				Layout.EnchantmentMenuOrigAnchoredPos = (Vector2)((GUICache._enchantmentMenuButtonRT != null) ? GUICache._enchantmentMenuButtonRT.anchoredPosition : default(Vector2));
				Layout.EnchantmentMenuBkgOrigAnchoredPos = (Vector2)((GUICache._enchantmentMenuBkgButtonRT != null) ? GUICache._enchantmentMenuBkgButtonRT.anchoredPosition : default(Vector2));
				Layout.ContainerOrigPivot = __instance.m_container.pivot;
				if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff())
				{
					Layout.ApplyRepairShift();
				}
				UIBuilder.CreateExtendedCraftingPanel(__instance, GUICache._selectedFrameRT);
				UIBuilder.CreateRuntimePanel();
				UIBuilder.CreateAzuEpiPreview(__instance, out RectTransform previewParentRT);
				UIBuilder.CreatePlayerPreviewImage(previewParentRT);
				UIBuilder.SetupPreviewPanel();
				UIBuilder.BuildToggleButtonGlg(__instance);
				UIBuilder.BuildCraftingToggleButton(__instance);
				Layout.FixPlayerPreview();
				UIBuilder.EnsureVanityPanelBuilt(__instance);
				VanityPanelController.SetVisible(visible: false);
				UIBuilder.BuildLoadoutToggles(__instance);
				UIBuilder.EnsureStatsPanelBuilt(__instance);
				UIBuilder.BuildStatsToggleButton(__instance);
				StatsPanelController.SetVisible(visible: false);
				UIBuilder.CreateCharacterName(__instance, previewParentRT);
				if (Object.op_Implicit((Object)(object)GUICache._craftingBkgRT))
				{
					((Behaviour)((Component)GUICache._craftingBkgRT).GetComponent<Image>()).enabled = AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn();
				}
				UIBuilder.BuildDropAllButton(__instance);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		private static class InventoryGuiShowPatch
		{
			private static void Postfix(InventoryGui __instance)
			{
				InventoryHealth.InventoryFix();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
		private static class InventoryGuiOnSelectedItemPatch
		{
			private static void Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Character)localPlayer).IsTeleporting() && __instance.m_dragItem != null && Object.op_Implicit((Object)(object)__instance.m_dragGo) && ((Humanoid)localPlayer).IsItemEquiped(__instance.m_dragItem) && __instance.m_dragInventory != null && __instance.m_dragInventory.IsAtEquipmentSlot(__instance.m_dragItem, out var _))
				{
					((Humanoid)localPlayer).UnequipItem(__instance.m_dragItem, false);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
		public static class InventoryGui_OnSelectedItem_EpiValidation
		{
			private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if (!Object.op_Implicit((Object)(object)localPlayer) || ((Character)localPlayer).IsTeleporting())
				{
					return true;
				}
				if (item == null)
				{
					return true;
				}
				if (!Object.op_Implicit((Object)(object)__instance.m_dragGo) || __instance.m_dragItem == null || __instance.m_dragInventory == null)
				{
					return true;
				}
				return EpiDropRouter.ValidatePlannedDrop(grid, __instance.m_dragInventory, __instance.m_dragItem, __instance.m_dragAmount, pos);
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "DropItem")]
		public static class InventoryGrid_DropItem_EpiValidation
		{
			private static bool Prefix(InventoryGrid __instance, Inventory fromInventory, ItemData item, int amount, Vector2i pos, ref bool __result)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if (!Object.op_Implicit((Object)(object)localPlayer) || ((Character)localPlayer).IsTeleporting())
				{
					return true;
				}
				if (EpiDropRouter.ValidatePlannedDrop(__instance, fromInventory, item, amount, pos))
				{
					return true;
				}
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(UITooltip)
		})]
		public static class ItemTooltipControllerFollowSelectionPatch
		{
			[HarmonyPriority(0)]
			public static bool Prefix(ItemData item, UITooltip tooltip, out string __state)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				__state = null;
				if (ZInput.IsGamepadActive() && !ZInput.IsMouseActive())
				{
					tooltip.Set(item.m_shared.m_name, item.GetTooltip(-1), (RectTransform)null, default(Vector2));
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateInventory")]
		internal static class UpdateInventory_Patch
		{
			private static RectTransform _cachedBkgRect;

			private static Transform _cachedPlayerScrollCheck;

			private static RectTransform _cachedPlayerGridRect;

			private static Transform _cachedEquipmentBkg;

			private static InventoryGui _lastInstance;

			private static Vector2 _lastBkgAnchorMin = new Vector2(float.NaN, float.NaN);

			private static Vector2[] _cachedSlotPositions = Array.Empty<Vector2>();

			private static string[] _cachedSlotNames = Array.Empty<string>();

			private static bool _overlaysInitialized;

			internal static void RebuildQuickslots()
			{
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				_cachedSlotPositions = Array.Empty<Vector2>();
				_cachedSlotNames = Array.Empty<string>();
				if (AzuExtendedPlayerInventoryPlugin.Hotkeys == null || AzuExtendedPlayerInventoryPlugin.HotkeyTexts == null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"RebuildQuickslots called with null Hotkeys or HotkeyTexts");
					return;
				}
				if (AzuExtendedPlayerInventoryPlugin.Hotkeys.Length != AzuExtendedPlayerInventoryPlugin.HotkeyTexts.Length)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"RebuildQuickslots: Hotkeys.Length ({AzuExtendedPlayerInventoryPlugin.Hotkeys.Length}) != HotkeyTexts.Length ({AzuExtendedPlayerInventoryPlugin.HotkeyTexts.Length})");
					return;
				}
				ExtendedPlayerInventory.slots.RemoveAll((Model.Slot? s) => s?.IsQuickSlot ?? false);
				API.BeforeQuickSlotsAdded();
				int value = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
				for (int num = 0; num < value && num < AzuExtendedPlayerInventoryPlugin.Hotkeys.Length && num < AzuExtendedPlayerInventoryPlugin.HotkeyTexts.Length; num++)
				{
					if (AzuExtendedPlayerInventoryPlugin.Hotkeys[num] == null || AzuExtendedPlayerInventoryPlugin.HotkeyTexts[num] == null)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"Skipping quick slot {num} due to null config entry");
						continue;
					}
					ExtendedPlayerInventory.slots.Add(new Model.Slot
					{
						Name = (Utility.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.HotkeyTexts[num].Value) ? ((object)AzuExtendedPlayerInventoryPlugin.Hotkeys[num].Value/*cast due to .constrained prefix*/).ToString() : AzuExtendedPlayerInventoryPlugin.HotkeyTexts[num].Value),
						IsQuickSlot = true
					});
				}
				API.QuickSlotsAdded();
				Layout.FixPlayerPreview();
			}

			private static void Postfix(InventoryGui __instance, Player player, InventoryGrid ___m_playerGrid)
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0416: Unknown result type (might be due to invalid IL or missing references)
				//IL_043e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0443: Unknown result type (might be due to invalid IL or missing references)
				//IL_0448: Unknown result type (might be due to invalid IL or missing references)
				//IL_0451: Unknown result type (might be due to invalid IL or missing references)
				//IL_0456: Unknown result type (might be due to invalid IL or missing references)
				//IL_0461: Unknown result type (might be due to invalid IL or missing references)
				//IL_046f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0471: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_040d: Unknown result type (might be due to invalid IL or missing references)
				//IL_040f: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_lastInstance != (Object)(object)__instance || (Object)(object)_cachedBkgRect == (Object)null)
				{
					_lastInstance = __instance;
					_cachedBkgRect = ((Component)((Transform)__instance.m_player).Find("Bkg")).GetComponent<RectTransform>();
					_cachedPlayerScrollCheck = ((Component)__instance.m_player).transform.Find("PlayerScroll");
					_cachedPlayerGridRect = ((___m_playerGrid != null) ? ((Component)___m_playerGrid).GetComponent<RectTransform>() : null);
					_lastBkgAnchorMin = new Vector2(float.NaN, float.NaN);
					_cachedSlotPositions = Array.Empty<Vector2>();
					_cachedSlotNames = Array.Empty<string>();
				}
				RectTransform cachedBkgRect = _cachedBkgRect;
				if ((Object)(object)_cachedPlayerScrollCheck == (Object)null)
				{
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(0f, (float)(AzuExtendedPlayerInventoryPlugin.ExtraRows.Value + ((!AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() && !AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value.isOn()) ? API.GetAddedRows(((Humanoid)Player.m_localPlayer).m_inventory.GetWidth()) : 0)) * -0.25f);
					if (val != _lastBkgAnchorMin)
					{
						cachedBkgRect.anchorMin = val;
						_lastBkgAnchorMin = val;
					}
				}
				if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() || !Object.op_Implicit((Object)(object)player))
				{
					return;
				}
				Inventory inventory = ((Humanoid)player).GetInventory();
				int baseSlotIndex = Layout.GetBaseSlotIndex(inventory);
				for (int i = 0; i < ___m_playerGrid.m_elements.Count; i++)
				{
					Element val2 = ___m_playerGrid.m_elements[i];
					if ((Object)(object)val2?.m_go != (Object)null && !val2.m_used)
					{
						SlotOverlays.SetVanityOverlayVisible(val2.m_go, default(VanityState));
					}
				}
				Rect rect = _cachedPlayerGridRect.rect;
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor((((Rect)(ref rect)).width - ___m_playerGrid.GetWidgetSize().x) / 2f, 0f);
				int count = ExtendedPlayerInventory.slots.Count;
				if (_cachedSlotPositions.Length != count)
				{
					_cachedSlotPositions = (Vector2[])(object)new Vector2[count];
					for (int j = 0; j < count; j++)
					{
						_cachedSlotPositions[j] = new Vector2(float.NaN, float.NaN);
					}
				}
				if (_cachedSlotNames.Length != count)
				{
					_cachedSlotNames = new string[count];
				}
				for (int k = 0; k < count; k++)
				{
					Element val4 = ___m_playerGrid.m_elements[baseSlotIndex + k];
					GameObject go = val4.m_go;
					if (!Object.op_Implicit((Object)(object)go) || ExtendedPlayerInventory.slots[k] == null)
					{
						continue;
					}
					if (!go.activeSelf)
					{
						go.SetActive(true);
					}
					if (!((Object)go).name.StartsWith("AzuEPI_Slot_"))
					{
						((Object)go).name = "AzuEPI_Slot_" + ExtendedPlayerInventory.slots[k]?.Name;
					}
					ExtendedPlayerInventory.slots[k].Occupied = val4.m_used;
					string text = ExtendedPlayerInventory.slots[k]?.Name ?? "";
					if (_cachedSlotNames[k] != text)
					{
						SlotText.Set(text, go.transform);
						_cachedSlotNames[k] = text;
					}
					RectTransform component = go.GetComponent<RectTransform>();
					if (AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value.isOn())
					{
						if (Object.op_Implicit((Object)(object)InventoryGui.instance))
						{
							if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() && (Object)(object)((Transform)component).parent != (Object)(object)InventoryGui.instance.m_crafting)
							{
								((Transform)component).SetParent((Transform)(object)InventoryGui.instance.m_crafting, false);
							}
							else if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn() && (Object)(object)((Transform)component).parent != (Object)(object)((Component)InventoryGui.instance.m_playerGrid).transform)
							{
								((Transform)component).SetParent(((Component)InventoryGui.instance.m_playerGrid).transform.parent, false);
							}
						}
						Vector2 position = ExtendedPlayerInventory.slots[k].Position;
						if (_cachedSlotPositions[k] != position)
						{
							component.anchoredPosition = position;
							_cachedSlotPositions[k] = position;
						}
					}
					else
					{
						Vector2 val5 = val3 + new Vector2((float)((baseSlotIndex + k) % inventory.GetWidth()) * ___m_playerGrid.m_elementSpace, (float)((baseSlotIndex + k) / inventory.GetWidth()) * (0f - ___m_playerGrid.m_elementSpace));
						if (_cachedSlotPositions[k] != val5)
						{
							component.anchoredPosition = val5;
							_cachedSlotPositions[k] = val5;
						}
					}
				}
				for (int l = baseSlotIndex + count; l < ___m_playerGrid.m_elements.Count; l++)
				{
					Element val6 = ___m_playerGrid.m_elements[l];
					if (val6.m_go.activeSelf)
					{
						val6.m_go.SetActive(false);
					}
					val6.m_used = true;
				}
				if (!Object.op_Implicit((Object)(object)__instance.m_playerGrid))
				{
					return;
				}
				Layout.ProjectEquippedIntoGridTail(player, ___m_playerGrid);
				if ((Object)(object)_cachedEquipmentBkg == (Object)null || (Object)(object)_lastInstance != (Object)(object)__instance)
				{
					_cachedEquipmentBkg = ((Transform)__instance.m_player).Find("AzuEPI_EquipmentBkg");
				}
				Transform cachedEquipmentBkg = _cachedEquipmentBkg;
				switch (AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value)
				{
				case AzuExtendedPlayerInventoryPlugin.Toggle.On:
					if (!Object.op_Implicit((Object)(object)cachedEquipmentBkg) && AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn())
					{
						Layout.UpdateContainerPosition();
						UIBuilder.BuildEquipmentBkg(__instance, cachedBkgRect);
					}
					else if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff())
					{
						Layout.UpdateContainerPosition();
						if (!Object.op_Implicit((Object)(object)cachedEquipmentBkg))
						{
							UIBuilder.BuildEquipmentBkg(__instance, cachedBkgRect);
						}
						float num = 77f / 95f;
						Vector2 anchorMax = default(Vector2);
						((Vector2)(ref anchorMax))..ctor(1f + num, 1f);
						if (GUICache.IsMinimalUiInstalled)
						{
							anchorMax.x += 0.03f;
						}
						if (Object.op_Implicit((Object)(object)GUICache._playerGridRootRT))
						{
							GUICache._playerGridRootRT.anchorMax = anchorMax;
						}
						if (Object.op_Implicit((Object)(object)GUICache._playerGridRootImage))
						{
							((Graphic)GUICache._playerGridRootImage).raycastTarget = false;
						}
					}
					break;
				case AzuExtendedPlayerInventoryPlugin.Toggle.Off:
					if (Object.op_Implicit((Object)(object)cachedEquipmentBkg))
					{
						Layout.UpdateContainerPosition(addAPIRows: true);
						((Component)cachedEquipmentBkg).gameObject.SetActive(false);
					}
					break;
				}
				if (StatsPanelController.IsVisible() && (Object)(object)player != (Object)null && Time.frameCount % 10 == 0 && !StatsPanelController.IsViewingRemotePlayer())
				{
					StatsPanelController.UpdateStats(player);
				}
				UpdateInvalidDropOverlays(__instance, ___m_playerGrid, player);
			}

			private static void UpdateInvalidDropOverlays(InventoryGui ig, InventoryGrid playerGrid, Player player)
			{
				GameObject dragGo = ig.m_dragGo;
				ItemData dragItem = ig.m_dragItem;
				bool flag = Object.op_Implicit((Object)(object)dragGo) && dragItem != null;
				if (!_overlaysInitialized)
				{
					int baseSlotIndex = Layout.GetBaseSlotIndex(((Humanoid)player).GetInventory());
					for (int i = 0; i < ExtendedPlayerInventory.slots.Count; i++)
					{
						if (ExtendedPlayerInventory.slots[i] == null)
						{
							continue;
						}
						int num = baseSlotIndex + i;
						if (num >= 0 && num < playerGrid.m_elements.Count)
						{
							GameObject go = playerGrid.m_elements[num].m_go;
							if (Object.op_Implicit((Object)(object)go))
							{
								SlotOverlays.EnsureInvalidOverlay(go);
								SlotOverlays.EnsureVanityStateOverlay(go);
							}
						}
					}
					_overlaysInitialized = true;
				}
				int baseSlotIndex2 = Layout.GetBaseSlotIndex(((Humanoid)player).GetInventory());
				for (int j = 0; j < ExtendedPlayerInventory.slots.Count; j++)
				{
					Model.Slot slot = ExtendedPlayerInventory.slots[j];
					if (slot == null)
					{
						continue;
					}
					int num2 = baseSlotIndex2 + j;
					if (num2 < 0 || num2 >= playerGrid.m_elements.Count)
					{
						continue;
					}
					GameObject go2 = playerGrid.m_elements[num2].m_go;
					if (Object.op_Implicit((Object)(object)go2))
					{
						if (!flag)
						{
							SlotOverlays.SetInvalidVisible(go2, visible: false);
							continue;
						}
						if (!slot.IsQuickSlot && !(slot is Model.EquipmentSlot))
						{
							SlotOverlays.SetInvalidVisible(go2, visible: false);
							continue;
						}
						bool flag2 = SlotAcceptRules.CanItemGoToSlot(slot, dragItem);
						SlotOverlays.SetInvalidVisible(go2, !flag2);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "SetupEquipment")]
	internal static class SetupEquipment_GridSync
	{
		private static void Postfix(Humanoid __instance)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val != null && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && !InventoryGui.IsVisible() && !AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() && !InventoryPatches.IsInAutoEquip)
			{
				Layout.ProjectEquippedIntoGridTail(val, null);
			}
		}
	}
	public class InventoryPatches
	{
		[HarmonyPatch(typeof(Inventory), "FindEmptySlot")]
		private static class FindEmptySlot_FilterHidden_AddQuick_Patch
		{
			private static bool Prefix(Inventory __instance, ref Vector2i __result, bool topFirst)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				if (_itemBeingAdded != null)
				{
					__result = __instance.FindEmptyQuickAware(_itemBeingAdded, topFirst);
				}
				else
				{
					__result = __instance.FindEmptyQuickAware(topFirst);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "GetEmptySlots")]
		private static class GetEmptySlots_QuickAware_Patch
		{
			private static bool Prefix(Inventory __instance, ref int __result, List<ItemData> ___m_inventory, int ___m_width, int ___m_height)
			{
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				__result = Capacity.FreeNormalCells(__instance) + Capacity.FreeQuickCells(__instance) + Capacity.FreeEquipmentCells(__instance);
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "HaveEmptySlot")]
		private static class HaveEmptySlot_QuickAware_Patch
		{
			private static bool Prefix(Inventory __instance, ref bool __result, List<ItemData> ___m_inventory, int ___m_width, int ___m_height)
			{
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				int num = Layout.NormalRows(__instance);
				int num2 = 0;
				foreach (ItemData item in ___m_inventory)
				{
					if (item.m_gridPos.y < num)
					{
						num2++;
					}
				}
				if (num2 < num * ___m_width)
				{
					__result = true;
					return false;
				}
				__result = __instance.TryFindEmptyQuickCell(out var _);
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[] { typeof(ItemData) })]
		private static class InventoryAddItemPatch1
		{
			private static bool _inAutoEquipCall;

			[HarmonyPriority(800)]
			private static bool Prefix(Inventory __instance, ref bool __result, ItemData item)
			{
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				//IL_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				//IL_024f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_027e: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.ShouldProtectInventorySlots() && item?.m_shared != null)
				{
					_itemBeingAdded = item;
				}
				if (_inAutoEquipCall)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem: Recursion detected, skipping auto-equip");
					return true;
				}
				if (IsInMigration)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem: Migration in progress, skipping auto-equip");
					return true;
				}
				if (_isLoadingInventory)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem: Inventory loading, skipping auto-equip");
					return true;
				}
				if (item?.m_shared == null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem: Item or shared data is null, skipping auto-equip");
					return true;
				}
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": No local player, skipping auto-equip");
					return true;
				}
				if (Player.m_localPlayer.m_isLoading)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": Player is loading, skipping auto-equip");
					return true;
				}
				if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff())
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": AddEquipmentRow is OFF, skipping auto-equip");
					return true;
				}
				if (__instance != ((Humanoid)Player.m_localPlayer).GetInventory())
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": Not player inventory, skipping auto-equip");
					return true;
				}
				if (!__instance.IsEquipmentSlotFreeAndItemValid(item, out var which))
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": No valid free equipment slot found, using vanilla placement");
					return true;
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"AddItem {item.m_shared.m_name}: Found equipment slot {which}, attempting to place");
				Vector2i val = __instance.EpiIndexToGridPos(which);
				try
				{
					_inAutoEquipCall = true;
					IsInAutoEquip = true;
					if (!__instance.AddItem(item, item.m_stack, val.x, val.y))
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarningDebug($"AddItem {item.m_shared.m_name}: Failed to place in equipment slot at ({val.x}, {val.y}), letting vanilla handle it");
						return true;
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"AddItem {item.m_shared.m_name}: Successfully placed at ({val.x}, {val.y})");
					ItemData itemAt = __instance.GetItemAt(val.x, val.y);
					if (itemAt == null)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarningDebug($"AddItem {item.m_shared.m_name}: Item not found at ({val.x}, {val.y}) after placement");
						__instance.Changed();
						__result = true;
						return false;
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"AddItem {item.m_shared.m_name}: Retrieved item from inventory - IsEquipped={itemAt.m_equipped}, InInventory={__instance.ContainsItem(itemAt)}");
					if (AzuExtendedPlayerInventoryPlugin.AutoEquip.Value.isOn() && !IsInTombstoneTakeAll)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": Calling EquipItem...");
						bool flag = ((Humanoid)Player.m_localPlayer).EquipItem(itemAt, false);
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"AddItem {item.m_shared.m_name}: EquipItem returned {flag}, item.m_equipped={itemAt.m_equipped}");
					}
					else if (IsInTombstoneTakeAll)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": Tombstone TakeAll in progress – placement done, deferring equip to AutoEquipAfterTombstoneGrab.");
					}
					else
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("AddItem " + item.m_shared.m_name + ": AutoEquip is OFF, skipping equip");
					}
					__instance.Changed();
					__result = true;
					return false;
				}
				finally
				{
					_inAutoEquipCall = false;
					IsInAutoEquip = false;
				}
			}

			[HarmonyPriority(0)]
			private static void Finalizer()
			{
				_itemBeingAdded = null;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		private static class AddItem_XY_Guard_Patch
		{
			[HarmonyPriority(0)]
			private static bool Prefix(Inventory __instance, ref bool __result, ItemData item, int amount, int x, int y)
			{
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				if (item?.m_shared == null)
				{
					return true;
				}
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				if (_isLoadingInventory)
				{
					return true;
				}
				if (IsInMigration)
				{
					return true;
				}
				if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.m_isLoading)
				{
					return true;
				}
				if (__instance.IsHiddenCell(x, y))
				{
					__result = __instance.AddItem(item, amount, Mathf.Clamp(item.m_gridPos.x, 0, __instance.GetWidth() - 1), Mathf.Clamp(item.m_gridPos.y, 0, __instance.GetHeight() - 1)) || __instance.AddItem(item);
					return false;
				}
				if (API.TryGetSlotIndexAtGridPos(__instance, new Vector2i(x, y), out var slotIndex) && !API.SlotValidates(slotIndex, item))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(Vector2i)
		})]
		internal static class AddItem_Pos_Guard_Patch
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Inventory __instance, ref bool __result, ItemData item, ref Vector2i pos)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: 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)
				if (item?.m_shared == null)
				{
					return true;
				}
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				if (_isLoadingInventory)
				{
					return true;
				}
				if (IsInMigration)
				{
					return true;
				}
				if (__instance.IsHiddenCell(pos.x, pos.y))
				{
					__result = __instance.AddItem(item);
					return false;
				}
				if (API.TryGetSlotIndexAtGridPos(__instance, pos, out var slotIndex) && !API.SlotValidates(slotIndex, item))
				{
					Vector2i val = __instance.FindEmptyQuickAware(item, topFirst: true);
					if (val.x >= 0)
					{
						pos = val;
						return true;
					}
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Inventory), "CanAddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int)
		})]
		private static class CanAddItem_QuickAware_Patch
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Inventory __instance, ItemData item, int stack, ref bool __result)
			{
				if (item?.m_shared == null)
				{
					return true;
				}
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				if (stack <= 0)
				{
					stack = item.m_stack;
				}
				int num = Mathf.Max(1, item.m_shared.m_maxStackSize);
				int num2 = Capacity.FreeStackSpace(__instance, item);
				int num3 = Capacity.FreeNormalCells(__instance);
				int num4 = Capacity.FreeQuickCells(__instance);
				int num5 = Capacity.FreeValidEquipmentCells(__instance, item);
				long num6 = num2 + (long)(num3 + num4 + num5) * (long)num;
				__result = num6 >= stack;
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "Load")]
		internal static class Load_TrackAndFixHiddenItems_Patch
		{
			private static readonly List<ItemData> _stuckItems = new List<ItemData>(16);

			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance)
			{
				_isLoadingInventory = true;
			}

			[HarmonyPriority(0)]
			private static void Postfix(Inventory __instance)
			{
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: 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_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0327: Unknown result type (might be due to invalid IL or missing references)
				//IL_0352: Unknown result type (might be due to invalid IL or missing references)
				//IL_0361: Unknown result type (might be due to invalid IL or missing references)
				//IL_0370: Unknown result type (might be due to invalid IL or missing references)
				//IL_037f: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_024d: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02da: Unknown result type (might be due to invalid IL or missing references)
				//IL_02df: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (!__instance.ShouldProtectInventorySlots())
					{
						return;
					}
					int width = __instance.GetWidth();
					int height = __instance.GetHeight();
					_stuckItems.Clear();
					foreach (ItemData allItem in __instance.GetAllItems())
					{
						bool num = allItem.m_gridPos.x < 0 || allItem.m_gridPos.x >= width || allItem.m_gridPos.y < 0 || allItem.m_gridPos.y >= height;
						bool flag = __instance.IsHiddenCell(allItem.m_gridPos.x, allItem.m_gridPos.y);
						if (num || flag)
						{
							_stuckItems.Add(allItem);
						}
					}
					if (_stuckItems.Count == 0)
					{
						return;
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"Found {_stuckItems.Count} items in hidden/out-of-bounds cells during load. Relocating...");
					foreach (ItemData it in _stuckItems)
					{
						Vector2i gridPos = it.m_gridPos;
						Vector2i val = __instance.FindEmptyQuickAware(topFirst: true);
						if (val.x < 0)
						{
							ItemData val2 = ((it.m_shared.m_maxStackSize > 1) ? ((IEnumerable<ItemData>)__instance.m_inventory).FirstOrDefault((Func<ItemData, bool>)((ItemData i) => i != it && i.m_shared.m_name == it.m_shared.m_name && i.m_worldLevel == it.m_worldLevel && i.m_quality == it.m_quality && i.m_stack < i.m_shared.m_maxStackSize && !__instance.IsHiddenCell(i.m_gridPos.x, i.m_gridPos.y) && i.m_gridPos.x >= 0 && i.m_gridPos.x < width && i.m_gridPos.y >= 0 && i.m_gridPos.y < height)) : null);
							if (val2 != null)
							{
								int num2 = Mathf.Min(it.m_stack, val2.m_shared.m_maxStackSize - val2.m_stack);
								val2.m_stack += num2;
								ItemData obj = it;
								obj.m_stack -= num2;
								AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Merged {num2}x {it.m_shared.m_name} from hidden cell ({gridPos.x}, {gridPos.y}) into stack at ({val2.m_gridPos.x}, {val2.m_gridPos.y})");
								if (it.m_stack <= 0)
								{
									__instance.m_inventory.Remove(it);
									continue;
								}
								val = __instance.FindEmptyQuickAware(topFirst: true);
							}
							if (val.x < 0)
							{
								((Vector2i)(ref val))..ctor(0, 0);
								AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("No free slot for " + it.m_shared.m_name + ", placing at (0,0) - may overlap!"));
							}
						}
						it.m_gridPos = val;
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Moved {it.m_shared.m_name} from hidden cell ({gridPos.x}, {gridPos.y}) to ({val.x}, {val.y})");
					}
					__instance.Changed();
				}
				finally
				{
					_isLoadingInventory = false;
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
		{
			typeof(Inventory),
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		internal static class MoveItemToThis_XY_Guard_Patch
		{
			private static bool Prefix(Inventory __instance, ref bool __result, Inventory fromInventory, ItemData item, int amount, int x, int y)
			{
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				if (item?.m_shared == null)
				{
					return true;
				}
				if (!__instance.ShouldProtectInventorySlots())
				{
					return true;
				}
				if (__instance.IsHiddenCell(x, y))
				{
					bool flag = __instance.AddItem(item, amount, Mathf.Clamp(item.m_gridPos.x, 0, __instance.GetWidth() - 1), Mathf.Clamp(item.m_gridPos.y, 0, __instance.GetHeight() - 1));
					if (!flag)
					{
						flag = __instance.AddItem(item);
					}
					if (flag)
					{
						if (item.m_stack == 0)
						{
							fromInventory.RemoveItem(item);
						}
						else
						{
							fromInventory.Changed();
						}
					}
					__result = flag;
					return false;
				}
				if (API.TryGetSlotIndexAtGridPos(__instance, new Vector2i(x, y), out var slotIndex) && !API.SlotValidates(slotIndex, item))
				{
					__result = false;
					return false;
				}
				return true;
			}

			private static void Postfix(Inventory __instance, bool __result, ItemData item, int x, int y)
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				if (__result && AzuExtendedPlayerInventoryPlugin.AutoEquip.Value.isOn() && AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOn() && !IsInAutoEquip && !IsInMigration && !IsInTombstoneTakeAll && !((Object)(object)Player.m_localPlayer == (Object)null) && __instance == ((Humanoid)Player.m_localPlayer).GetInventory() && API.TryGetSlotIndexAtGridPos(__instance, new Vector2i(x, y), out var slotIndex) && ExtendedPlayerInventory.slots[slotIndex] is Model.EquipmentSlot)
				{
					ItemData itemAt = __instance.GetItemAt(x, y);
					if (itemAt != null && !itemAt.m_equipped)
					{
						((Humanoid)Player.m_localPlayer).EquipItem(itemAt, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveInventoryToGrave")]
		private static class MoveInventoryToGravePatch
		{
			private static void Prefix(Inventory __instance, Inventory original)
			{
				if (original.IsPlayerInventory())
				{
					original.m_height = API.GetFullHeight(original.GetWidth());
					__instance.m_height = API.GetFullHeight(__instance.GetWidth());
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"MoveInventoryToGrave: Set original inventory height to {original.m_height}, grave height to {__instance.m_height}");
				}
			}

			private static void Postfix(Inventory __instance, Inventory original)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"MoveInventoryToGrave: grave height={__instance.GetHeight()}, original height={original.GetHeight()}");
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveAll")]
		internal static class MoveAllToPatch
		{
			private static void Postfix(Inventory __instance, Inventory fromInventory)
			{
				if (__instance.IsPlayerInventory())
				{
					InventoryHealth.InventoryFix();
				}
			}
		}

		[HarmonyPatch(typeof(Container), "RPC_TakeAllRespons")]
		internal static class ContainerRPCRequestTakeAllPatch
		{
			private static void Prefix(Container __instance, bool granted)
			{
				if (granted && (Object)(object)((Component)__instance).GetComponent<TombStone>() != (Object)null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"TombStone TakeAll starting – suppressing per-item EquipItem calls during MoveAll.");
					IsInTombstoneTakeAll = true;
				}
			}

			private static void Postfix(Container __instance, bool granted)
			{
				if (granted)
				{
					InventoryHealth.InventoryFix();
				}
			}

			private static void Finalizer()
			{
				IsInTombstoneTakeAll = false;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		private static class DoCrafting_TrackUpgradeEquipped_Patch
		{
			internal static bool UpgradeItemWasEquipped;

			private static void Prefix(InventoryGui __instance)
			{
				UpgradeItemWasEquipped = __instance.m_craftUpgradeItem?.m_equipped ?? false;
			}

			private static void Finalizer()
			{
				UpgradeItemWasEquipped = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(Vector2i),
			typeof(bool)
		})]
		internal static class AddItem_String_TrackItemForUpgrading_Patch
		{
			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance, string name, int quality, int variant)
			{
				if (__instance.IsPlayerInventory())
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
					ItemDrop val = default(ItemDrop);
					if (!((Object)(object)itemPrefab == (Object)null) && itemPrefab.TryGetComponent<ItemDrop>(ref val))
					{
						_itemBeingAdded = val.m_itemData.Clone();
						_itemBeingAdded.m_quality = quality;
						_itemBeingAdded.m_variant = variant;
					}
				}
			}

			[HarmonyPriority(0)]
			private static void Postfix(Inventory __instance, ItemData? __result)
			{
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				if (__result != null && DoCrafting_TrackUpgradeEquipped_Patch.UpgradeItemWasEquipped && AzuExtendedPlayerInventoryPlugin.AutoEquip.Value.isOn() && AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOn() && !_isLoadingInventory && !IsInMigration && !((Object)(object)Player.m_localPlayer == (Object)null) && __instance == ((Humanoid)Player.m_localPlayer).GetInventory() && API.TryGetSlotIndexAtGridPos(__instance, __result.m_gridPos, out var slotIndex) && ExtendedPlayerInventory.slots[slotIndex] is Model.EquipmentSlot)
				{
					__result.m_equipped = false;
					((Humanoid)Player.m_localPlayer).EquipItem(__result, false);
				}
			}

			[HarmonyPriority(0)]
			private static void Finalizer()
			{
				_itemBeingAdded = null;
			}
		}

		internal static bool IsInMigration;

		internal static bool IsInAutoEquip;

		internal static bool IsInTombstoneTakeAll;

		private static bool _isLoadingInventory;

		private static ItemData? _itemBeingAdded;
	}
	[HarmonyPatch(typeof(MaterialMan), "Update")]
	internal static class MaterialManUpdatePatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(MaterialMan __instance)
		{
			for (int num = __instance.m_containersToUpdate.Count - 1; num >= 0; num--)
			{
				try
				{
					__instance.m_containersToUpdate[num].UpdateBlock();
					__instance.m_containersToUpdate.RemoveAt(num);
				}
				catch
				{
				}
			}
			return false;
		}
	}
	public class PlayerPatches
	{
		[HarmonyPatch(typeof(Player), "Awake")]
		private static class PlayerAwakePatch
		{
			private static void Prefix(Player __instance, Inventory ___m_inventory)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("Player_Awake");
				int fullHeight = API.GetFullHeight(((Humanoid)__instance).m_inventory.GetWidth());
				((Humanoid)__instance).m_inventory.m_height = fullHeight;
				GameObject tombstone = __instance.m_tombstone;
				Container val = ((tombstone != null) ? tombstone.GetComponent<Container>() : null);
				if ((Object)(object)val != (Object)null)
				{
					val.m_height = fullHeight;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class PlayerOnSpawnedPatch
		{
			public const string Sentinel = "<|>";

			public static Inventory QuickSlotInventory = new Inventory("QuickSlotInventory", (Sprite)null, 3, 1);

			public static Inventory EquipmentSlotInventory = new Inventory("EquipmentSlotInventory", (Sprite)null, 5, 1);

			private static readonly MethodInfo MemberwiseCloneMethod = AccessTools.DeclaredMethod(typeof(object), "MemberwiseClone", (Type[])null, (Type[])null);

			public static T Clone<T>(T input) where T : notnull
			{
				return (T)MemberwiseCloneMethod.Invoke(input, Array.Empty<object>());
			}

			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
				{
					VanityPanelController.InvalidateCache();
					if (!Chainloader.PluginInfos.TryGetValue("randyknapp.mods.equipmentandquickslots", out var _))
					{
						Load(__instance);
					}
				}
			}

			public static void Load(Player fromPlayer)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Expected O, but got Unknown
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Expected O, but got Unknown
				if ((Object)(object)fromPlayer == (Object)null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)"Tried to load an ExtendedPlayerData with a null player!");
					return;
				}
				try
				{
					InventoryPatches.IsInMigration = true;
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Starting player data migration from old storage systems");
					LoadValue(fromPlayer, "ExtendedPlayerData", out string _);
					if (LoadValue(fromPlayer, "QuickSlotInventory", out string value2))
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Migrating QuickSlotInventory data");
						ZPackage val = new ZPackage(value2);
						QuickSlotInventory.Load(val);
						((Humanoid)fromPlayer).m_inventory.MoveAll(QuickSlotInventory);
						foreach (ItemData allItem in QuickSlotInventory.GetAllItems())
						{
							if (!((Object)(object)allItem.m_dropPrefab == (Object)null))
							{
								TryAddItemToInventory(fromPlayer, allItem, ((Humanoid)fromPlayer).m_inventory, useItem: false);
							}
						}
						QuickSlotInventory.RemoveAll();
						val = new ZPackage();
						QuickSlotInventory.Save(val);
						SaveValue(fromPlayer, "QuickSlotInventory", val.GetBase64());
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"QuickSlotInventory migration complete");
					}
					if (LoadValue(fromPlayer, "EquipmentSlotInventory", out string value3))
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Migrating EquipmentSlotInventory data");
						ZPackage val2 = new ZPackage(value3);
						EquipmentSlotInventory.Load(val2);
						foreach (ItemData allItem2 in EquipmentSlotInventory.GetAllItems())
						{
							if (!((Object)(object)allItem2.m_dropPrefab == (Object)null))
							{
								TryAddItemToInventory(fromPlayer, allItem2, ((Humanoid)fromPlayer).m_inventory);
							}
						}
						EquipmentSlotInventory.RemoveAll();
						val2 = new ZPackage();
						EquipmentSlotInventory.Save(val2);
						SaveValue(fromPlayer, "EquipmentSlotInventory", val2.GetBase64());
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"EquipmentSlotInventory migration complete");
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Player data migration complete");
				}
				finally
				{
					InventoryPatches.IsInMigration = false;
				}
			}

			private static bool LoadValue(Player player, string key, out string value)
			{
				if (player.m_customData.TryGetValue(key, out value))
				{
					return true;
				}
				if (!player.m_knownTexts.TryGetValue(key, out value))
				{
					key = "<|>" + key;
				}
				bool num = player.m_knownTexts.TryGetValue(key, out value);
				if (num)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"Loaded data from knownTexts. Will be converted to customData on save.");
				}
				return num;
			}

			private static void SaveValue(Player player, string key, string value)
			{
				if (player.m_knownTexts.ContainsKey(key))
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"Found KnownText for save data, converting to customData");
					player.m_knownTexts.Remove(key);
				}
				if (player.m_customData.ContainsKey(key))
				{
					player.m_customData[key] = value;
				}
				else
				{
					player.m_customData.Add(key, value);
				}
			}

			public static void TryAddItemToInventory(Player player, ItemData itemData, Inventory fromInventory, bool useItem = true)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: 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_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				Vector2i val = ((Humanoid)player).m_inventory.FindEmptyQuickAware(itemData, topFirst: true);
				if (val.x >= 0 && val.y >= 0)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Adding " + Localization.instance.Localize(itemData.m_shared.m_name) + " to inventory"));
					fromInventory.RemoveItem(itemData);
					itemData.m_gridPos = val;
					((Humanoid)player).m_inventory.AddItem(itemData);
					if (useItem)
					{
						((Humanoid)player).UseItem(((Humanoid)player).GetInventory(), itemData, false);
					}
					return;
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Dropping " + Localization.instance.Localize(itemData.m_shared.m_name)));
				Transform transform = ((Component)player).transform;
				ItemDrop val2 = ItemDrop.DropItem(itemData, itemData.m_stack, transform.position + transform.forward + transform.up, transform.rotation);
				if (!((Object)(object)val2 == (Object)null))
				{
					if (val2.m_itemData.m_equipped)
					{
						val2.m_itemData.m_equipped = false;
					}
					if (((Humanoid)player).Pickup(((Component)val2).gameObject, false, false) && useItem)
					{
						((Humanoid)player).UseItem(((Humanoid)player).GetInventory(), val2.m_itemData, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class PlayerUpdatePatch
		{
			private static readonly Dictionary<Player, Container> TombstoneContainerCache = new Dictionary<Player, Container>();

			private static void Postfix(Player __instance, ref Inventory ___m_inventory)
			{
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				int width = ___m_inventory.GetWidth();
				int fullHeight = API.GetFullHeight(width);
				___m_inventory.m_height = fullHeight;
				if (!TombstoneContainerCache.TryGetValue(__instance, out Container value))
				{
					GameObject tombstone = __instance.m_tombstone;
					value = ((tombstone != null) ? tombstone.GetComponent<Container>() : null);
					if ((Object)(object)value != (Object)null)
					{
						TombstoneContainerCache[__instance] = value;
					}
				}
				if ((Object)(object)value != (Object)null)
				{
					value.m_height = fullHeight;
				}
				if (InventoryHealth.IgnoreKeyPresses(extra: true) || AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() || AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value == 0)
				{
					return;
				}
				for (int i = 0; i < AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value; i++)
				{
					if (AzuExtendedPlayerInventoryPlugin.Hotkeys[i].Value.IsKeyDown())
					{
						int num = (4 + AzuExtendedPlayerInventoryPlugin.ExtraRows.Value) * width + ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value + i;
						ItemData itemAt = ___m_inventory.GetItemAt(num % width, num / width);
						if (itemAt != null)
						{
							((Humanoid)__instance).UseItem((Inventory)null, itemAt, true);
						}
						break;
					}
				}
			}

			private static void CreateTombStone()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"Height {Player.m_localPlayer.m_tombstone.GetComponent<Container>().m_height}");
				GameObject val = Object.Instantiate<GameObject>(Player.m_localPlayer.m_tombstone, ((Character)Player.m_localPlayer).GetCenterPoint(), ((Component)Player.m_localPlayer).transform.rotation);
				TombStone component = val.GetComponent<TombStone>();
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"Height {val.GetComponent<Container>().m_height}");
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"Inv height {val.GetComponent<Container>().GetInventory().GetHeight()}");
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"Inv slots {val.GetComponent<Container>().GetInventory().GetEmptySlots()}");
				for (int i = 0; i < val.GetComponent<Container>().GetInventory().GetEmptySlots(); i++)
				{
					val.GetComponent<Container>().GetInventory().AddItem("SwordBronze", 1, 1, 0, 0L, "", false);
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"No items: {val.GetComponent<Container>().GetInventory().NrOfItems()}");
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				component.Setup(playerProfile.GetName(), playerProfile.GetPlayerID());
			}
		}
	}
	[HarmonyPatch]
	internal class PreventKeys
	{
		[HarmonyPatch(typeof(ZInput), "TryGetKeyStateLowLevel")]
		[HarmonyPatch(typeof(ZInput), "TryGetButtonState")]
		[HarmonyPatch(typeof(ZInput), "GetKeyDown")]
		private static void Postfix(ref bool __result)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !((Character)Player.m_localPlayer).TakeInput())
			{
				return;
			}
			ConfigEntry<KeyboardShortcut>[] hotkeys = AzuExtendedPlayerInventoryPlugin.Hotkeys;
			for (int i = 0; i < hotkeys.Length; i++)
			{
				if (hotkeys[i].Value.IsKeyDown())
				{
					__result = false;
					break;
				}
			}
		}
	}
	public class TombstonePatches
	{
		[HarmonyPatch(typeof(TombStone), "Awake")]
		private static class TombStoneAwakePatch
		{
			private static void Postfix(TombStone __instance)
			{
				Container component = ((Component)__instance).GetComponent<Container>();
				int height = (component.m_height = API.GetFullHeight(component.m_width));
				if (component.m_inventory != null)
				{
					component.m_inventory.m_height = height;
				}
			}
		}

		[HarmonyPatch(typeof(TombStone), "Interact")]
		private static class TombStoneInteractPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(TombStone __instance, bool hold, Container ___m_container)
			{
				if (hold)
				{
					return;
				}
				int fullHeight = API.GetFullHeight(___m_container.m_width);
				bool flag = ___m_container.m_height < fullHeight;
				bool flag2 = ___m_container.m_inventory != null && ___m_container.m_inventory.m_height < fullHeight;
				if (flag || flag2)
				{
					if (flag)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"TombStone Interact: Adjusting container height {___m_container.m_height} -> {fullHeight}");
						___m_container.m_height = fullHeight;
					}
					if (flag2)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"TombStone Interact: Adjusting inventory height {___m_container.m_inventory.m_height} -> {fullHeight}");
						___m_container.m_inventory.m_height = fullHeight;
					}
					___m_container.m_lastRevision = 0u;
				}
			}
		}

		[HarmonyPatch(typeof(TombStone), "OnTakeAllSuccess")]
		private static class AutoEquipAfterTombstoneGrab
		{
			private static void Postfix(TombStone __instance)
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if (!Object.op_Implicit((Object)(object)localPlayer) || ((Humanoid)localPlayer).GetInventory() == null)
				{
					return;
				}
				FloatingTerrain val = default(FloatingTerrain);
				if (Object.op_Implicit((Object)(object)__instance.m_body) && Player.m_enableAutoPickup && (Object)(object)((Component)((Component)__instance.m_body).transform.root).gameObject != (Object)(object)((Component)__instance).gameObject && ((Component)__instance).TryGetComponent<FloatingTerrain>(ref val))
				{
					val.m_lastHeightmap = null;
					Object.Destroy((Object)(object)((Component)__instance.m_body).gameObject);
				}
				if (AzuExtendedPlayerInventoryPlugin.AutoEquip.Value.isOn())
				{
					Inventory inventory = ((Humanoid)localPlayer).GetInventory();
					foreach (SlotSnapshot equipmentSlotSnapshot in API.GetEquipmentSlotSnapshots(inventory))
					{
						ItemData itemAt = inventory.GetItemAt(equipmentSlotSnapshot.GridPos.x, equipmentSlotSnapshot.GridPos.y);
						if (itemAt != null)
						{
							((Humanoid)localPlayer).EquipItem(itemAt, true);
						}
					}
				}
				Container container = __instance.m_container;
				if (container != null)
				{
					Inventory inventory2 = container.GetInventory();
					if (((inventory2 != null) ? new int?(inventory2.NrOfItems()) : ((int?)null)) > 0)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"TombStone still has {container.GetInventory().NrOfItems()} items after TakeAll, opening container UI");
						container.Interact((Humanoid)(object)localPlayer, false, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(TombStone), "EasyFitInInventory")]
		private static class EasyFitInInventory_SimulateFit
		{
			[HarmonyPriority(200)]
			private static bool Prefix(TombStone __instance, Player player, ref bool __result)
			{
				Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
				Container container = __instance.m_container;
				Inventory val2 = ((container != null) ? container.GetInventory() : null);
				if (val == null || val2 == null)
				{
					return true;
				}
				if (SimulateFit(val2, val))
				{
					return true;
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"EasyFitInInventory simulation: not all items fit – opening container instead of auto-looting.");
				__result = false;
				return false;
			}

			private static bool SimulateFit(Inventory tombInv, Inventory playerInv)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: 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)
				int width = playerInv.GetWidth();
				int normalRows = 4 + AzuExtendedPlayerInventoryPlugin.ExtraRows.Value;
				HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
				foreach (ItemData allItem in playerInv.GetAllItems())
				{
					hashSet.Add(allItem.m_gridPos);
				}
				foreach (ItemData allItem2 in tombInv.GetAllItems())
				{
					Vector2i val = FindVirtualFreePos(playerInv, allItem2, hashSet, width, normalRows);
					if (val.x < 0)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("EasyFitInInventory simulation: '" + allItem2.m_shared.m_name + "' has no available slot."));
						return false;
					}
					hashSet.Add(val);
				}
				return true;
			}

			private static Vector2i FindVirtualFreePos(Inventory inv, ItemData item, HashSet<Vector2i> claimed, int width, int normalRows)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_0032: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				foreach (Vector2i item2 in inv.EnumerateEquipmentCells())
				{
					if (!claimed.Contains(item2) && API.TryGetSlotIndexAtGridPos(inv, item2, out var slotIndex) && API.SlotValidates(slotIndex, item))
					{
						return item2;
					}
				}
				Vector2i val = default(Vector2i);
				for (int i = 0; i < normalRows; i++)
				{
					for (int j = 0; j < width; j++)
					{
						((Vector2i)(ref val))..ctor(j, i);
						if (!claimed.Contains(val))
						{
							return val;
						}
					}
				}
				foreach (Vector2i item3 in inv.EnumerateQuickCells())
				{
					if (!claimed.Contains(item3))
					{
						return item3;
					}
				}
				return new Vector2i(-1, -1);
			}
		}

		[HarmonyPatch(typeof(TombStone), "EasyFitInInventory")]
		private static class TemporarilyIncreaseCarryWeightAndInventoryHeight
		{
			private struct TempState
			{
				public int Height;

				public float TempWeight;

				public bool PrevPickup;

				public bool ChangedPickup;
			}

			private static void Prefix(TombStone __instance, Player player, out TempState __state)
			{
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				__state = default(TempState);
				__state.PrevPickup = Player.m_enableAutoPickup;
				if (Player.m_enableAutoPickup)
				{
					Player.m_enableAutoPickup = false;
					__state.ChangedPickup = true;
				}
				float num = 0f;
				float num2 = num;
				StatusEffect obj = __instance?.m_lootStatusEffect;
				SE_Stats val = (SE_Stats)(object)((obj is SE_Stats) ? obj : null);
				num = num2 + ((val != null && val.m_addMaxCarryWeight > 0f) ? val.m_addMaxCarryWeight : 0f);
				object obj2;
				if (__instance == null)
				{
					obj2 = null;
				}
				else
				{
					Container container = __instance.m_container;
					obj2 = ((container != null) ? container.GetInventory() : null);
				}
				Inventory val2 = (Inventory)obj2;
				float num3 = 0f;
				if (val2 != null)
				{
					foreach (ItemData allItem in val2.GetAllItems())
					{
						StatusEffect obj3 = allItem?.m_shared?.m_equipStatusEffect;
						SE_Stats val3 = (SE_Stats)(object)((obj3 is SE_Stats) ? obj3 : null);
						if (val3 != null && val3.m_addMaxCarryWeight > 0f && API.TryGetSlotIndexAtGridPos(val2, allItem.m_gridPos, out var slotIndex) && API.SlotValidates(slotIndex, allItem))
						{
							num3 += val3.m_addMaxCarryWeight;
						}
					}
				}
				num += num3;
				__state.TempWeight += num + 150f;
				__state.Height = 0;
				player.m_maxCarryWeight += __state.TempWeight;
			}

			private static void Finalizer(Player player, TempState __state)
			{
				if (__state.ChangedPickup)
				{
					Player.m_enableAutoPickup = __state.PrevPickup;
				}
				player.m_maxCarryWeight -= __state.TempWeight;
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
	internal static class InventoryGridQueuedFillPatch
	{
		private static readonly Dictionary<GameObject, Image> FillOverlays = new Dictionary<GameObject, Image>();

		[HarmonyPriority(0)]
		private static void Postfix(InventoryGrid __instance, Player player)
		{
			if (!Object.op_Implicit((Object)(object)player))
			{
				return;
			}
			foreach (Element element in __instance.m_elements)
			{
				if (Object.op_Implicit((Object)(object)element.m_queued))
				{
					object obj;
					if (!element.m_used)
					{
						obj = null;
					}
					else
					{
						Inventory inventory = __instance.m_inventory;
						obj = ((inventory != null) ? inventory.GetItemAt(element.m_pos.x, element.m_pos.y) : null);
					}
					ItemData item = (ItemData)obj;
					UpdateFillOverlay(((Component)element.m_queued).gameObject, element.m_queued, player, item);
				}
			}
		}

		public static void UpdateFillOverlay(GameObject queuedGo, Image? sourceImage, Player player, ItemData? item)
		{
			if ((Object)(object)queuedGo == (Object)null)
			{
				return;
			}
			if (sourceImage == null)
			{
				sourceImage = queuedGo.GetComponent<Image>();
			}
			if ((Object)(object)sourceImage == (Object)null)
			{
				return;
			}
			Image orCreateFillOverlay = GetOrCreateFillOverlay(queuedGo, sourceImage);
			if (item == null)
			{
				orCreateFillOverlay.fillAmount = 0f;
				((Behaviour)orCreateFillOverlay).enabled = false;
				return;
			}
			bool isActivelyEquipping;
			bool isQueuedWaiting;
			float equipProgress = GetEquipProgress(player, item, out isActivelyEquipping, out isQueuedWaiting);
			if (isActivelyEquipping)
			{
				((Behaviour)sourceImage).enabled = false;
				orCreateFillOverlay.fillAmount = equipProgress;
				((Behaviour)orCreateFillOverlay).enabled = true;
			}
			else if (isQueuedWaiting)
			{
				((Behaviour)sourceImage).enabled = false;
				orCreateFillOverlay.fillAmount = 1f;
				((Behaviour)orCreateFillOverlay).enabled = true;
			}
			else
			{
				orCreateFillOverlay.fillAmount = 0f;
				((Behaviour)orCreateFillOverlay).enabled = false;
			}
		}

		private static Image GetOrCreateFillOverlay(GameObject queuedGo, Image sourceImage)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_008e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (FillOverlays.TryGetValue(queuedGo, out Image value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			GameObject val = new GameObject("FillOverlay", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(queuedGo.transform.parent, false);
			RectTransform component = queuedGo.GetComponent<RectTransform>();
			RectTransform component2 = val.GetComponent<RectTransform>();
			component2.anchorMin = component.anchorMin;
			component2.anchorMax = component.anchorMax;
			component2.anchoredPosition = component.anchoredPosition;
			component2.sizeDelta = component.sizeDelta;
			component2.pivot = component.pivot;
			val.transform.SetSiblingIndex(queuedGo.transform.GetSiblingIndex() + 1);
			Image component3 = val.GetComponent<Image>();
			component3.sprite = sourceImage.sprite;
			((Graphic)component3).color = ((Graphic)sourceImage).color;
			component3.type = (Type)3;
			component3.fillMethod = (FillMethod)1;
			component3.fillOrigin = 0;
			component3.fillAmount = 0f;
			((Graphic)component3).raycastTarget = false;
			((Behaviour)component3).enabled = false;
			FillOverlays[queuedGo] = component3;
			return component3;
		}

		public static float GetEquipProgress(Player player, ItemData item, out bool isActivelyEquipping, out bool isQueuedWaiting)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			isActivelyEquipping = false;
			isQueuedWaiting = false;
			if (item == null || (Object)(object)player == (Object)null)
			{
				return 0f;
			}
			for (int i = 0; i < player.m_actionQueue.Count; i++)
			{
				MinorActionData val = player.m_actionQueue[i];
				if (val.m_item != item || ((int)val.m_type != 0 && (int)val.m_type != 1))
				{
					continue;
				}
				if (i == 0)
				{
					isActivelyEquipping = true;
					if (!(val.m_duration <= 0f))
					{
						return Mathf.Clamp01(val.m_time / val.m_duration);
					}
					return 1f;
				}
				isQueuedWaiting = true;
				return 1f;
			}
			return 0f;
		}

		public static float GetEquipProgress(Player player, ItemData item)
		{
			bool isActivelyEquipping;
			bool isQueuedWaiting;
			return GetEquipProgress(player, item, out isActivelyEquipping, out isQueuedWaiting);
		}

		public static void ClearCache()
		{
			foreach (Image value in FillOverlays.Values)
			{
				if ((Object)(object)value != (Object)null && (Object)(object)((Component)value).gameObject != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			FillOverlays.Clear();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
	internal static class InventoryGuiOnDestroyQueuedFillPatch
	{
		private static void Postfix()
		{
			InventoryGridQueuedFillPatch.ClearCache();
		}
	}
	[HarmonyPatch(typeof(Hud), "Awake")]
	internal static class HudAwakePatch
	{
		public static List<GameObject> actionBarChildren = new List<GameObject>();

		private static void Postfix(Hud __instance)
		{
			if (actionBarChildren.Count > 0)
			{
				actionBarChildren.Clear();
			}
			Transform[] componentsInChildren = __instance.m_actionBarRoot.GetComponentsInChildren<Transform>();
			foreach (Transform val in componentsInChildren)
			{
				actionBarChildren.Add(((Component)val).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(Hud), "UpdateActionProgress")]
	internal static class HudUpdateActionProgressPatch
	{
		private static void Prefix(Hud __instance)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || localPlayer.m_actionQueue.Count <= 0 || HudAwakePatch.actionBarChildren.Count <= 0)
			{
				return;
			}
			ActionType type = localPlayer.m_actionQueue[0].m_type;
			if ((int)type <= 1)
			{
				foreach (GameObject actionBarChild in HudAwakePatch.actionBarChildren)
				{
					actionBarChild.SafeSetActive(active: false);
				}
				return;
			}
			foreach (GameObject actionBarChild2 in HudAwakePatch.actionBarChildren)
			{
				actionBarChild2.SafeSetActive(active: true);
			}
		}
	}
	[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
	internal static class VanillaHotkeyBarFillPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(HotkeyBar __instance, Player player)
		{
			if (((Object)__instance).name == "AzuEPI_QuickAccessBar" || !Object.op_Implicit((Object)(object)player))
			{
				return;
			}
			foreach (ElementData element in __instance.m_elements)
			{
				ItemData item = null;
				if (element.m_used)
				{
					int num = __instance.m_elements.IndexOf(element);
					foreach (ItemData item2 in __instance.m_items)
					{
						if (item2.m_gridPos.x == num && item2.m_gridPos.y == 0)
						{
							item = item2;
							break;
						}
					}
				}
				InventoryGridQueuedFillPatch.UpdateFillOverlay(element.m_queued, null, player, item);
			}
		}
	}
	[HarmonyPatch(typeof(Hud), "OnDestroy")]
	internal static class HudOnDestroyFillCachePatch
	{
		private static void Postfix()
		{
			InventoryGridQueuedFillPatch.ClearCache();
		}
	}
}
namespace AzuEPI.Game.Loadout
{
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class PlayerSpawnedPatch
	{
		private static void Postfix(Player __instance)
		{
			try
			{
				GameObject gameObject = ((Component)StoreGui.instance).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)"StoreGui.instance is null");
					return;
				}
				Transform backgroundParent = CreateBackground(InventoryGui.instance);
				CreateMainPanel(gameObject, __instance, backgroundParent, out GameObject _, out PersonalLoadoutGui _);
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)("Exception: " + ex));
			}
		}

		private static void CreateMainPanel(GameObject rootPanel, Player player, Transform backgroundParent, out GameObject clonedRootPanel, out PersonalLoadoutGui gui)
		{
			//IL_0038: 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_0062: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(rootPanel, backgroundParent, false);
			((Object)val).name = "AzuEPI_LoadoutsRootPanel";
			val.GetComponent<Canvas>().sortingOrder = 699;
			clonedRootPanel = val;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.offsetMin = new Vector2(0f, 0f);
			component.offsetMax = new Vector2(0f, 0f);
			((Transform)component).localScale = Vector3.one;
			component.anchoredPosition = new Vector2(-135f, 0f);
			PersonalLoadoutGui personalLoadoutGui = val.AddComponent<PersonalLoadoutGui>();
			if ((Object)(object)personalLoadoutGui == (Object)null)
			{
				gui = null;
				return;
			}
			gui = personalLoadoutGui;
			PersonalLoadoutGui.m_rootPanel = val.gameObject;
			PersonalLoadoutGui.m_rootPanel.GetOrAddComponent<Localize>();
			PersonalLoadoutGui.m_storeRootPanel = ((Component)Utils.FindChild(val.transform, "Store", (IterativeSearchType)0)).gameObject;
			PersonalLoadoutGui.m_storeRootPanel.GetComponent<RectTransform>().anchoredPosition = new Vector2(166f, -50f);
			((Component)Utils.FindChild(val.transform, "border (1)", (IterativeSearchType)0)).gameObject.SetActive(false);
			personalLoadoutGui.m_chooseButton = ((Component)Utils.FindChild(val.transform, "BuyButton", (IterativeSearchType)0)).GetComponent<Button>();
			((Component)((Component)personalLoadoutGui.m_chooseButton).transform.Find("Text")).GetComponent<TMP_Text>().text = Localization.instance.Localize("$azu_epi_equipLoadout");
			PanelUtilities.BindGamePad(((Component)personalLoadoutGui.m_chooseButton).transform, "JoyButtonA", (KeyCode)330);
			personalLoadoutGui.m_sellButton = ((Component)Utils.FindChild(val.transform, "SellButton", (IterativeSearchType)0)).GetComponent<Button>();
			((Component)personalLoadoutGui.m_sellButton).GetComponent<UITooltip>().m_text = Localization.instance.Localize("$azu_epi_equipSelected");
			((Component)((Component)personalLoadoutGui.m_sellButton).transform.Find("Image")).gameObject.SetActive(false);
			((Component)((Component)personalLoadoutGui.m_sellButton).transform.Find("Image (1)")).gameObject.SetActive(true);
			((Component)((Component)personalLoadoutGui.m_sellButton).transform.parent).gameObject.SetActive(false);
			PersonalLoadoutGui.m_listRoot = ((Component)Utils.FindChild(val.transform, "ListRoot", (IterativeSearchType)0)).GetComponent<RectTransform>();
			PersonalLoadoutGui.m_listElement = ((Component)Utils.FindChild(val.transform, "ItemElement", (IterativeSearchType)0)).gameObject;
			personalLoadoutGui.m_listScroll = ((Component)Utils.FindChild(val.transform, "ItemScroll", (IterativeSearchType)0)).GetComponent<Scrollbar>();
			PersonalLoadoutGui.m_itemEnsureVisible = ((Component)Utils.FindChild(val.transform, "Items", (IterativeSearchType)0)).GetComponent<ScrollRectEnsureVisible>();
			personalLoadoutGui.m_coinText = ((Component)val.transform.Find("Store/coins/coins")).GetComponent<TMP_Text>();
			personalLoadoutGui.m_coinIcon = ((Component)val.transform.Find("Store/coins/coin icon")).GetComponent<Image>();
			RectTransform component2 = ((Component)val.transform.Find("Store/coins/coin icon")).GetComponent<RectTransform>();
			component2.anchoredPosition += new Vector2(0f, 5f);
			RectTransform component3 = ((Component)val.transform.Find("Store/coins")).GetComponent<RectTransform>();
			component3.anchoredPosition += new Vector2(35f, 0f);
			val.transform.Find("Store/coins").SafeSetActive(active: false);
			personalLoadoutGui.m_topicText = ((Component)Utils.FindChild(val.transform, "topic", (IterativeSearchType)0)).GetComponent<TMP_Text>();
			personalLoadoutGui.m_buyEffects = val.GetComponent<StoreGui>().m_buyEffects;
			personalLoadoutGui.m_sellEffects = val.GetComponent<StoreGui>().m_sellEffects;
			personalLoadoutGui.m_hideDistance = val.GetComponent<StoreGui>().m_hideDistance;
			PersonalLoadoutGui.m_itemSpacing = val.GetComponent<StoreGui>().m_itemSpacing;
			PersonalLoadoutGui.m_coinPrefab = val.GetComponent<StoreGui>().m_coinPrefab;
			PersonalLoadoutGui.m_itemlistBaseSize = val.GetComponent<StoreGui>().m_itemlistBaseSize;
			Object.DestroyImmediate((Object)(object)val.GetComponent<StoreGui>());
			CreateLoadoutInventoryGrid(val, player);
		}

		private static void CreateLoadoutInventoryGrid(GameObject panel, Player player)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002e: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			GameObject val = new GameObject("AzuEPI_LoadoutGridContainer");
			val.transform.SetParent(panel.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(1f, 0.5f);
			obj.anchorMax = new Vector2(1f, 0.5f);
			obj.pivot = new Vector2(0f, 0.5f);
			obj.anchoredPosition = new Vector2(-220f, 0f);
			obj.sizeDelta = new Vector2(400f, 400f);
			PersonalLoadoutGui.m_loadoutInventory = new Inventory("Loadout View", (Sprite)null, 4, 8);
			InventoryGrid playerGrid = InventoryGui.instance.m_playerGrid;
			PersonalLoadoutGui.m_loadoutGrid = val.AddComponent<InventoryGrid>();
			PersonalLoadoutGui.m_loadoutGrid.m_elementPrefab = playerGrid.m_elementPrefab;
			PersonalLoadoutGui.m_loadoutGrid.m_gridRoot = val.GetComponent<RectTransform>();
			PersonalLoadoutGui.m_loadoutGrid.m_elementSpace = 70f;
			PersonalLoadoutGui.m_loadoutGrid.m_width = 0;
			PersonalLoadoutGui.m_loadoutGrid.m_height = 0;
			UIGroupHandler val2 = val.AddComponent<UIGroupHandler>();
			val2.m_active = false;
			PersonalLoadoutGui.m_loadoutGrid.m_uiGroup = val2;
			PersonalLoadoutGui.m_loadoutGrid.m_onSelected = OnLoadoutGridItemSelected;
			PersonalLoadoutGui.m_loadoutGrid.m_onRightClick = OnLoadoutGridItemRightClick;
			PersonalLoadoutGui.m_loadoutGridRoot = val;
		}

		private static void OnLoadoutGridItemSelected(InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Invalid comparison between Unknown and I4
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if ((Object)(object)instance.m_dragGo != (Object)null && instance.m_dragItem != null)
			{
				ItemData dragItem = instance.m_dragItem;
				Inventory dragInventory = instance.m_dragInventory;
				int dragAmount = instance.m_dragAmount;
				if (dragInventory == null)
				{
					return;
				}
				if (!dragItem.m_shared.m_teleportable)
				{
					Localization instance2 = Localization.instance;
					((Character)localPlayer).Message((MessageType)2, (instance2 != null) ? instance2.Localize("$msg_blocked $item_noteleport") : null, 0, (Sprite)null);
				}
				else if (Object.op_Implicit((Object)(object)dragItem.m_dropPrefab) && (AdvBackpacksCompat.Backpacks.Contains(((Object)dragItem.m_dropPrefab).name) || RustyBagsCompat.Backpacks.Contains(((Object)dragItem.m_dropPrefab).name) || ((Object)dragItem.m_dropPrefab).name == "bp_explorer" || ((Object)dragItem.m_dropPrefab).name == "JC_Gem_Bag"))
				{
					Localization instance3 = Localization.instance;
					((Character)localPlayer).Message((MessageType)2, (instance3 != null) ? instance3.Localize("$msg_blocked $piece_armorstand_cantattach") : null, 0, (Sprite)null);
				}
				else if (PersonalLoadoutGui.m_loadoutInventory.AddItem(dragItem, dragAmount, pos.x, pos.y))
				{
					if (dragItem.m_stack <= 0)
					{
						((Humanoid)localPlayer).UnequipItem(dragItem, true);
						dragInventory.RemoveItem(dragItem);
					}
					UpdateLoadoutFromInventory();
					PersonalLoadoutGui.RefreshLoadoutInventory();
					instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
				}
			}
			else if ((int)mod == 2 && item != null && ((Humanoid)localPlayer).GetInventory().AddItem(item.Clone()))
			{
				PersonalLoadoutGui.m_loadoutInventory.RemoveItem(item);
				UpdateLoadoutFromInventory();
				PersonalLoadoutGui.RefreshLoadoutInventory();
			}
		}

		private static void OnLoadoutGridItemRightClick(InventoryGrid grid, ItemData item, Vector2i pos)
		{
			if (item != null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory().AddItem(item.Clone()))
				{
					PersonalLoadoutGui.m_loadoutInventory.RemoveItem(item);
					UpdateLoadoutFromInventory();
					PersonalLoadoutGui.RefreshLoadoutInventory();
				}
			}
		}

		private static void UpdateLoadoutFromInventory()
		{
			if (!string.IsNullOrWhiteSpace(PersonalLoadoutGui.m_selectedItem))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					string key = "AzuEPILoadout_" + PersonalLoadoutGui.m_selectedItem;
					List<ItemData> allItems = PersonalLoadoutGui.m_loadoutInventory.GetAllItems();
					PersonalLoadout personalLoadout = new PersonalLoadout(PersonalLoadoutGui.m_selectedItem, allItems);
					localPlayer.m_customData[key] = personalLoadout.Serialize();
					PersonalLoadoutGui.FillList();
				}
			}
		}

		private static Transform CreateBackground(InventoryGui gui)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			RectTransform crafting = gui.m_crafting;
			Transform val = ((Transform)crafting).Find("Bkg");
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			Transform obj = Object.Instantiate<Transform>(val, (Transform)(object)crafting);
			((Object)obj).name = "AzuEPI_LoadoutPanel";
			RectTransform val2 = (RectTransform)((Component)obj).transform;
			val2.anchorMin = ((Component)val).GetComponent<RectTransform>().anchorMin;
			val2.anchorMax = ((Component)val).GetComponent<RectTransform>().anchorMax;
			((Transform)val2).SetAsLastSibling();
			Image component = ((Component)obj).GetComponent<Image>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((Graphic)component).raycastTarget = false;
				((Behaviour)component).enabled = true;
			}
			((Component)obj).gameObject.SetActive(false);
			return obj;
		}
	}
	internal static class EpiSwapContext
	{
		private sealed class Scope : IDisposable
		{
			public void Dispose()
			{
				Active = false;
			}
		}

		public static bool Active { get; private set; }

		public static IDisposable Begin()
		{
			Active = true;
			return new Scope();
		}
	}
	public class PersonalLoadoutGui : MonoBehaviour, TextReceiver
	{
		public static PersonalLoadoutGui? m_instance;

		public static GameObject m_rootPanel = null;

		public static GameObject m_storeRootPanel = null;

		public Button m_chooseButton;

		public Button m_sellButton;

		public static InventoryGrid m_loadoutGrid = null;

		public static Inventory m_loadoutInventory = null;

		public static GameObject m_loadoutGridRoot = null;

		public static RectTransform m_listRoot = null;

		public static GameObject m_listElement = null;

		public Scrollbar m_listScroll;

		public static ScrollRectEnsureVisible m_itemEnsureVisible = null;

		public TMP_Text m_coinText;

		public Image m_coinIcon;

		public TMP_Text m_topicText;

		public EffectList m_buyEffects = new EffectList();

		public EffectList m_sellEffects = new EffectList();

		public float m_hideDistance = 5f;

		public static float m_itemSpacing = 64f;

		public static ItemDrop m_coinPrefab = null;

		public static List<GameObject> m_itemList = new List<GameObject>();

		public static string? m_selectedItem;

		public static Player? m_LocalPlayerRef;

		public static float m_itemlistBaseSize;

		public List<ItemData> m_tempItems = new List<ItemData>();

		private static List<ItemSet?> availableSets = new List<ItemSet>();

		public static bool PanelActive;

		public const string LoadoutKey = "AzuEPILoadout_";

		public const string LoadoutNameKey = "AzuEPILoadoutName_";

		public static Transform LoadoutsToggleButton = null;

		private static Button _toggleBtn;

		internal static int tempInventorySize = 0;

		internal static RectTransform ToggleButtonParentGlg = null;

		private static string? m_loadoutBeingRenamed;

		public static PersonalLoadoutGui? instance => m_instance;

		public void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			m_instance = this;
			if ((Object)(object)m_storeRootPanel != (Object)null)
			{
				m_storeRootPanel.SetActive(false);
			}
			if ((Object)(object)m_listRoot != (Object)null)
			{
				Rect rect = m_listRoot.rect;
				m_itemlistBaseSize = ((Rect)(ref rect)).height;
			}
			m_chooseButton.onClick = new ButtonClickedEvent();
			((UnityEvent)m_chooseButton.onClick).AddListener(new UnityAction(OnChooseLoadout));
			m_topicText.text = Localization.instance.Localize("$azu_epi_loadouts");
		}

		public void OnDestroy()
		{
			if ((Object)(object)m_instance == (Object)(object)this)
			{
				m_instance = null;
			}
		}

		public void HandleUIUpdates()
		{
			if (ShouldHide() || ShouldClose())
			{
				Hide();
			}
			else
			{
				UpdateUI();
			}
		}

		private bool ShouldHide()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead() || ((Character)localPlayer).InCutscene())
			{
				return true;
			}
			if (InventoryGui.IsVisible())
			{
				return Minimap.IsOpen();
			}
			return true;
		}

		private static bool ShouldClose()
		{
			Player localPlayer = Player.m_localPlayer;
			if (((!((Object)(object)Chat.instance != (Object)null) || !Chat.instance.HasFocus()) && !Console.IsVisible() && !Menu.IsVisible() && (!((Object)(object)TextViewer.instance != (Object)null) || !TextViewer.instance.IsVisible()) && !((Character)localPlayer).InCutscene()) || (!ZInput.GetButtonDown("JoyButtonB") && !Input.GetKeyDown((KeyCode)27) && !ZInput.GetButtonDown("Use")))
			{
				return false;
			}
			ZInput.ResetButtonStatus("JoyButtonB");
			return true;
		}

		private void UpdateUI()
		{
			UpdateSwitchLoadoutButton();
			UpdateRecipeGamepadInput();
			m_coinText.text = GetNumberOfLoadouts().ToString();
		}

		public static void Show()
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !IsVisible())
			{
				m_LocalPlayerRef = Player.m_localPlayer;
				((Component)InventoryGui.instance.m_dropButton).gameObject.SetActive(false);
				((Component)m_rootPanel.transform.parent).gameObject.SetActive(true);
				m_rootPanel.SetActive(true);
				m_storeRootPanel.SetActive(true);
				if ((Object)(object)m_loadoutGridRoot != (Object)null)
				{
					m_loadoutGridRoot.SetActive(true);
				}
				PanelActive = true;
				FillList();
				RefreshLoadoutInventory();
				m_listRoot.sizeDelta = Vector2.zero;
				((Component)((Transform)m_listRoot).parent).GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 1f);
			}
		}

		public static void Hide()
		{
			m_LocalPlayerRef = null;
			((Component)m_rootPanel.transform.parent).gameObject.SetActive(false);
			m_rootPanel.SetActive(false);
			m_storeRootPanel.SetActive(false);
			if ((Object)(object)m_loadoutGridRoot != (Object)null)
			{
				m_loadoutGridRoot.SetActive(false);
			}
			PanelActive = false;
			((Component)InventoryGui.instance.m_dropButton).gameObject.SetActive(true);
		}

		public static void ToggleUI()
		{
			if (IsVisible())
			{
				Hide();
				return;
			}
			Show();
			VanityPanelController.SetVisible(visible: false);
			StatsPanelController.Hide();
		}

		public static bool IsVisible()
		{
			if (!Object.op_Implicit((Object)(object)m_instance) || !m_storeRootPanel.activeSelf)
			{
				return PanelActive;
			}
			return true;
		}

		public void OnChooseLoadout()
		{
			LoadSelectedLoadout();
		}

		public void LoadSelectedLoadout()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(m_selectedItem))
			{
				LoadLoadout(m_selectedItem);
				m_buyEffects.Create(((Component)this).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				FillList();
				RefreshLoadoutInventory();
			}
		}

		internal static void BuildLoadoutToggleButton(InventoryGui gui)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			PanelUtilities.ButtonConfig config = new PanelUtilities.ButtonConfig("AzuEPI_LoadoutsToggleButton", new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(-205f, -30f), new Vector2(120f, 32f), PanelUtilities.KeyCodeToZInputKey(AzuExtendedPlayerInventoryPlugin.LoadoutToggleGamepadKey.Value), AzuExtendedPlayerInventoryPlugin.LoadoutToggleGamepadKey.Value, "\ud83d\udccb", 36f, delegate
			{
				ToggleUI();
				if (Object.op_Implicit((Object)(object)InventoryGui.instance))
				{
					PanelUtilities.HideCraftingElements(IsVisible());
				}
			});
			(LoadoutsToggleButton, _toggleBtn) = PanelUtilities.BuildToggleButton(gui, (Transform)(object)ToggleButtonParentGlg, config);
			((Component)LoadoutsToggleButton).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.LoadoutOption.Value.isOn());
		}

		public static int GetNumberOfLoadouts()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0;
			}
			return localPlayer.m_customData.Keys.Count((string key) => key.StartsWith("AzuEPILoadout_"));
		}

		public static List<string> GetAvailableLoadouts()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return new List<string>();
			}
			List<string> list = new List<string>();
			foreach (string key in localPlayer.m_customData.Keys)
			{
				if (key.StartsWith("AzuEPILoadout_"))
				{
					list.Add(key.Replace("AzuEPILoadout_", ""));
				}
			}
			return list;
		}

		public static bool SaveLoadout(string loadoutName)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			string text = "AzuEPILoadout_" + loadoutName;
			List<ItemData> equippedItemsFiltered = ((Humanoid)localPlayer).GetInventory().GetEquippedItemsFiltered();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"SaveLoadout: Saving loadout '{loadoutName}' with {equippedItemsFiltered.Count} items.");
			foreach (ItemData item in equippedItemsFiltered)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$" - {item.m_shared.m_name} x{item.m_stack}");
			}
			PersonalLoadout personalLoadout = new PersonalLoadout(loadoutName, equippedItemsFiltered);
			localPlayer.m_customData[text] = personalLoadout.Serialize();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("SaveLoadout: Key '" + text + "' created successfully."));
			return true;
		}

		private static void SaveEquippedItems(Player player, Inventory inventory)
		{
			List<ItemData> equippedItemsFiltered = ((Humanoid)player).GetInventory().GetEquippedItemsFiltered();
			if (equippedItemsFiltered != null && equippedItemsFiltered.Count > 0)
			{
				for (int i = 0; i < equippedItemsFiltered.Count; i++)
				{
					ItemData val = equippedItemsFiltered[i];
					inventory.AddItem(val.Clone());
				}
			}
		}

		public static void LoadLoadout(string loadoutName)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			string key = "AzuEPILoadout_" + loadoutName;
			if (!localPlayer.m_customData.TryGetValue(key, out var value))
			{
				return;
			}
			string text = value;
			PersonalLoadout loadout = PersonalLoadout.Deserialize(loadoutName, value);
			using (EpiSwapContext.Begin())
			{
				SaveLoadout(loadoutName);
				UnequipAndRemoveCurrentItems(localPlayer);
				if (!EquipItemsFromLoadout(localPlayer, loadout))
				{
					PersonalLoadout loadout2 = PersonalLoadout.Deserialize(loadoutName, text);
					EquipItemsFromLoadout(localPlayer, loadout2);
					localPlayer.m_customData[key] = text;
				}
				((Humanoid)localPlayer).m_visEquipment.UpdateVisuals();
			}
		}

		private static bool EquipItemsFromLoadout(Player player, PersonalLoadout loadout)
		{
			List<ItemData> items = loadout.Items;
			if (((Humanoid)player).GetInventory().GetEmptySlots() >= items.Count)
			{
				for (int i = 0; i < items.Count; i++)
				{
					ItemData val = items[i];
					if (val == null)
					{
						continue;
					}
					if (val.m_equipped)
					{
						val.m_equipped = false;
					}
					string targetName = val.m_shared.m_name;
					long targetCrafterID = val.m_crafterID;
					string targetCrafterName = val.m_crafterName;
					float targetDurability = val.m_durability;
					int targetQuality = val.m_quality;
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Attempting to add item: " + targetName));
					bool flag = ((Humanoid)player).GetInventory().AddItem(val);
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Move result: " + flag));
					if (flag)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Equipping item: " + targetName));
						ItemData val2 = null;
						if (((Humanoid)player).GetInventory().ContainsItem(val))
						{
							val2 = val;
							AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Using original item reference");
						}
						else
						{
							val2 = ((IEnumerable<ItemData>)((Humanoid)player).GetInventory().GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData val3) => val3.m_shared.m_name == targetName && val3.m_crafterID == targetCrafterID && val3.m_crafterName == targetCrafterName && val3.m_quality == targetQuality && Math.Abs(val3.m_durability - targetDurability) < 0.01f && !val3.m_equipped));
						}
						if (val2 == null)
						{
							val2 = ((IEnumerable<ItemData>)((Humanoid)player).GetInventory().GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData val3) => val3.m_shared.m_name == targetName && val3.m_quality == targetQuality && !val3.m_equipped));
						}
						if (val2 != null && !AzuExtendedPlayerInventoryPlugin.AutoEquip.Value.isOff() && ((Humanoid)player).EquipItem(val2, false))
						{
							AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Successfully equipped " + val2.m_shared.m_name));
						}
					}
					else
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)("Failed to add item " + val.m_shared.m_name + " to inventory during loadout restore!"));
					}
				}
				return true;
			}
			((Character)player).Message((MessageType)2, "Not enough room in inventory.", 0, (Sprite)null);
			return false;
		}

		private static void UnequipAndRemoveCurrentItems(Player player)
		{
			List<ItemData> equippedItemsFiltered = ((Humanoid)player).GetInventory().GetEquippedItemsFiltered();
			for (int i = 0; i < equippedItemsFiltered.Count; i++)
			{
				ItemData val = equippedItemsFiltered[i];
				((Humanoid)player).UnequipItem(val, true);
				val.m_equipped = false;
				((Humanoid)player).GetInventory().RemoveItem(val);
			}
		}

		private static void UnequipToBags(Player player)
		{
			foreach (ItemData item in ((Humanoid)player).GetInventory().GetEquippedItemsFiltered())
			{
				((Humanoid)player).UnequipItem(item, true);
				if (!((Humanoid)player).GetInventory().AddItem(item))
				{
					((Humanoid)player).EquipItem(item, true);
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("No space to unequip " + item.m_shared.m_name));
				}
			}
		}

		public static void FillList()
		{
			//IL_00c3: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Expected O, but got Unknown
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: 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_03a5: Expected O, but got Unknown
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			List<string> availableLoadouts = GetAvailableLoadouts();
			int num = GetSelectedItemIndex();
			foreach (GameObject item in m_itemList)
			{
				Object.Destroy((Object)(object)item);
			}
			m_itemList.Clear();
			m_listRoot.SetSizeWithCurrentAnchors((Axis)1, Mathf.Max(m_itemlistBaseSize, (float)availableLoadouts.Count * m_itemSpacing));
			for (int i = 0; i < availableLoadouts.Count; i++)
			{
				string text = availableLoadouts[i];
				GameObject element = Object.Instantiate<GameObject>(m_listElement, (Transform)(object)m_listRoot);
				element.SetActive(true);
				Transform transform = element.transform;
				((RectTransform)((transform is RectTransform) ? transform : null)).anchoredPosition = new Vector2(0f, (float)i * (0f - m_itemSpacing));
				Image component = ((Component)element.transform.Find("icon")).GetComponent<Image>();
				if (!Player.m_localPlayer.m_customData.TryGetValue("AzuEPILoadout_" + text, out var value))
				{
					continue;
				}
				PersonalLoadout personalLoadout = PersonalLoadout.Deserialize(text, value);
				if (personalLoadout.Items.Count > 0)
				{
					ItemData val = personalLoadout.Items[0];
					component.sprite = val.m_shared.m_icons[0];
				}
				else
				{
					component.sprite = null;
				}
				bool flag = personalLoadout.Items.Count > 0;
				((Graphic)component).color = (Color)(flag ? Color.white : new Color(1f, 0f, 1f, 0f));
				TMP_Text component2 = ((Component)element.transform.Find("name")).GetComponent<TMP_Text>();
				string loadoutCustomName = GetLoadoutCustomName(text);
				component2.text = Localization.instance.Localize(loadoutCustomName);
				((Graphic)component2).color = (flag ? Color.white : Color.grey);
				UITooltip component3 = element.GetComponent<UITooltip>();
				component3.m_topic = loadoutCustomName;
				component3.m_text = (flag ? ("$azu_epi_loadouts_load:\n" + string.Join("\n", personalLoadout.Items.Select((ItemData val2) => Localization.instance.Localize(val2.m_shared.m_name)))) : "$azu_epi_loadouts_empty");
				((UnityEvent)element.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					OnSelectedLoadout(element);
				});
				if ((Object)(object)element.GetComponent<Button>() != (Object)null)
				{
					Transform obj = PanelUtilities.CloneButton(((Component)instance.m_chooseButton).transform, element.transform, "RenameButton", new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-10f, 0f), new Vector2(30f, 30f));
					Button component4 = ((Component)obj).GetComponent<Button>();
					((UnityEventBase)component4.onClick).RemoveAllListeners();
					TMP_Text componentInChildren = ((Component)obj).GetComponentInChildren<TMP_Text>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.text = "R";
						componentInChildren.fontSize = 18f;
						componentInChildren.fontStyle = (FontStyles)1;
						componentInChildren.alignment = (TextAlignmentOptions)514;
						((Graphic)componentInChildren).color = Color.white;
					}
					PanelUtilities.BindGamePad(obj, "", (KeyCode)0);
					UITooltip component5 = ((Component)obj).GetComponent<UITooltip>();
					if ((Object)(object)component5 != (Object)null)
					{
						component5.m_text = "$azu_epi_loadout_rename_tooltip";
						component5.m_topic = "";
					}
					string currentLoadoutId = text;
					((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
					{
						RequestRenameLoadout(currentLoadoutId);
					});
				}
				TMP_Text component6 = ((Component)Utils.FindChild(element.transform, "price", (IterativeSearchType)0)).GetComponent<TMP_Text>();
				((Behaviour)((Component)Utils.FindChild(element.transform, "coin icon", (IterativeSearchType)0)).GetComponent<Image>()).enabled = false;
				string arg = ((personalLoadout.Items.Count > 1) ? "items" : "item");
				component6.text = ((personalLoadout.Items.Count >= 1) ? $"{personalLoadout.Items.Count} {arg}" : "Empty");
				if (!flag)
				{
					((Graphic)component6).color = Color.grey;
				}
				m_itemList.Add(element);
			}
			if (num < 0)
			{
				num = 0;
			}
			SelectItem(num, center: false);
		}

		public static void OnSelectedLoadout(GameObject button)
		{
			SelectItem(FindSelectedLoadout(button), center: false);
			RefreshLoadoutInventory();
		}

		public static void RefreshLoadoutInventory()
		{
			if (m_loadoutInventory == null || (Object)(object)m_loadoutGrid == (Object)null || (Object)(object)m_loadoutGrid.m_uiGroup == (Object)null)
			{
				return;
			}
			m_loadoutInventory.RemoveAll();
			if (string.IsNullOrWhiteSpace(m_selectedItem))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			string key = "AzuEPILoadout_" + m_selectedItem;
			if (!localPlayer.m_customData.TryGetValue(key, out var value))
			{
				return;
			}
			foreach (ItemData item in PersonalLoadout.Deserialize(m_selectedItem, value).Items)
			{
				if (item != null)
				{
					m_loadoutInventory.AddItem(item.Clone());
				}
			}
			m_loadoutGrid.UpdateInventory(m_loadoutInventory, (Player)null, (ItemData)null);
		}

		public static int FindSelectedLoadout(GameObject button)
		{
			for (int i = 0; i < m_itemList.Count; i++)
			{
				if ((Object)(object)m_itemList[i] == (Object)(object)button)
				{
					return i;
				}
			}
			return -1;
		}

		public static void SelectItem(int index, bool center)
		{
			try
			{
				for (int i = 0; i < m_itemList.Count; i++)
				{
					bool active = i == index;
					((Component)m_itemList[i].transform.Find("selected")).gameObject.SetActive(active);
				}
				if (center && index >= 0)
				{
					? val = m_itemEnsureVisible;
					Transform transform = m_itemList[index].transform;
					((ScrollRectEnsureVisible)val).CenterOnItem((RectTransform)(object)((transform is RectTransform) ? transform : null));
				}
				m_selectedItem = ((index < 0) ? null : GetAvailableLoadouts()[index]);
			}
			catch
			{
				for (int j = 1; j < 11; j++)
				{
					Player.m_localPlayer.m_customData[string.Format("{0}{1}", "AzuEPILoadout_", j)] = "";
				}
				FillList();
			}
		}

		public static int GetSelectedItemIndex()
		{
			int result = 0;
			List<string> availableLoadouts = GetAvailableLoadouts();
			for (int i = 0; i < availableLoadouts.Count; i++)
			{
				if (availableLoadouts[i] == m_selectedItem)
				{
					result = i;
				}
			}
			return result;
		}

		public void UpdateSwitchLoadoutButton()
		{
			UITooltip component = ((Component)m_chooseButton).GetComponent<UITooltip>();
			if (m_selectedItem != null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && localPlayer.m_customData.TryGetValue("AzuEPILoadout_" + m_selectedItem, out var value))
				{
					bool flag = PersonalLoadout.Deserialize(m_selectedItem, value).Items.Count == 0;
					bool flag2 = ((Humanoid)localPlayer).GetInventory().HaveEmptySlot() || flag;
					((Selectable)m_chooseButton).interactable = flag2;
					string text = (flag ? "$azu_epi_emptyLoadout" : "$azu_epi_swapLoadout");
					((Component)((Component)m_chooseButton).transform.Find("Text")).GetComponent<TMP_Text>().text = Localization.instance.Localize(text);
					component.m_text = ((!flag2) ? Localization.instance.Localize("$inventory_full") : "");
				}
			}
			else
			{
				((Selectable)m_chooseButton).interactable = false;
				component.m_text = "";
			}
		}

		public void UpdateRecipeGamepadInput()
		{
			if (m_itemList.Count > 0)
			{
				if (ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyDPadDown"))
				{
					SelectItem(Mathf.Min(m_itemList.Count - 1, GetSelectedItemIndex() + 1), center: true);
				}
				if (ZInput.GetButtonDown("JoyLStickUp") || ZInput.GetButtonDown("JoyDPadUp"))
				{
					SelectItem(Mathf.Max(0, GetSelectedItemIndex() - 1), center: true);
				}
			}
		}

		public string GetText()
		{
			if (string.IsNullOrEmpty(m_loadoutBeingRenamed))
			{
				return "";
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return "";
			}
			string key = "AzuEPILoadoutName_" + m_loadoutBeingRenamed;
			if (localPlayer.m_customData.TryGetValue(key, out var value))
			{
				return value;
			}
			return m_loadoutBeingRenamed;
		}

		public void SetText(string text)
		{
			if (string.IsNullOrEmpty(m_loadoutBeingRenamed))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				text = text.Trim();
				if (string.IsNullOrEmpty(text))
				{
					text = m_loadoutBeingRenamed;
				}
				if (text.Length > 20)
				{
					text = text.Substring(0, 20);
				}
				string key = "AzuEPILoadoutName_" + m_loadoutBeingRenamed;
				localPlayer.m_customData[key] = text;
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Renamed loadout '" + m_loadoutBeingRenamed + "' to '" + text + "'"));
				m_loadoutBeingRenamed = null;
				FillList();
			}
		}

		public static void RequestRenameLoadout(string loadoutId)
		{
			if (!((Object)(object)m_instance == (Object)null))
			{
				m_loadoutBeingRenamed = loadoutId;
				TextInput.instance.RequestText((TextReceiver)(object)m_instance, "$azu_epi_loadout_rename", 20);
			}
		}

		public static string GetLoadoutCustomName(string loadoutId)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return loadoutId;
			}
			string key = "AzuEPILoadoutName_" + loadoutId;
			if (localPlayer.m_customData.TryGetValue(key, out var value) && !string.IsNullOrEmpty(value))
			{
				return value;
			}
			return "Loadout " + loadoutId;
		}
	}
	public static class InventorySerializer
	{
		public static string SerializeInventory(Inventory inventory)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			inventory.Save(val);
			return val.GetBase64();
		}

		public static void DeserializeInventory(Inventory inventory, string data)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			if (!string.IsNullOrEmpty(data))
			{
				ZPackage val = new ZPackage(data);
				inventory.Load(val);
			}
		}
	}
	public class PersonalLoadout
	{
		public string LoadoutName { get; set; }

		public List<ItemData> Items { get; set; }

		public PersonalLoadout(string loadoutName, List<ItemData> items)
		{
			LoadoutName = loadoutName;
			Items = items;
		}

		public string Serialize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Inventory val = new Inventory("Loadout", (Sprite)null, 100, 100);
			foreach (ItemData item in Items)
			{
				val.AddItem(item.Clone());
			}
			return InventorySerializer.SerializeInventory(val);
		}

		public static PersonalLoadout Deserialize(string loadoutName, string data)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			Inventory val = new Inventory("Loadout", (Sprite)null, 100, 100);
			InventorySerializer.DeserializeInventory(val, data);
			List<ItemData> allItems = val.GetAllItems();
			return new PersonalLoadout(loadoutName, allItems);
		}
	}
	public class PersonalLoadoutGuiDetails : MonoBehaviour
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__41_0;

			public static Func<string, bool> <>9__42_0;

			public static Func<ItemData, string> <>9__50_0;

			internal void <BuildToggleButton>b__41_0()
			{
				ToggleUI();
			}

			internal bool <GetNumberOfLoadouts>b__42_0(string key)
			{
				return key.StartsWith("AzuEPILoadout_");
			}

			internal string <FillList>b__50_0(ItemData i)
			{
				return Localization.instance.Localize(i.m_shared.m_name);
			}
		}

		public static PersonalLoadoutGuiDetails? m_instance;

		public static GameObject m_rootPanel = null;

		public static GameObject m_storeRootPanel = null;

		public Button m_chooseButton;

		public Button m_sellButton;

		public static RectTransform m_listRoot = null;

		public static GameObject m_listElement = null;

		public Scrollbar m_listScroll;

		public static ScrollRectEnsureVisible m_itemEnsureVisible = null;

		public TMP_Text m_coinText;

		public Image m_coinIcon;

		public TMP_Text m_topicText;

		public EffectList m_buyEffects = new EffectList();

		public EffectList m_sellEffects = new EffectList();

		public float m_hideDistance = 5f;

		public static float m_itemSpacing = 64f;

		public static ItemDrop m_coinPrefab = null;

		public static List<GameObject> m_itemList = new List<GameObject>();

		public static string? m_selectedItem;

		public static Player? m_LocalPlayerRef;

		public static float m_itemlistBaseSize;

		public List<ItemData> m_tempItems = new List<ItemData>();

		private static List<ItemSet?> availableSets = new List<ItemSet>();

		public static bool PanelActive;

		public const string LoadoutKey = "AzuEPILoadout_";

		private static Button _toggleBtn;

		internal static int tempInventorySize = 0;

		public static PersonalLoadoutGuiDetails? instance => m_instance;

		public void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			m_instance = this;
			if ((Object)(object)m_storeRootPanel != (Object)null)
			{
				m_storeRootPanel.SetActive(false);
			}
			if ((Object)(object)m_listRoot != (Object)null)
			{
				Rect rect = m_listRoot.rect;
				m_itemlistBaseSize = ((Rect)(ref rect)).height;
			}
			m_chooseButton.onClick = new ButtonClickedEvent();
			((UnityEvent)m_chooseButton.onClick).AddListener(new UnityAction(OnChooseLoadout));
			m_topicText.text = Localization.instance.Localize("$azu_epi_loadouts");
		}

		public void OnDestroy()
		{
			if ((Object)(object)m_instance == (Object)(object)this)
			{
				m_instance = null;
			}
		}

		private void Update()
		{
			if (m_storeRootPanel.activeSelf && PanelActive)
			{
				if (ShouldHide() || ShouldClose())
				{
					Hide();
				}
				else
				{
					UpdateUI();
				}
			}
		}

		private bool ShouldHide()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead() || ((Character)localPlayer).InCutscene())
			{
				return true;
			}
			if (!InventoryGui.IsVisible() || Minimap.IsOpen())
			{
				return true;
			}
			return false;
		}

		private static bool ShouldClose()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus()) || Console.IsVisible() || Menu.IsVisible() || ((Object)(object)TextViewer.instance != (Object)null && TextViewer.instance.IsVisible()) || ((Character)localPlayer).InCutscene()) && (ZInput.GetButtonDown("JoyButtonB") || Input.GetKeyDown((KeyCode)27) || ZInput.GetButtonDown("Use")))
			{
				ZInput.ResetButtonStatus("JoyButtonB");
				return true;
			}
			return false;
		}

		private void UpdateUI()
		{
			UpdateSwitchLoadoutButton();
			UpdateRecipeGamepadInput();
			m_coinText.text = GetNumberOfLoadouts().ToString();
		}

		public static void Show()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !IsVisible())
			{
				m_LocalPlayerRef = Player.m_localPlayer;
				((Component)InventoryGui.instance.m_dropButton).gameObject.SetActive(false);
				((Component)m_rootPanel.transform.parent).gameObject.SetActive(true);
				m_rootPanel.SetActive(true);
				m_storeRootPanel.SetActive(true);
				PanelActive = true;
				FillList();
			}
		}

		public static void Hide()
		{
			m_LocalPlayerRef = null;
			((Component)m_rootPanel.transform.parent).gameObject.SetActive(false);
			m_rootPanel.SetActive(false);
			m_storeRootPanel.SetActive(false);
			PanelActive = false;
			((Component)InventoryGui.instance.m_dropButton).gameObject.SetActive(true);
		}

		public static void ToggleUI()
		{
			if (IsVisible())
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		public static bool IsVisible()
		{
			if (!Object.op_Implicit((Object)(object)m_instance) || !m_storeRootPanel.activeSelf)
			{
				return PanelActive;
			}
			return true;
		}

		public void OnChooseLoadout()
		{
			LoadSelectedLoadout();
		}

		public void LoadSelectedLoadout()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(m_selectedItem))
			{
				LoadLoadout(m_selectedItem);
				m_buyEffects.Create(((Component)this).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				FillList();
			}
		}

		internal static void BuildToggleButton(InventoryGui gui)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			Button takeAllButton = gui.m_takeAllButton;
			object obj = ((takeAllButton != null) ? ((Component)takeAllButton).transform : null);
			if (obj == null)
			{
				Button craftButton = gui.m_craftButton;
				obj = ((craftButton != null) ? ((Component)craftButton).transform : null);
			}
			Transform val = (Transform)obj;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			Transform obj2 = Object.Instantiate<Transform>(val, (Transform)(object)gui.m_crafting);
			((Object)obj2).name = "AzuEPI_LoadoutsToggleButton";
			obj2.SetAsLastSibling();
			RectTransform val2 = (RectTransform)obj2;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.anchoredPosition = new Vector2(-205f, -30f);
			val2.sizeDelta = new Vector2(120f, 32f);
			Button component = ((Component)obj2).GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = component.onClick;
			object obj3 = <>c.<>9__41_0;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					ToggleUI();
				};
				<>c.<>9__41_0 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			TMP_Text componentInChildren = ((Component)obj2).GetComponentInChildren<TMP_Text>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.text = "Loadouts";
			}
			_toggleBtn = component;
		}

		public static int GetNumberOfLoadouts()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0;
			}
			return localPlayer.m_customData.Keys.Count((string key) => key.StartsWith("AzuEPILoadout_"));
		}

		public static List<string> GetAvailableLoadouts()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return new List<string>();
			}
			List<string> list = new List<string>();
			foreach (string key in localPlayer.m_customData.Keys)
			{
				if (key.StartsWith("AzuEPILoadout_"))
				{
					list.Add(key.Replace("AzuEPILoadout_", ""));
				}
			}
			return list;
		}

		public static bool SaveLoadout(string loadoutName)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			string text = "AzuEPILoadout_" + loadoutName;
			List<ItemData> equippedItems = ((Humanoid)localPlayer).GetInventory().GetEquippedItems();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"SaveLoadout: Saving loadout '{loadoutName}' with {equippedItems.Count} items.");
			foreach (ItemData item in equippedItems)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$" - {item.m_shared.m_name} x{item.m_stack}");
			}
			PersonalLoadoutDetails personalLoadoutDetails = new PersonalLoadoutDetails(loadoutName, equippedItems);
			localPlayer.m_customData[text] = personalLoadoutDetails.Serialize();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("SaveLoadout: Key '" + text + "' created successfully."));
			return true;
		}

		private static void SaveEquippedItems(Player player, Inventory inventory)
		{
			List<ItemData> equippedItems = ((Humanoid)player).GetInventory().GetEquippedItems();
			if (equippedItems != null && equippedItems.Count > 0)
			{
				for (int i = 0; i < equippedItems.Count; i++)
				{
					ItemData val = equippedItems[i];
					inventory.AddItem(val.Clone());
				}
			}
		}

		public static void LoadLoadout(string loadoutName)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !localPlayer.m_customData.TryGetValue("AzuEPILoadout_" + loadoutName, out var value))
			{
				return;
			}
			PersonalLoadoutDetails loadout = PersonalLoadoutDetails.Deserialize(loadoutName, value);
			using (EpiSwapContext.Begin())
			{
				SaveLoadout(loadoutName);
				UnequipAndRemoveCurrentItems(localPlayer);
				EquipItemsFromLoadout(localPlayer, loadout);
				((Humanoid)localPlayer).m_visEquipment.UpdateVisuals();
			}
		}

		private static void EquipItemsFromLoadout(Player player, PersonalLoadoutDetails loadout)
		{
			List<ItemData> items = loadout.Items;
			int num = ((Humanoid)player).GetInventory().GetEmptySlots();
			for (int i = 0; i < items.Count; i++)
			{
				ItemData val = items[i];
				if (val != null && num > 0)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Attempting to add item: " + val.m_shared.m_name));
					bool flag = ((Humanoid)player).GetInventory().AddItem(val);
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Move result: " + flag));
					if (flag)
					{
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Equipping item: " + val.m_shared.m_name));
						((Humanoid)player).EquipItem(val, true);
					}
					num--;
				}
			}
		}

		private static void UnequipAndRemoveCurrentItems(Player player)
		{
			List<ItemData> equippedItems = ((Humanoid)player).GetInventory().GetEquippedItems();
			for (int i = 0; i < equippedItems.Count; i++)
			{
				ItemData val = equippedItems[i];
				((Humanoid)player).UnequipItem(val, true);
				((Humanoid)player).GetInventory().RemoveItem(val);
			}
		}

		private static void UnequipToBags(Player player)
		{
			foreach (ItemData equippedItem in ((Humanoid)player).GetInventory().GetEquippedItems())
			{
				((Humanoid)player).UnequipItem(equippedItem, true);
				if (!((Humanoid)player).GetInventory().AddItem(equippedItem))
				{
					((Humanoid)player).EquipItem(equippedItem, true);
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("No space to unequip " + equippedItem.m_shared.m_name));
				}
			}
		}

		public static void FillList()
		{
			//IL_00c3: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Expected O, but got Unknown
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			List<string> availableLoadouts = GetAvailableLoadouts();
			int num = GetSelectedItemIndex();
			foreach (GameObject item in m_itemList)
			{
				Object.Destroy((Object)(object)item);
			}
			m_itemList.Clear();
			m_listRoot.SetSizeWithCurrentAnchors((Axis)1, Mathf.Max(m_itemlistBaseSize, (float)availableLoadouts.Count * m_itemSpacing));
			for (int i = 0; i < availableLoadouts.Count; i++)
			{
				string text = availableLoadouts[i];
				GameObject element = Object.Instantiate<GameObject>(m_listElement, (Transform)(object)m_listRoot);
				element.SetActive(true);
				Transform transform = element.transform;
				((RectTransform)((transform is RectTransform) ? transform : null)).anchoredPosition = new Vector2(0f, (float)i * (0f - m_itemSpacing));
				Image component = ((Component)element.transform.Find("icon")).GetComponent<Image>();
				if (Player.m_localPlayer.m_customData.TryGetValue("AzuEPILoadout_" + text, out var value))
				{
					PersonalLoadoutDetails personalLoadoutDetails = PersonalLoadoutDetails.Deserialize(text, value);
					if (personalLoadoutDetails.Items.Count > 0)
					{
						ItemData val = personalLoadoutDetails.Items[0];
						component.sprite = val.m_shared.m_icons[0];
					}
					else
					{
						component.sprite = null;
					}
					bool flag = personalLoadoutDetails.Items.Count > 0;
					((Graphic)component).color = (Color)(flag ? Color.white : new Color(1f, 0f, 1f, 0f));
					TMP_Text component2 = ((Component)element.transform.Find("name")).GetComponent<TMP_Text>();
					component2.text = Localization.instance.Localize("$azu_epi_loadout " + text);
					((Graphic)component2).color = (flag ? Color.white : Color.grey);
					UITooltip component3 = element.GetComponent<UITooltip>();
					component3.m_topic = text;
					component3.m_text = (flag ? ("$azu_epi_loadouts_load:\n" + string.Join("\n", personalLoadoutDetails.Items.Select((ItemData val2) => Localization.instance.Localize(val2.m_shared.m_name)))) : "$azu_epi_loadouts_empty");
					((UnityEvent)element.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						OnSelectedLoadout(element);
					});
					TMP_Text component4 = ((Component)Utils.FindChild(element.transform, "price", (IterativeSearchType)0)).GetComponent<TMP_Text>();
					((Behaviour)((Component)Utils.FindChild(element.transform, "coin icon", (IterativeSearchType)0)).GetComponent<Image>()).enabled = false;
					string arg = ((personalLoadoutDetails.Items.Count > 1) ? "items" : "item");
					component4.text = ((personalLoadoutDetails.Items.Count >= 1) ? $"{personalLoadoutDetails.Items.Count} {arg}" : "Empty");
					if (!flag)
					{
						((Graphic)component4).color = Color.grey;
					}
					m_itemList.Add(element);
				}
			}
			if (num < 0)
			{
				num = 0;
			}
			SelectItem(num, center: false);
		}

		public static void OnSelectedLoadout(GameObject button)
		{
			SelectItem(FindSelectedLoadout(button), center: false);
		}

		public static int FindSelectedLoadout(GameObject button)
		{
			for (int i = 0; i < m_itemList.Count; i++)
			{
				if ((Object)(object)m_itemList[i] == (Object)(object)button)
				{
					return i;
				}
			}
			return -1;
		}

		public static void SelectItem(int index, bool center)
		{
			try
			{
				for (int i = 0; i < m_itemList.Count; i++)
				{
					bool active = i == index;
					((Component)m_itemList[i].transform.Find("selected")).gameObject.SetActive(active);
				}
				if (center && index >= 0)
				{
					? val = m_itemEnsureVisible;
					Transform transform = m_itemList[index].transform;
					((ScrollRectEnsureVisible)val).CenterOnItem((RectTransform)(object)((transform is RectTransform) ? transform : null));
				}
				m_selectedItem = ((index < 0) ? null : GetAvailableLoadouts()[index]);
			}
			catch
			{
				for (int j = 1; j < 11; j++)
				{
					Player.m_localPlayer.m_customData[string.Format("{0}{1}", "AzuEPILoadout_", j)] = "";
				}
				FillList();
			}
		}

		public static int GetSelectedItemIndex()
		{
			int result = 0;
			List<string> availableLoadouts = GetAvailableLoadouts();
			for (int i = 0; i < availableLoadouts.Count; i++)
			{
				if (availableLoadouts[i] == m_selectedItem)
				{
					result = i;
				}
			}
			return result;
		}

		public void UpdateSwitchLoadoutButton()
		{
			UITooltip component = ((Component)m_chooseButton).GetComponent<UITooltip>();
			if (m_selectedItem != null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && localPlayer.m_customData.TryGetValue("AzuEPILoadout_" + m_selectedItem, out var value))
				{
					bool num = PersonalLoadoutDetails.Deserialize(m_selectedItem, value).Items.Count == 0;
					bool flag = ((Humanoid)localPlayer).GetInventory().HaveEmptySlot();
					((Selectable)m_chooseButton).interactable = flag;
					string text = (num ? "$azu_epi_emptyLoadout" : "$azu_epi_swapLoadout");
					((Component)((Component)m_chooseButton).transform.Find("Text")).GetComponent<TMP_Text>().text = Localization.instance.Localize(text);
					component.m_text = ((!flag) ? Localization.instance.Localize("$inventory_full") : "");
				}
			}
			else
			{
				((Selectable)m_chooseButton).interactable = false;
				component.m_text = "";
			}
		}

		public void UpdateRecipeGamepadInput()
		{
			if (m_itemList.Count > 0)
			{
				if (ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyDPadDown"))
				{
					SelectItem(Mathf.Min(m_itemList.Count - 1, GetSelectedItemIndex() + 1), center: true);
				}
				if (ZInput.GetButtonDown("JoyLStickUp") || ZInput.GetButtonDown("JoyDPadUp"))
				{
					SelectItem(Mathf.Max(0, GetSelectedItemIndex() - 1), center: true);
				}
			}
		}
	}
	public class PersonalLoadoutDetails
	{
		public string LoadoutName { get; set; }

		public List<ItemData> Items { get; set; }

		public PersonalLoadoutDetails(string loadoutName, List<ItemData> items)
		{
			LoadoutName = loadoutName;
			Items = items;
		}

		public string Serialize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Inventory val = new Inventory("Loadout", (Sprite)null, 100, 100);
			foreach (ItemData item in Items)
			{
				val.AddItem(item.Clone());
			}
			return InventorySerializer.SerializeInventory(val);
		}

		public static PersonalLoadoutDetails Deserialize(string loadoutName, string data)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			Inventory val = new Inventory("Loadout", (Sprite)null, 100, 100);
			InventorySerializer.DeserializeInventory(val, data);
			List<ItemData> allItems = val.GetAllItems();
			return new PersonalLoadoutDetails(loadoutName, allItems);
		}
	}
	public class UIDragger : EventTrigger
	{
		public delegate void UIDroppedHandler(object source, Vector3 newLocalPosition);

		private bool _isDragging;

		public event UIDroppedHandler OnUIDropped;

		public void Update()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (_isDragging)
			{
				((Component)this).transform.position = Input.mousePosition;
			}
		}

		public override void OnPointerDown(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 1 && Input.GetKey((KeyCode)306))
			{
				_isDragging = true;
			}
		}

		public override void OnPointerUp(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 1)
			{
				_isDragging = false;
				this.OnUIDropped?.Invoke(this, new Vector3(((Component)this).transform.localPosition.x, ((Component)this).transform.localPosition.y, -1f));
			}
		}
	}
}
namespace AzuEPI.Game.Panels
{
	public static class PanelUtilities
	{
		public struct ButtonConfig
		{
			public readonly string Name;

			public Vector2 AnchorMin;

			public Vector2 AnchorMax;

			public Vector2 Pivot;

			public Vector2 AnchoredPosition;

			public Vector2 Size;

			public readonly string GamepadKey;

			public readonly KeyCode GamepadKeyCode;

			public readonly string Label;

			public readonly float LabelFontSize;

			public readonly Action OnClick;

			public ButtonConfig(string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPosition, Vector2 size, string gamepadKey, KeyCode gamepadKeyCode, string label, float labelFontSize, Action onClick)
			{
				//IL_0008: 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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: 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_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				Name = name;
				AnchorMin = anchorMin;
				AnchorMax = anchorMax;
				Pivot = pivot;
				AnchoredPosition = anchoredPosition;
				Size = size;
				GamepadKey = gamepadKey;
				GamepadKeyCode = gamepadKeyCode;
				Label = label;
				LabelFontSize = labelFontSize;
				OnClick = onClick;
			}
		}

		public struct ScrollbarConfig
		{
			public string Name;

			public Vector2 AnchorMin;

			public Vector2 AnchorMax;

			public Vector2 Pivot;

			public Vector2 OffsetMin;

			public Vector2 OffsetMax;
		}

		public static Transform CloneButton(Transform src, Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPos, Vector2 size)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0032: 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)
			Transform obj = Object.Instantiate<Transform>(src, parent);
			((Object)obj).name = name;
			obj.SetAsLastSibling();
			RectTransform val = (RectTransform)obj;
			val.anchorMin = anchorMin;
			val.anchorMax = anchorMax;
			val.pivot = pivot;
			val.anchoredPosition = anchoredPos;
			val.sizeDelta = size;
			return obj;
		}

		public static void AnchorFill(RectTransform rt)
		{
			//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_0017: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		public static RectTransform BuildPanel(InventoryGui gui, string panelName)
		{
			//IL_003b: 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)
			RectTransform crafting = gui.m_crafting;
			Transform val = ((Transform)crafting).Find("Bkg");
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			Transform val2 = Object.Instantiate<Transform>(val, (Transform)(object)crafting);
			((Object)val2).name = panelName;
			RectTransform component = ((Component)val2).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)val).GetComponent<RectTransform>();
			component.anchorMin = component2.anchorMin;
			component.anchorMax = component2.anchorMax;
			((Transform)component).SetAsLastSibling();
			Image component3 = ((Component)val2).GetComponent<Image>();
			if (Object.op_Implicit((Object)(object)component3))
			{
				((Graphic)component3).raycastTarget = false;
			}
			return component;
		}

		public static RectTransform BuildViewport(RectTransform parent, string viewportName, Color? backgroundColor = null)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(viewportName, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(RectMask2D)
			});
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)parent, false);
			AnchorFill(val2);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = (Color)(((??)backgroundColor) ?? new Color(0f, 0f, 0f, 0f));
			((Graphic)component).raycastTarget = true;
			return val2;
		}

		public static RectTransform BuildVerticalContent(RectTransform parent, string contentName, RectOffset padding, float spacing = 10f)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(contentName, new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)parent, false);
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			VerticalLayoutGroup component = val.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component).childAlignment = (TextAnchor)0;
			((LayoutGroup)component).padding = padding;
			((HorizontalOrVerticalLayoutGroup)component).spacing = spacing;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			ContentSizeFitter component2 = val.GetComponent<ContentSizeFitter>();
			component2.horizontalFit = (FitMode)0;
			component2.verticalFit = (FitMode)2;
			return val2;
		}

		public static Scrollbar BuildScrollbar(Transform panelParent, ScrollbarConfig config)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_0144: Expected O, but got Unknown
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			GameObject val;
			if (Object.op_Implicit((Object)(object)InventoryGui.instance.m_recipeListScroll))
			{
				val = Object.Instantiate<GameObject>(((Component)InventoryGui.instance.m_recipeListScroll).gameObject, panelParent);
				((Object)val).name = config.Name;
			}
			else
			{
				val = new GameObject(config.Name, new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Scrollbar)
				});
				val.transform.SetParent(panelParent, false);
			}
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = config.AnchorMin;
			val2.anchorMax = config.AnchorMax;
			val2.pivot = config.Pivot;
			val2.offsetMin = config.OffsetMin;
			val2.offsetMax = config.OffsetMax;
			Scrollbar component = val.GetComponent<Scrollbar>();
			component.direction = (Direction)2;
			Image component2 = ((Component)component).GetComponent<Image>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				((Behaviour)component2).enabled = true;
			}
			Transform obj = ((Component)component).transform.Find("Sliding Area/Handle");
			Image val3 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			if (Object.op_Implicit((Object)(object)val3))
			{
				((Behaviour)val3).enabled = true;
			}
			else
			{
				GameObject val4 = new GameObject("Handle", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				RectTransform val5 = (RectTransform)val4.transform;
				((Transform)val5).SetParent((Transform)(object)val2, false);
				AnchorFill(val5);
				((Selectable)component).targetGraphic = (Graphic)(object)val4.GetComponent<Image>();
				component.handleRect = val5;
			}
			return component;
		}

		public static (ScrollRect scroll, RectTransform viewport, RectTransform content, Scrollbar scrollbar) BuildScrollView(RectTransform panel, string scrollRootName, string viewportName, string contentName, ScrollbarConfig scrollbarConfig, Vector2 scrollRootOffsetMin, Vector2 scrollRootOffsetMax, RectOffset contentPadding, float contentSpacing = 10f, Color? viewportColor = null)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			StoreGui instance = StoreGui.instance;
			GameObject val;
			if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)((Component)instance).GetComponentInChildren<ScrollRect>()))
			{
				val = Object.Instantiate<GameObject>(((Component)((Component)instance).GetComponentInChildren<ScrollRect>()).gameObject, (Transform)(object)panel);
				((Object)val).name = scrollRootName;
			}
			else
			{
				val = new GameObject(scrollRootName, new Type[2]
				{
					typeof(RectTransform),
					typeof(ScrollRect)
				});
				val.transform.SetParent((Transform)(object)panel, false);
			}
			RectTransform val2 = (RectTransform)val.transform;
			AnchorFill(val2);
			val2.offsetMin = scrollRootOffsetMin;
			val2.offsetMax = scrollRootOffsetMax;
			ScrollRect component = val.GetComponent<ScrollRect>();
			component.horizontal = false;
			component.vertical = true;
			component.movementType = (MovementType)2;
			component.inertia = true;
			component.decelerationRate = 0.135f;
			component.scrollSensitivity = 800f;
			RectTransform val3 = BuildViewport(val2, viewportName, viewportColor);
			RectTransform val4 = BuildVerticalContent(val3, contentName, contentPadding, contentSpacing);
			Scrollbar val5 = BuildScrollbar((Transform)(object)panel, scrollbarConfig);
			component.viewport = val3;
			component.content = val4;
			component.verticalScrollbar = val5;
			component.verticalScrollbarVisibility = (ScrollbarVisibility)2;
			return (scroll: component, viewport: val3, content: val4, scrollbar: val5);
		}

		public static (Transform buttonGo, Button button) BuildToggleButton(InventoryGui gui, Transform parent, ButtonConfig config)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			Button craftButton = gui.m_craftButton;
			object obj = ((craftButton != null) ? ((Component)craftButton).transform : null);
			if (obj == null)
			{
				Button takeAllButton = gui.m_takeAllButton;
				obj = ((takeAllButton != null) ? ((Component)takeAllButton).transform : null);
			}
			Transform val = (Transform)obj;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return (buttonGo: null, button: null);
			}
			Transform val2 = CloneButton(val, parent, config.Name, config.AnchorMin, config.AnchorMax, config.Pivot, config.AnchoredPosition, config.Size);
			BindGamePad(val2, config.GamepadKey, config.GamepadKeyCode, gui);
			Button component = ((Component)val2).GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			if (config.OnClick != null)
			{
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					config.OnClick();
				});
			}
			Transform[] componentsInChildren = ((Component)component).GetComponentsInChildren<Transform>();
			foreach (Transform val3 in componentsInChildren)
			{
				if (((Object)val3).name.Contains("AAAMaxCraftAmountText"))
				{
					Object.Destroy((Object)(object)((Component)val3).gameObject);
				}
			}
			TMP_Text componentInChildren = ((Component)val2).GetComponentInChildren<TMP_Text>();
			if (!Object.op_Implicit((Object)(object)componentInChildren))
			{
				return (buttonGo: val2, button: component);
			}
			componentInChildren.text = config.Label;
			componentInChildren.fontSize = config.LabelFontSize;
			componentInChildren.fontSizeMax = config.LabelFontSize;
			return (buttonGo: val2, button: component);
		}

		public static void BindGamePad(Transform buttonGo, string GamepadKey, KeyCode GamepadKeyCode, InventoryGui gui = null)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			UIGamePad val = default(UIGamePad);
			if (((Component)buttonGo).TryGetComponent<UIGamePad>(ref val))
			{
				if (ZInput.instance != null)
				{
					((TMP_Text)val.m_hint.GetComponentInChildren<TextMeshProUGUI>(true)).text = ZInput.instance.GetBoundKeyString(GamepadKey, true);
				}
				else
				{
					ZInput.Initialize();
					((TMP_Text)val.m_hint.GetComponentInChildren<TextMeshProUGUI>(true)).text = ZInput.instance.GetBoundKeyString(GamepadKey, true);
				}
				val.m_zinputKey = GamepadKey;
				val.m_keyCode = GamepadKeyCode;
				UIGroupHandler val2 = default(UIGroupHandler);
				if ((Object)(object)gui != (Object)null && ((Component)gui.m_crafting).TryGetComponent<UIGroupHandler>(ref val2))
				{
					val.m_group = val2;
				}
			}
		}

		public static void UpdateButtonBinding(Transform buttonGo, KeyCode newKeyCode)
		{
			//IL_000b: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			UIGamePad val = default(UIGamePad);
			if (((Component)buttonGo).TryGetComponent<UIGamePad>(ref val))
			{
				string text = KeyCodeToZInputKey(newKeyCode);
				val.m_keyCode = newKeyCode;
				val.m_zinputKey = text;
				if (ZInput.instance != null)
				{
					((TMP_Text)val.m_hint.GetComponentInChildren<TextMeshProUGUI>(true)).text = ZInput.instance.GetBoundKeyString(text, true);
				}
			}
		}

		public static string KeyCodeToZInputKey(KeyCode keyCode)
		{
			//IL_0000: 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_005c: Expected I4, but got Unknown
			return (keyCode - 330) switch
			{
				0 => "JoyButtonA", 
				1 => "JoyButtonB", 
				2 => "JoyButtonX", 
				3 => "JoyButtonY", 
				4 => "JoyLBumper", 
				5 => "JoyRBumper", 
				6 => "JoyBack", 
				7 => "JoyStart", 
				8 => "JoyLStick", 
				9 => "JoyRStick", 
				10 => "JoyDPadLeft", 
				11 => "JoyDPadRight", 
				12 => "JoyDPadUp", 
				13 => "JoyDPadDown", 
				14 => "JoyLTrigger", 
				15 => "JoyRTrigger", 
				16 => "JoyButtonA", 
				17 => "JoyButtonB", 
				18 => "JoyButtonX", 
				19 => "JoyButtonY", 
				_ => "JoyButtonA", 
			};
		}

		public static void HideCraftingElements(bool hide)
		{
			if (Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				RectTransform crafting = InventoryGui.instance.m_crafting;
				((Component)crafting).transform.Find("TabsButtons").SafeSetActive(!hide);
				((Component)crafting).transform.Find("RecipeList").SafeSetActive(!hide);
				((Component)crafting).transform.Find("Decription").SafeSetActive(!hide);
			}
		}

		public static TMP_FontAsset GetFontAsset(InventoryGui gui)
		{
			Button craftButton = gui.m_craftButton;
			object obj = ((craftButton != null) ? ((Component)craftButton).GetComponentInChildren<TMP_Text>() : null);
			if (obj == null)
			{
				Button takeAllButton = gui.m_takeAllButton;
				obj = ((takeAllButton != null) ? ((Component)takeAllButton).GetComponentInChildren<TMP_Text>() : null);
				if (obj == null)
				{
					RectTransform info = gui.m_info;
					obj = ((info != null) ? ((Component)info).GetComponentInChildren<TMP_Text>() : null);
				}
			}
			if (obj == null)
			{
				return null;
			}
			return ((TMP_Text)obj).font;
		}

		public static void DisableChild(Transform root, string childName)
		{
			Transform val = root.Find(childName);
			if (Object.op_Implicit((Object)(object)val))
			{
				((Component)val).gameObject.SetActive(false);
			}
		}

		public static void DisableChildrenContaining(Transform root, string contains)
		{
			int childCount = root.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (((Object)child).name.Contains(contains))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		public static void ClearChildren(Transform t)
		{
			for (int num = t.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)t.GetChild(num)).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateGamepad")]
	internal static class Vanity_GamepadUpdate
	{
		private static void Prefix(InventoryGui __instance)
		{
			if (__instance.m_inventoryGroup.IsActive)
			{
				if (VanityPanelController.IsVisible())
				{
					VanityPanelController.UpdateGamepadNavigation();
				}
				if (PersonalLoadoutGui.IsVisible())
				{
					PersonalLoadoutGui.instance.HandleUIUpdates();
				}
				if (StatsPanelController.IsVisible())
				{
					StatsPanelController.HandleScrollInput();
				}
			}
		}
	}
}
namespace AzuEPI.Game.Panels.Vanity
{
	[HarmonyPatch]
	public static class IconPatches
	{
		private static Sprite TryOverride(ItemData item, Sprite fallback)
		{
			if (item == null)
			{
				return fallback;
			}
			if (!VanityAPI.TryGetEquippedVanityIcon(item, out Sprite sprite))
			{
				return fallback;
			}
			return sprite;
		}

		[HarmonyPatch(typeof(ItemData), "GetIcon")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void ItemIcon_Postfix(ItemData __instance, ref Sprite __result)
		{
			__result = TryOverride(__instance, __result);
		}

		[HarmonyPatch(typeof(InventoryGui), "SetupUpgradeItem")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void SetupUpgradeItem_Postfix(InventoryGui __instance, Recipe recipe, ItemData item)
		{
			ItemData val = item ?? recipe?.m_item?.m_itemData;
			if (val != null)
			{
				__instance.m_upgradeItemIcon.sprite = TryOverride(val, __instance.m_upgradeItemIcon.sprite);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void UpdateRecipe_Postfix(InventoryGui __instance)
		{
			ItemData itemData = ((RecipeDataPair)(ref __instance.m_selectedRecipe)).ItemData;
			if (itemData != null)
			{
				__instance.m_recipeIcon.sprite = TryOverride(itemData, __instance.m_recipeIcon.sprite);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "EquipInventoryItems")]
	internal static class LoadVanityOnPlayerLoad
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				VanityAPI.LoadFromCustomData(__instance);
			}
		}
	}
	internal static class CharacterSelectionVanity
	{
		internal static Player? PreviewPlayer;

		internal static readonly Dictionary<int, int> VanityData = new Dictionary<int, int>();

		internal static void LoadFromPlayer(Player player)
		{
			PreviewPlayer = player;
			VanityData.Clear();
			if (!Object.op_Implicit((Object)(object)player) || !player.m_customData.TryGetValue("AzuEPI.Vanity", out var value))
			{
				return;
			}
			string[] array = value.Split(new char[1] { ':' });
			if (array.Length >= 6)
			{
				if (int.TryParse(array[0], out var result))
				{
					VanityData[VanityZdoKeys.Helmet] = result;
				}
				if (int.TryParse(array[1], out var result2))
				{
					VanityData[VanityZdoKeys.Chest] = result2;
				}
				if (int.TryParse(array[2], out var result3))
				{
					VanityData[VanityZdoKeys.Legs] = result3;
				}
				if (int.TryParse(array[3], out var result4))
				{
					VanityData[VanityZdoKeys.Shoulder] = result4;
				}
				if (int.TryParse(array[4], out var result5))
				{
					VanityData[VanityZdoKeys.ShoulderVariant] = result5;
				}
				if (int.TryParse(array[5], out var result6))
				{
					VanityData[VanityZdoKeys.Utility] = result6;
				}
				if (array.Length >= 7 && int.TryParse(array[6], out var result7))
				{
					VanityData[VanityZdoKeys.Trinket] = result7;
				}
				if (array.Length >= 8 && int.TryParse(array[7], out var result8))
				{
					VanityData[VanityZdoKeys.HelmetVariant] = result8;
				}
				if (array.Length >= 9 && int.TryParse(array[8], out var result9))
				{
					VanityData[VanityZdoKeys.ChestVariant] = result9;
				}
				if (array.Length >= 10 && int.TryParse(array[9], out var result10))
				{
					VanityData[VanityZdoKeys.LegsVariant] = result10;
				}
				if (array.Length >= 11 && int.TryParse(array[10], out var result11))
				{
					VanityData[VanityZdoKeys.UtilityVariant] = result11;
				}
			}
		}

		internal static void Clear()
		{
			PreviewPlayer = null;
			VanityData.Clear();
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "SetupCharacterPreview")]
	internal static class LoadVanityOnCharacterPreview
	{
		[HarmonyPostfix]
		private static void Postfix(FejdStartup __instance)
		{
			Player previewPlayer = __instance.GetPreviewPlayer();
			if ((Object)(object)previewPlayer != (Object)null)
			{
				CharacterSelectionVanity.LoadFromPlayer(previewPlayer);
				VisEquipment visEquipment = ((Humanoid)previewPlayer).m_visEquipment;
				if (visEquipment != null)
				{
					visEquipment.UpdateVisuals();
				}
			}
			else
			{
				CharacterSelectionVanity.Clear();
			}
		}
	}
	internal static class VanityZdoKeys
	{
		internal static readonly int Chest = StringExtensionMethods.GetStableHashCode("azu.vanity.chest");

		internal static readonly int Legs = StringExtensionMethods.GetStableHashCode("azu.vanity.legs");

		internal static readonly int Helmet = StringExtensionMethods.GetStableHashCode("azu.vanity.helmet");

		internal static readonly int Shoulder = StringExtensionMethods.GetStableHashCode("azu.vanity.shoulder");

		internal static readonly int Utility = StringExtensionMethods.GetStableHashCode("azu.vanity.utility");

		internal static readonly int Trinket = StringExtensionMethods.GetStableHashCode("azu.vanity.trinket");

		internal static readonly int HelmetVariant = StringExtensionMethods.GetStableHashCode("azu.vanity.helmet.variant");

		internal static readonly int ChestVariant = StringExtensionMethods.GetStableHashCode("azu.vanity.chest.variant");

		internal static readonly int LegsVariant = StringExtensionMethods.GetStableHashCode("azu.vanity.legs.variant");

		internal static readonly int ShoulderVariant = StringExtensionMethods.GetStableHashCode("azu.vanity.shoulder.variant");

		internal static readonly int UtilityVariant = StringExtensionMethods.GetStableHashCode("azu.vanity.utility.variant");

		internal static int VariantKeyForSlot(VisSlot slot)
		{
			//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_001c: Expected I4, but got Unknown
			return (slot - 4) switch
			{
				2 => HelmetVariant, 
				0 => ChestVariant, 
				1 => LegsVariant, 
				3 => ShoulderVariant, 
				4 => UtilityVariant, 
				_ => 0, 
			};
		}
	}
	public static class VanityAPI
	{
		public const int HIDE = int.MinValue;

		public static bool IsHidden(int hash)
		{
			return hash == int.MinValue;
		}

		public static bool SetVanity(VisEquipment ve, VisSlot slot, string prefabName, int variant = 0)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected I4, but got Unknown
			if (!Object.op_Implicit((Object)(object)ve) || (Object)(object)ve.m_nview == (Object)null)
			{
				return false;
			}
			ZDO zDO = ve.m_nview.GetZDO();
			if (zDO == null || !ve.m_nview.IsOwner())
			{
				return false;
			}
			int num = ((!string.IsNullOrEmpty(prefabName)) ? StringExtensionMethods.GetStableHashCode(prefabName) : 0);
			switch (slot - 4)
			{
			case 0:
				zDO.Set(VanityZdoKeys.Chest, num, false);
				zDO.Set(VanityZdoKeys.ChestVariant, variant, false);
				break;
			case 1:
				zDO.Set(VanityZdoKeys.Legs, num, false);
				zDO.Set(VanityZdoKeys.LegsVariant, variant, false);
				break;
			case 2:
				zDO.Set(VanityZdoKeys.Helmet, num, false);
				zDO.Set(VanityZdoKeys.HelmetVariant, variant, false);
				break;
			case 3:
				zDO.Set(VanityZdoKeys.Shoulder, num, false);
				zDO.Set(VanityZdoKeys.ShoulderVariant, variant, false);
				break;
			case 4:
				zDO.Set(VanityZdoKeys.Utility, num, false);
				zDO.Set(VanityZdoKeys.UtilityVariant, variant, false);
				break;
			default:
				return false;
			}
			SaveToCustomData(Player.m_localPlayer);
			ve.UpdateVisuals();
			return true;
		}

		public static bool ClearVanity(VisEquipment ve, VisSlot slot)
		{
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected I4, but got Unknown
			if (!Object.op_Implicit((Object)(object)ve) || (Object)(object)ve.m_nview == (Object)null)
			{
				return false;
			}
			ZDO zDO = ve.m_nview.GetZDO();
			if (zDO == null || !ve.m_nview.IsOwner())
			{
				return false;
			}
			int num = VanityZdoKeys.VariantKeyForSlot(slot);
			switch (slot - 4)
			{
			case 0:
				zDO.Set(VanityZdoKeys.Chest, 0, false);
				break;
			case 1:
				zDO.Set(VanityZdoKeys.Legs, 0, false);
				break;
			case 2:
				zDO.Set(VanityZdoKeys.Helmet, 0, false);
				break;
			case 3:
				zDO.Set(VanityZdoKeys.Shoulder, 0, false);
				break;
			case 4:
				zDO.Set(VanityZdoKeys.Utility, 0, false);
				break;
			default:
				return false;
			}
			if (num != 0)
			{
				zDO.Set(num, 0, false);
			}
			SaveToCustomData(Player.m_localPlayer);
			ve.UpdateVisuals();
			return true;
		}

		public static bool SetHidden(VisEquipment ve, VisSlot slot, bool hidden)
		{
			//IL_0042: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected I4, but got Unknown
			if (!Object.op_Implicit((Object)(object)ve) || (Object)(object)ve.m_nview == (Object)null)
			{
				return false;
			}
			ZDO zDO = ve.m_nview.GetZDO();
			if (zDO == null || !ve.m_nview.IsOwner())
			{
				return false;
			}
			int num = (hidden ? int.MinValue : 0);
			int num2 = VanityZdoKeys.VariantKeyForSlot(slot);
			switch (slot - 4)
			{
			case 0:
				zDO.Set(VanityZdoKeys.Chest, num, false);
				break;
			case 1:
				zDO.Set(VanityZdoKeys.Legs, num, false);
				break;
			case 2:
				zDO.Set(VanityZdoKeys.Helmet, num, false);
				break;
			case 3:
				zDO.Set(VanityZdoKeys.Shoulder, num, false);
				break;
			case 4:
				zDO.Set(VanityZdoKeys.Utility, num, false);
				break;
			default:
				return false;
			}
			if (!hidden && num2 != 0)
			{
				zDO.Set(num2, 0, false);
			}
			SaveToCustomData(Player.m_localPlayer);
			ve.UpdateVisuals();
			return true;
		}

		private static void SaveToCustomData(Player player)
		{
			if (!Object.op_Implicit((Object)(object)player) || player.m_isLoading)
			{
				return;
			}
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (Object.op_Implicit((Object)(object)visEquipment))
			{
				ZNetView nview = visEquipment.m_nview;
				ZDO val = ((nview != null) ? nview.GetZDO() : null);
				if (val != null)
				{
					string value = $"{val.GetInt(VanityZdoKeys.Helmet, 0)}:{val.GetInt(VanityZdoKeys.Chest, 0)}:{val.GetInt(VanityZdoKeys.Legs, 0)}:{val.GetInt(VanityZdoKeys.Shoulder, 0)}:{val.GetInt(VanityZdoKeys.ShoulderVariant, 0)}:{val.GetInt(VanityZdoKeys.Utility, 0)}:{val.GetInt(VanityZdoKeys.Trinket, 0)}:{val.GetInt(VanityZdoKeys.HelmetVariant, 0)}:{val.GetInt(VanityZdoKeys.ChestVariant, 0)}:{val.GetInt(VanityZdoKeys.LegsVariant, 0)}:{val.GetInt(VanityZdoKeys.UtilityVariant, 0)}";
					player.m_customData["AzuEPI.Vanity"] = value;
				}
			}
		}

		public static void LoadFromCustomData(Player player)
		{
			if (!Object.op_Implicit((Object)(object)player))
			{
				return;
			}
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment) || !Object.op_Implicit((Object)(object)visEquipment.m_nview))
			{
				return;
			}
			ZDO zDO = visEquipment.m_nview.GetZDO();
			if (zDO == null || !player.m_customData.TryGetValue("AzuEPI.Vanity", out var value))
			{
				return;
			}
			string[] array = value.Split(new char[1] { ':' });
			if (array.Length >= 6)
			{
				if (int.TryParse(array[0], out var result))
				{
					zDO.Set(VanityZdoKeys.Helmet, result, false);
				}
				if (int.TryParse(array[1], out var result2))
				{
					zDO.Set(VanityZdoKeys.Chest, result2, false);
				}
				if (int.TryParse(array[2], out var result3))
				{
					zDO.Set(VanityZdoKeys.Legs, result3, false);
				}
				if (int.TryParse(array[3], out var result4))
				{
					zDO.Set(VanityZdoKeys.Shoulder, result4, false);
				}
				if (int.TryParse(array[4], out var result5))
				{
					zDO.Set(VanityZdoKeys.ShoulderVariant, result5, false);
				}
				if (int.TryParse(array[5], out var result6))
				{
					zDO.Set(VanityZdoKeys.Utility, result6, false);
				}
				if (array.Length >= 7 && int.TryParse(array[6], out var result7))
				{
					zDO.Set(VanityZdoKeys.Trinket, result7, false);
				}
				if (array.Length >= 8 && int.TryParse(array[7], out var result8))
				{
					zDO.Set(VanityZdoKeys.HelmetVariant, result8, false);
				}
				if (array.Length >= 9 && int.TryParse(array[8], out var result9))
				{
					zDO.Set(VanityZdoKeys.ChestVariant, result9, false);
				}
				if (array.Length >= 10 && int.TryParse(array[9], out var result10))
				{
					zDO.Set(VanityZdoKeys.LegsVariant, result10, false);
				}
				if (array.Length >= 11 && int.TryParse(array[10], out var result11))
				{
					zDO.Set(VanityZdoKeys.UtilityVariant, result11, false);
				}
			}
		}

		public static bool IsHidden(VisEquipment ve, VisSlot slot)
		{
			//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_001c: Expected I4, but got Unknown
			return IsHidden((slot - 4) switch
			{
				0 => Get(ve, VanityZdoKeys.Chest), 
				1 => Get(ve, VanityZdoKeys.Legs), 
				2 => Get(ve, VanityZdoKeys.Helmet), 
				3 => Get(ve, VanityZdoKeys.Shoulder), 
				4 => Get(ve, VanityZdoKeys.Utility), 
				_ => 0, 
			});
		}

		internal static int Get(VisEquipment ve, int key)
		{
			object obj;
			if (ve == null)
			{
				obj = null;
			}
			else
			{
				ZNetView nview = ve.m_nview;
				obj = ((nview != null) ? nview.GetZDO() : null);
			}
			if (obj == null)
			{
				return 0;
			}
			return ((ZDO)obj).GetInt(key, 0);
		}

		internal static int GetVariant(VisEquipment ve, int key)
		{
			object obj;
			if (ve == null)
			{
				obj = null;
			}
			else
			{
				ZNetView nview = ve.m_nview;
				obj = ((nview != null) ? nview.GetZDO() : null);
			}
			if (obj == null)
			{
				return 0;
			}
			return ((ZDO)obj).GetInt(key, 0);
		}

		public static VanityState GetAppliedVanity(Player player, VisSlot slot)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return VanitySlots.GetState(Object.op_Implicit((Object)(object)player) ? ((Humanoid)player).m_visEquipment : null, slot);
		}

		public static VanityState GetAppliedVanityForItem(Player player, ItemData item)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)player) || item?.m_shared == null)
			{
				return new VanityState(has: false, hidden: false, 0, 0);
			}
			if (!VanitySlots.TryMapItemTypeToVisSlot(item.m_shared.m_itemType, out var slot))
			{
				return new VanityState(has: false, hidden: false, 0, 0);
			}
			return GetAppliedVanity(player, slot);
		}

		public static bool TryGetEquippedVanityIcon(ItemData item, out Sprite sprite)
		{
			//IL_0037: 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)
			sprite = null;
			if (!VanityPanelController.IsVisible())
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || item == null || item.m_shared == null)
			{
				return false;
			}
			if (!item.m_equipped)
			{
				return false;
			}
			if (!VanitySlots.TryMapItemTypeToVisSlot(item.m_shared.m_itemType, out var slot))
			{
				return false;
			}
			VanityState appliedVanity = GetAppliedVanity(localPlayer, slot);
			Element element;
			try
			{
				element = InventoryGui.instance.m_playerGrid.GetElement(item.m_gridPos.x, item.m_gridPos.y, ((Humanoid)localPlayer).GetInventory().GetWidth());
			}
			catch
			{
				return false;
			}
			if (element == null)
			{
				return false;
			}
			SlotOverlays.SetVanityOverlayVisible(element.m_go, appliedVanity);
			if (appliedVanity.HasVanity && !appliedVanity.IsHidden)
			{
				return VanityLookup.TryGetIcon(appliedVanity.Hash, appliedVanity.Variant, out sprite);
			}
			return false;
		}
	}
	public readonly struct VanityState
	{
		public readonly bool HasVanity;

		public readonly bool IsHidden;

		public readonly int Hash;

		public readonly int Variant;

		public VanityState(bool has, bool hidden, int hash, int variant)
		{
			HasVanity = has;
			IsHidden = hidden;
			Hash = hash;
			Variant = variant;
		}
	}
	internal static class VanityLookup
	{
		private static readonly Dictionary<int, (string prefab, ItemDrop itemDrop)> _byHash = new Dictionary<int, (string, ItemDrop)>(2048);

		private static int _buildFrame = -1;

		private static readonly List<ItemDrop> _tempDrops = new List<ItemDrop>(32);

		public static void InvalidateCache()
		{
			_byHash.Clear();
			_buildFrame = -1;
		}

		private static IEnumerable<ItemDrop> AllItemDrops(ObjectDB odb)
		{
			if ((Object)(object)odb == (Object)null)
			{
				yield break;
			}
			foreach (GameObject item in odb.m_items)
			{
				if (!Object.op_Implicit((Object)(object)item))
				{
					continue;
				}
				_tempDrops.Clear();
				item.GetComponentsInChildren<ItemDrop>(true, _tempDrops);
				foreach (ItemDrop tempDrop in _tempDrops)
				{
					if (Object.op_Implicit((Object)(object)tempDrop) && tempDrop.m_itemData?.m_shared != null)
					{
						yield return tempDrop;
					}
				}
			}
			foreach (Recipe recipe in odb.m_recipes)
			{
				if (Object.op_Implicit((Object)(object)recipe) && Object.op_Implicit((Object)(object)recipe.m_item))
				{
					ItemDrop component = ((Component)recipe.m_item).GetComponent<ItemDrop>();
					if (Object.op_Implicit((Object)(object)component) && component.m_itemData?.m_shared != null)
					{
						yield return component;
					}
				}
			}
		}

		private static void EnsureBuilt()
		{
			ObjectDB instance = ObjectDB.instance;
			if (!Object.op_Implicit((Object)(object)instance) || _buildFrame == Time.frameCount)
			{
				return;
			}
			_buildFrame = Time.frameCount;
			if (_byHash.Count != 0)
			{
				return;
			}
			foreach (ItemDrop item in AllItemDrops(instance))
			{
				string text = (Object.op_Implicit((Object)(object)item.m_itemData.m_dropPrefab) ? ((Object)item.m_itemData.m_dropPrefab).name : ((Object)item).name);
				int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
				_byHash[stableHashCode] = (text, item);
			}
		}

		public static bool TryGetByHash(int hash, out string prefab, out ItemDrop itemDrop)
		{
			EnsureBuilt();
			if (_byHash.TryGetValue(hash, out (string, ItemDrop) value))
			{
				(prefab, itemDrop) = value;
				return true;
			}
			prefab = null;
			itemDrop = null;
			return false;
		}

		public static bool TryGetIcon(int hash, int variant, out Sprite sprite)
		{
			sprite = null;
			if (!TryGetByHash(hash, out string _, out ItemDrop itemDrop))
			{
				return false;
			}
			Sprite[] array = itemDrop.m_itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0)
			{
				return false;
			}
			int num = ((variant >= 0 && variant < array.Length) ? variant : 0);
			sprite = array[num];
			return (Object)(object)sprite != (Object)null;
		}
	}
	internal static class VanitySlots
	{
		public static bool TryMapItemTypeToVisSlot(ItemType t, out VisSlot slot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if ((int)t <= 7)
			{
				if ((int)t == 6)
				{
					slot = (VisSlot)6;
					return true;
				}
				if ((int)t == 7)
				{
					slot = (VisSlot)4;
					return true;
				}
			}
			else
			{
				if ((int)t == 11)
				{
					slot = (VisSlot)5;
					return true;
				}
				if ((int)t == 17)
				{
					slot = (VisSlot)7;
					return true;
				}
				if ((int)t == 18)
				{
					slot = (VisSlot)8;
					return true;
				}
			}
			slot = (VisSlot)0;
			return false;
		}

		public static VanityState GetState(VisEquipment ve, VisSlot slot)
		{
			//IL_0012: 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_002e: Expected I4, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ve))
			{
				return new VanityState(has: false, hidden: false, 0, 0);
			}
			int num = (slot - 4) switch
			{
				2 => VanityAPI.Get(ve, VanityZdoKeys.Helmet), 
				0 => VanityAPI.Get(ve, VanityZdoKeys.Chest), 
				1 => VanityAPI.Get(ve, VanityZdoKeys.Legs), 
				3 => VanityAPI.Get(ve, VanityZdoKeys.Shoulder), 
				4 => VanityAPI.Get(ve, VanityZdoKeys.Utility), 
				_ => 0, 
			};
			bool flag = VanityAPI.IsHidden(num);
			bool has = !flag && num != 0;
			int num2 = VanityZdoKeys.VariantKeyForSlot(slot);
			int variant = ((num2 != 0) ? VanityAPI.GetVariant(ve, num2) : 0);
			return new VanityState(has, flag, num, variant);
		}
	}
	internal static class VanityPanelController
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ResetAllVanities;
		}

		public const string VanityPanelName = "AzuEPI_VanityPanel";

		public const string VanityScrollRootName = "ScrollRoot";

		public const string VanityViewportName = "Viewport";

		public const string VanityContentName = "Content";

		public const string VanityScrollbarName = "Scrollbar";

		public const string VanityToggleButtonName = "AzuEPI_VanityToggleButton";

		public const string ResetAllVanityButtonName = "ResetAllVanityButton";

		public static Transform VanityButtonGo = null;

		private static readonly Vector2 CellSize = new Vector2(70f, 70f);

		private static readonly Vector2 Spacing = new Vector2(6f, 6f);

		private static readonly Vector2 Padding = new Vector2(12f, 12f);

		private const int Columns = 7;

		private static readonly Vector2 ScrollRootOffsetMin = new Vector2(10f, 10f);

		private static readonly Vector2 ScrollRootOffsetMax = new Vector2(-24f, -50f);

		internal static RectTransform ToggleButtonParentGlg = null;

		private static readonly Vector2 ToggleBtnAnchorMin = new Vector2(0f, 1f);

		private static readonly Vector2 ToggleBtnAnchorMax = new Vector2(0f, 1f);

		private static readonly Vector2 ToggleBtnPivot = new Vector2(0f, 1f);

		private static readonly Vector2 ToggleBtnPos = new Vector2(-360f, -30f);

		private static readonly Vector2 ToggleBtnSize = new Vector2(120f, 32f);

		private static readonly Vector2 ResetBtnAnchorMin = new Vector2(0.5f, 1f);

		private static readonly Vector2 ResetBtnAnchorMax = new Vector2(0.5f, 1f);

		private static readonly Vector2 ResetBtnPivot = new Vector2(0f, 1f);

		private static readonly Vector2 ResetBtnPos = new Vector2(-45f, -20f);

		private static readonly Vector2 ResetBtnSize = new Vector2(120f, 32f);

		private static readonly Vector2 BarAnchorMin = new Vector2(1f, 0f);

		private static readonly Vector2 BarAnchorMax = new Vector2(1f, 1f);

		private static readonly Vector2 BarPivot = new Vector2(1f, 1f);

		private static readonly Vector2 BarOffsetMin = new Vector2(-12f, 12f);

		private static readonly Vector2 BarOffsetMax = new Vector2(-4f, -12f);

		private const string UpTriangle = "▲";

		private const string DownTriangle = "▼";

		private const string LeftTriangle = "◀";

		private const string RightTriangle = "▶";

		private const string HeaderTriangleSizeTag = "<size=10>";

		private static RectTransform _panel;

		private static ScrollRect _scroll;

		private static RectTransform _viewport;

		private static RectTransform _content;

		private static VerticalLayoutGroup _stack;

		private static ContentSizeFitter _fitter;

		private static Scrollbar _vbar;

		private static Button _toggleBtn;

		private static Button _resetVanitiesBtn;

		private static TMP_Text _fontSample;

		private static bool _visible;

		private static VanityCell _selectedCell;

		private static readonly List<VanityCell> _allCells = new List<VanityCell>();

		private static Image _gamepadSelectionOverlay;

		private static readonly Dictionary<VisSlot, List<VanityCell>> _cellsBySlot = new Dictionary<VisSlot, List<VanityCell>>();

		private static readonly Dictionary<VisSlot, TextMeshProUGUI> _headersBySlot = new Dictionary<VisSlot, TextMeshProUGUI>();

		private static readonly Dictionary<TextMeshProUGUI, (string baseLabel, VisSlot slot)> _headerInfo = new Dictionary<TextMeshProUGUI, (string, VisSlot)>();

		private static readonly Dictionary<VisSlot, GameObject> _resetButtonsBySlot = new Dictionary<VisSlot, GameObject>();

		private static readonly Dictionary<VisSlot, RectTransform> _headerRectsBySlot = new Dictionary<VisSlot, RectTransform>();

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

		private static readonly Dictionary<string, ItemDrop> _reusableDropsDict = new Dictionary<string, ItemDrop>(256);

		private static readonly List<ItemData> _reusableVanityItems = new List<ItemData>(128);

		private static Player _cachedPlayer = null;

		private static bool _hasCompleteBuild = false;

		public static void EnsureBuilt(InventoryGui gui)
		{
			if (Object.op_Implicit((Object)(object)gui))
			{
				if (!Object.op_Implicit((Object)(object)_panel))
				{
					BuildPanel(gui);
				}
				if (!Object.op_Implicit((Object)(object)_scroll))
				{
					BuildScrollTree();
				}
				if (!Object.op_Implicit((Object)(object)_toggleBtn))
				{
					BuildVanityToggleButton(gui);
				}
				if (!Object.op_Implicit((Object)(object)_resetVanitiesBtn))
				{
					BuildResetButton(gui);
				}
				Button craftButton = gui.m_craftButton;
				_fontSample = ((craftButton != null) ? ((Component)craftButton).GetComponentInChildren<TMP_Text>() : null);
				RefreshGridIfNeeded();
				SetVisible(_visible);
			}
		}

		public static void InvalidateCache()
		{
			_cachedPlayer = null;
			_hasCompleteBuild = false;
			VanityLookup.InvalidateCache();
		}

		private static bool NeedsRebuild()
		{
			Player localPlayer = Player.m_localPlayer;
			ObjectDB instance = ObjectDB.instance;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)instance))
			{
				return false;
			}
			if ((Object)(object)_cachedPlayer != (Object)(object)localPlayer)
			{
				return true;
			}
			if (_allCells.Count == 0)
			{
				return true;
			}
			if (!_hasCompleteBuild && _allCells.Count < 15)
			{
				return true;
			}
			return false;
		}

		public static void RefreshGridIfNeeded()
		{
			if (NeedsRebuild())
			{
				RefreshGrid();
			}
		}

		public static bool IsVisible()
		{
			return _visible;
		}

		public static void SetVisible(bool visible)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			_visible = visible;
			if (Object.op_Implicit((Object)(object)_panel))
			{
				((Component)_panel).gameObject.SetActive(visible);
			}
			if (visible && Object.op_Implicit((Object)(object)_panel))
			{
				((Transform)_panel).SetAsLastSibling();
				foreach (VisSlot key in _cellsBySlot.Keys)
				{
					UpdateSelectedVisuals(key);
				}
				if (ZInput.IsGamepadActive())
				{
					ExpandAllSections();
					UpdateEquippedBorders();
					SelectFirstCell();
				}
				return;
			}
			_selectedCell = null;
			foreach (VanityCell allCell in _allCells)
			{
				if (Object.op_Implicit((Object)(object)allCell) && Object.op_Implicit((Object)(object)allCell.SelectedBadge))
				{
					allCell.SelectedBadge.SetActive(false);
				}
				if (Object.op_Implicit((Object)(object)allCell) && Object.op_Implicit((Object)(object)allCell.EquippedBorder))
				{
					allCell.EquippedBorder.SetActive(false);
				}
			}
			SlotOverlays.HideAllVanityOverlays();
		}

		private static void ExpandAllSections()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_content))
			{
				return;
			}
			for (int i = 0; i < ((Transform)_content).childCount; i++)
			{
				Transform child = ((Transform)_content).GetChild(i);
				if (!((Object)(object)((Component)child).GetComponent<GridLayoutGroup>() != (Object)null) || ((Component)child).gameObject.activeSelf)
				{
					continue;
				}
				((Component)child).gameObject.SetActive(true);
				if (i > 0)
				{
					TextMeshProUGUI component = ((Component)((Transform)_content).GetChild(i - 1)).GetComponent<TextMeshProUGUI>();
					if (Object.op_Implicit((Object)(object)component) && _headerInfo.TryGetValue(component, out (string, VisSlot) value))
					{
						ApplyHeaderStyle(component, value.Item1, value.Item2, isExpanded: true);
					}
				}
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
		}

		public unsafe static void RefreshGrid()
		{
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Invalid comparison between Unknown and I4
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Invalid comparison between Unknown and I4
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Invalid comparison between Unknown and I4
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Invalid comparison between Unknown and I4
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Invalid comparison between Unknown and I4
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Invalid comparison between Unknown and I4
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Invalid comparison between Unknown and I4
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Invalid comparison between Unknown and I4
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Invalid comparison between Unknown and I4
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_content))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			ObjectDB instance = ObjectDB.instance;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			_cachedPlayer = localPlayer;
			_cellsBySlot.Clear();
			_headersBySlot.Clear();
			_headerInfo.Clear();
			_resetButtonsBySlot.Clear();
			_headerRectsBySlot.Clear();
			_allCells.Clear();
			_selectedCell = null;
			PanelUtilities.ClearChildren((Transform)(object)_content);
			_reusableGameObjectList.Clear();
			foreach (Recipe recipe in instance.m_recipes)
			{
				if (Object.op_Implicit((Object)(object)recipe) && Object.op_Implicit((Object)(object)recipe.m_item))
				{
					_reusableGameObjectList.Add(((Component)recipe.m_item).gameObject);
				}
			}
			if (instance.m_items != null)
			{
				foreach (GameObject item in instance.m_items)
				{
					if (Object.op_Implicit((Object)(object)item))
					{
						_reusableGameObjectList.Add(item);
					}
				}
			}
			_reusableDropsDict.Clear();
			foreach (GameObject reusableGameObject in _reusableGameObjectList)
			{
				ItemDrop[] componentsInChildren = reusableGameObject.GetComponentsInChildren<ItemDrop>(true);
				foreach (ItemDrop val in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)val) && val.m_itemData?.m_shared != null)
					{
						string name = val.m_itemData.m_shared.m_name;
						if (!_reusableDropsDict.ContainsKey(name))
						{
							_reusableDropsDict[name] = val;
						}
					}
				}
			}
			_reusableVanityItems.Clear();
			foreach (ItemDrop value in _reusableDropsDict.Values)
			{
				ItemData itemData = value.m_itemData;
				GameObject val2 = (Object.op_Implicit((Object)(object)itemData?.m_dropPrefab) ? itemData.m_dropPrefab : ((Component)value).gameObject);
				int num;
				if (itemData != null)
				{
					SharedData shared = itemData.m_shared;
					if (shared != null)
					{
						Sprite[] icons = shared.m_icons;
						if (icons != null && icons.Length > 0 && Object.op_Implicit((Object)(object)val2) && (val2.HasChildWithNameThatContains("attach") || val2.HasChildWithNameThatContains("log")))
						{
							num = (string.IsNullOrWhiteSpace(itemData.m_shared.m_dlc) ? 1 : 0);
							goto IL_0290;
						}
					}
				}
				num = 0;
				goto IL_0290;
				IL_0290:
				bool flag = (byte)num != 0;
				if (flag)
				{
					ItemType itemType = itemData.m_shared.m_itemType;
					bool flag2 = ((itemType - 6 <= 1 || (int)itemType == 11 || itemType - 17 <= 1) ? true : false);
					flag = flag2;
				}
				if (flag)
				{
					if ((Object)(object)itemData.m_dropPrefab == (Object)null)
					{
						itemData.m_dropPrefab = ((Component)value).gameObject;
					}
					_reusableVanityItems.Add(itemData);
				}
			}
			if (_reusableVanityItems.Count >= 15)
			{
				_hasCompleteBuild = true;
			}
			_reusableVanityItems.Sort(delegate(ItemData a, ItemData b)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				ref ItemType itemType3 = ref a.m_shared.m_itemType;
				object target = b.m_shared.m_itemType;
				int num3 = ((Enum)Unsafe.As<ItemType, ItemType>(ref itemType3)/*cast due to .constrained prefix*/).CompareTo(target);
				return (num3 == 0) ? string.Compare(a.m_shared.m_name, b.m_shared.m_name, StringComparison.Ordinal) : num3;
			});
			GameObject elementPrefab = InventoryGui.instance.m_playerGrid.m_elementPrefab;
			ItemType val3 = (ItemType)(-1);
			GridLayoutGroup val4 = null;
			foreach (ItemData reusableVanityItem in _reusableVanityItems)
			{
				ItemType itemType2 = reusableVanityItem.m_shared.m_itemType;
				string text;
				if (itemType2 != val3)
				{
					val3 = itemType2;
					if ((int)itemType2 <= 7)
					{
						if ((int)itemType2 != 6)
						{
							if ((int)itemType2 != 7)
							{
								goto IL_03e5;
							}
							text = "$azu_epi_chest";
						}
						else
						{
							text = "$azu_epi_helmet";
						}
					}
					else if ((int)itemType2 != 11)
					{
						if ((int)itemType2 != 17)
						{
							if ((int)itemType2 != 18)
							{
								goto IL_03e5;
							}
							text = "$item_utility";
						}
						else
						{
							text = "$azu_epi_shoulder";
						}
					}
					else
					{
						text = "$azu_epi_legs";
					}
					goto IL_03f4;
				}
				goto IL_042c;
				IL_042c:
				if (!((Object)(object)val4 != (Object)null))
				{
					continue;
				}
				int variants = reusableVanityItem.m_shared.m_variants;
				if (variants <= 1)
				{
					CreateCell(elementPrefab, val4, reusableVanityItem, MapItemTypeToVisSlot(itemType2));
					continue;
				}
				for (int num2 = 0; num2 < variants && num2 < reusableVanityItem.m_shared.m_icons.Length; num2++)
				{
					CreateCell(elementPrefab, val4, reusableVanityItem, MapItemTypeToVisSlot(itemType2), num2);
				}
				continue;
				IL_03e5:
				text = ((object)(*(ItemType*)(&itemType2))/*cast due to .constrained prefix*/).ToString();
				goto IL_03f4;
				IL_03f4:
				string text2 = text;
				string text3 = Localization.instance.Localize(text2);
				VisSlot slot = MapItemTypeToVisSlot(itemType2);
				AddHeader(text3, slot);
				val4 = AddGrid(text3);
				CreateNoneCell(elementPrefab, val4, MapItemTypeToVisSlot(itemType2));
				goto IL_042c;
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
			_scroll.velocity = Vector2.zero;
			_scroll.normalizedPosition = new Vector2(0f, 1f);
			foreach (VisSlot key in _cellsBySlot.Keys)
			{
				UpdateSelectedVisuals(key);
			}
		}

		public static void UpdateGamepadNavigation()
		{
			if (!_visible || !ZInput.IsGamepadActive() || Console.IsVisible() || PersonalLoadoutGui.IsVisible() || _allCells.Count == 0)
			{
				return;
			}
			if ((Object)(object)_selectedCell == (Object)null || !((Component)_selectedCell).gameObject.activeInHierarchy)
			{
				SelectFirstCell();
				return;
			}
			bool flag = ZInput.GetButtonDown("JoyDPadLeft") || ZInput.GetButtonDown("JoyLStickLeft");
			bool flag2 = ZInput.GetButtonDown("JoyDPadRight") || ZInput.GetButtonDown("JoyLStickRight");
			bool flag3 = ZInput.GetButtonDown("JoyDPadUp") || ZInput.GetButtonDown("JoyLStickUp");
			bool flag4 = ZInput.GetButtonDown("JoyDPadDown") || ZInput.GetButtonDown("JoyLStickDown");
			if (flag || flag2 || flag3 || flag4)
			{
				Navigate(flag, flag2, flag3, flag4);
			}
			if (ZInput.GetButtonDown("JoyButtonA"))
			{
				_selectedCell?.OnLeftClick(null);
			}
			else if (ZInput.GetButtonDown("JoyButtonX"))
			{
				_selectedCell?.OnRightClick(null);
			}
			else if (ZInput.GetButtonDown("JoyLTrigger"))
			{
				ToggleCurrentSection();
			}
		}

		private static void ToggleCurrentSection()
		{
			if ((Object)(object)_selectedCell == (Object)null)
			{
				return;
			}
			int num = ((Component)_selectedCell).transform.parent.GetSiblingIndex() - 1;
			if (num >= 0 && num < ((Transform)_content).childCount)
			{
				Button component = ((Component)((Transform)_content).GetChild(num)).GetComponent<Button>();
				if ((Object)(object)component != (Object)null)
				{
					((UnityEvent)component.onClick).Invoke();
				}
			}
		}

		private static void Navigate(bool left, bool right, bool up, bool down)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			if ((Object)(object)_selectedCell == (Object)null)
			{
				return;
			}
			GridLayoutGroup component = ((Component)((Component)_selectedCell).transform.parent).GetComponent<GridLayoutGroup>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			List<VanityCell> list = new List<VanityCell>();
			foreach (Transform item in ((Component)component).transform)
			{
				Transform val = item;
				if (((Component)val).gameObject.activeSelf)
				{
					VanityCell component2 = ((Component)val).GetComponent<VanityCell>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						list.Add(component2);
					}
				}
			}
			int num = list.IndexOf(_selectedCell);
			if (num < 0)
			{
				return;
			}
			int constraintCount = component.constraintCount;
			int num2 = num / constraintCount;
			int num3 = num % constraintCount;
			VanityCell vanityCell = null;
			if (left && num3 > 0)
			{
				vanityCell = list[num - 1];
			}
			else if (right && num3 < constraintCount - 1 && num + 1 < list.Count)
			{
				vanityCell = list[num + 1];
			}
			else if (up)
			{
				if (num2 > 0)
				{
					int num4 = (num2 - 1) * constraintCount + num3;
					if (num4 < list.Count)
					{
						vanityCell = list[num4];
					}
				}
				else
				{
					VanityCell vanityCell2 = FindLastCellInSection(GetSectionIndexOfCell(_selectedCell) - 1);
					if ((Object)(object)vanityCell2 != (Object)null)
					{
						vanityCell = vanityCell2;
					}
				}
			}
			else if (down)
			{
				int num5 = (num2 + 1) * constraintCount + num3;
				if (num5 < list.Count)
				{
					vanityCell = list[num5];
				}
				else
				{
					VanityCell vanityCell3 = FindFirstCellInSection(GetSectionIndexOfCell(_selectedCell) + 1);
					if ((Object)(object)vanityCell3 != (Object)null)
					{
						vanityCell = vanityCell3;
					}
				}
			}
			if ((Object)(object)vanityCell != (Object)null)
			{
				SelectCell(vanityCell);
			}
		}

		private static int GetSectionIndexOfCell(VanityCell cell)
		{
			if (!Object.op_Implicit((Object)(object)cell))
			{
				return -1;
			}
			return ((Component)cell).transform.parent.GetSiblingIndex();
		}

		private static VanityCell FindFirstCellInSection(int sectionIndex)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			if (sectionIndex < 0 || sectionIndex >= ((Transform)_content).childCount)
			{
				return null;
			}
			Transform child = ((Transform)_content).GetChild(sectionIndex);
			if (!((Component)child).gameObject.activeSelf)
			{
				return FindFirstCellInSection(sectionIndex + 1);
			}
			GridLayoutGroup component = ((Component)child).GetComponent<GridLayoutGroup>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return null;
			}
			foreach (Transform item in ((Component)component).transform)
			{
				Transform val = item;
				if (((Component)val).gameObject.activeSelf)
				{
					VanityCell component2 = ((Component)val).GetComponent<VanityCell>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						return component2;
					}
				}
			}
			return FindFirstCellInSection(sectionIndex + 1);
		}

		private static VanityCell FindLastCellInSection(int sectionIndex)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			if (sectionIndex < 0 || sectionIndex >= ((Transform)_content).childCount)
			{
				return null;
			}
			Transform child = ((Transform)_content).GetChild(sectionIndex);
			if (!((Component)child).gameObject.activeSelf)
			{
				return FindLastCellInSection(sectionIndex - 1);
			}
			GridLayoutGroup component = ((Component)child).GetComponent<GridLayoutGroup>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return null;
			}
			VanityCell vanityCell = null;
			foreach (Transform item in ((Component)component).transform)
			{
				Transform val = item;
				if (((Component)val).gameObject.activeSelf)
				{
					VanityCell component2 = ((Component)val).GetComponent<VanityCell>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						vanityCell = component2;
					}
				}
			}
			return vanityCell ?? FindLastCellInSection(sectionIndex - 1);
		}

		private static void SelectFirstCell()
		{
			foreach (VanityCell allCell in _allCells)
			{
				if (Object.op_Implicit((Object)(object)allCell) && ((Component)allCell).gameObject.activeInHierarchy)
				{
					SelectCell(allCell);
					break;
				}
			}
		}

		private static void SelectCell(VanityCell cell)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)cell))
			{
				return;
			}
			if ((Object)(object)_selectedCell != (Object)null && (Object)(object)_selectedCell.SelectedBadge != (Object)null)
			{
				_selectedCell.SelectedBadge.SetActive(false);
			}
			_selectedCell = cell;
			if ((Object)(object)_selectedCell.SelectedBadge != (Object)null)
			{
				_selectedCell.SelectedBadge.SetActive(true);
			}
			UpdateEquippedBorders();
			Transform parent = ((Component)cell).transform.parent;
			if (!((Component)parent).gameObject.activeSelf)
			{
				((Component)parent).gameObject.SetActive(true);
				int num = parent.GetSiblingIndex() - 1;
				if (num >= 0)
				{
					TextMeshProUGUI component = ((Component)((Transform)_content).GetChild(num)).GetComponent<TextMeshProUGUI>();
					if (Object.op_Implicit((Object)(object)component) && _headerInfo.TryGetValue(component, out (string, VisSlot) value))
					{
						ApplyHeaderStyle(component, value.Item1, value.Item2, isExpanded: true);
					}
				}
				LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
			}
			EnsureSelectionVisible();
		}

		private static void EnsureSelectionVisible()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_00ac: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_selectedCell) && Object.op_Implicit((Object)(object)_scroll) && Object.op_Implicit((Object)(object)_viewport) && Object.op_Implicit((Object)(object)_content))
			{
				RectTransform val = (RectTransform)((Component)_selectedCell).transform;
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				val.GetWorldCorners(array);
				Vector3[] array2 = (Vector3[])(object)new Vector3[4];
				_viewport.GetWorldCorners(array2);
				float y = array[1].y;
				float y2 = array[0].y;
				float y3 = array2[1].y;
				float y4 = array2[0].y;
				if (y > y3 || y2 < y4)
				{
					Canvas.ForceUpdateCanvases();
					Vector2 anchoredPosition = _content.anchoredPosition;
					Rect rect = _viewport.rect;
					float height = ((Rect)(ref rect)).height;
					rect = _content.rect;
					float height2 = ((Rect)(ref rect)).height;
					float num = Mathf.Clamp(0f - val.anchoredPosition.y - height / 2f, 0f, Mathf.Max(0f, height2 - height));
					_content.anchoredPosition = new Vector2(anchoredPosition.x, num);
				}
			}
		}

		internal static void UpdateSelectedVisuals(VisSlot slot)
		{
			//IL_0000: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			UpdateHeaderLabel(slot);
			if (ZInput.IsGamepadActive() && _visible)
			{
				UpdateEquippedBorders();
				return;
			}
			VisEquipment val = ((Humanoid)(Player.m_localPlayer?)).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			VanityState state = VanitySlots.GetState(val, slot);
			if (!_cellsBySlot.TryGetValue(slot, out List<VanityCell> value))
			{
				return;
			}
			foreach (VanityCell item in value)
			{
				bool active = (item.IsNone ? state.IsHidden : (state.HasVanity && Object.op_Implicit((Object)(object)item.Item?.m_dropPrefab) && StringExtensionMethods.GetStableHashCode(((Object)item.Item.m_dropPrefab).name) == state.Hash && item.Variant == state.Variant));
				if (Object.op_Implicit((Object)(object)item.SelectedBadge))
				{
					item.SelectedBadge.SetActive(active);
				}
			}
		}

		private static void UpdateEquippedBorders()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			VisEquipment val = ((Humanoid)(Player.m_localPlayer?)).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			foreach (VisSlot key in _cellsBySlot.Keys)
			{
				VanityState state = VanitySlots.GetState(val, key);
				List<VanityCell> orCreateSlotList = GetOrCreateSlotList(key);
				if (orCreateSlotList == null)
				{
					continue;
				}
				foreach (VanityCell item in orCreateSlotList)
				{
					if (Object.op_Implicit((Object)(object)item) && Object.op_Implicit((Object)(object)item.EquippedBorder))
					{
						bool active = (item.IsNone ? state.IsHidden : (state.HasVanity && Object.op_Implicit((Object)(object)item.Item?.m_dropPrefab) && StringExtensionMethods.GetStableHashCode(((Object)item.Item.m_dropPrefab).name) == state.Hash && item.Variant == state.Variant));
						item.EquippedBorder.SetActive(active);
					}
				}
			}
		}

		public static void ResetAllVanities()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				return;
			}
			VisEquipment visEquipment = ((Humanoid)localPlayer).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment))
			{
				return;
			}
			VanityAPI.ClearVanity(visEquipment, (VisSlot)6);
			VanityAPI.ClearVanity(visEquipment, (VisSlot)4);
			VanityAPI.ClearVanity(visEquipment, (VisSlot)5);
			VanityAPI.ClearVanity(visEquipment, (VisSlot)7);
			VanityAPI.ClearVanity(visEquipment, (VisSlot)8);
			foreach (VisSlot key in _cellsBySlot.Keys)
			{
				UpdateSelectedVisuals(key);
			}
			VECloneSync.ResetStamp();
			VECloneSync.MirrorFrom(localPlayer, AzuEPICharacterPanel.playerPreviewComp);
		}

		private static void BuildPanel(InventoryGui gui)
		{
			_panel = PanelUtilities.BuildPanel(gui, "AzuEPI_VanityPanel");
			((Component)(object)_panel).GetOrAddComponent<Localize>();
		}

		private static void BuildScrollTree()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00fd: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)_panel))
			{
				StoreGui instance = StoreGui.instance;
				GameObject val;
				if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)((Component)instance).GetComponentInChildren<ScrollRect>()))
				{
					val = Object.Instantiate<GameObject>(((Component)((Component)instance).GetComponentInChildren<ScrollRect>()).gameObject, (Transform)(object)_panel);
				}
				else
				{
					val = new GameObject("ScrollRoot", new Type[2]
					{
						typeof(RectTransform),
						typeof(ScrollRect)
					});
					val.transform.SetParent((Transform)(object)_panel, false);
				}
				RectTransform val2 = (RectTransform)val.transform;
				PanelUtilities.AnchorFill(val2);
				val2.offsetMin = ScrollRootOffsetMin;
				val2.offsetMax = ScrollRootOffsetMax;
				_scroll = val.GetComponent<ScrollRect>();
				_scroll.horizontal = false;
				_scroll.vertical = true;
				_scroll.movementType = (MovementType)2;
				_scroll.inertia = true;
				_scroll.decelerationRate = 0.135f;
				_scroll.scrollSensitivity = 800f;
				_viewport = BuildViewport(val2);
				BuildContentStack(_viewport);
				_scroll.viewport = _viewport;
				_scroll.content = _content;
				_vbar = BuildScrollbar((Transform)(object)_panel);
				_scroll.verticalScrollbar = _vbar;
				_scroll.verticalScrollbarVisibility = (ScrollbarVisibility)2;
			}
		}

		private static RectTransform BuildViewport(RectTransform parent)
		{
			return PanelUtilities.BuildViewport(parent, "Viewport");
		}

		private static void BuildContentStack(RectTransform parent)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			_content = PanelUtilities.BuildVerticalContent(parent, "Content", new RectOffset(12, 12, 12, 12));
			_stack = ((Component)_content).GetComponent<VerticalLayoutGroup>();
			_fitter = ((Component)_content).GetComponent<ContentSizeFitter>();
		}

		private static Scrollbar BuildScrollbar(Transform panelParent)
		{
			//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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			return PanelUtilities.BuildScrollbar(panelParent, new PanelUtilities.ScrollbarConfig
			{
				Name = "Scrollbar",
				AnchorMin = BarAnchorMin,
				AnchorMax = BarAnchorMax,
				Pivot = BarPivot,
				OffsetMin = BarOffsetMin,
				OffsetMax = BarOffsetMax
			});
		}

		private static void BuildVanityToggleButton(InventoryGui gui)
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			PanelUtilities.ButtonConfig config = new PanelUtilities.ButtonConfig("AzuEPI_VanityToggleButton", ToggleBtnAnchorMin, ToggleBtnAnchorMax, ToggleBtnPivot, ToggleBtnPos, ToggleBtnSize, PanelUtilities.KeyCodeToZInputKey(AzuExtendedPlayerInventoryPlugin.VanityToggleGamepadKey.Value), AzuExtendedPlayerInventoryPlugin.VanityToggleGamepadKey.Value, "\ud83d\udc55", 36f, delegate
			{
				_visible = !_visible;
				SetVisible(_visible);
				if (PersonalLoadoutGui.IsVisible())
				{
					PersonalLoadoutGui.Hide();
				}
				if (StatsPanelController.IsVisible())
				{
					StatsPanelController.Hide();
				}
				PanelUtilities.HideCraftingElements(_visible);
			});
			(VanityButtonGo, _toggleBtn) = PanelUtilities.BuildToggleButton(gui, (Transform)(object)ToggleButtonParentGlg, config);
			((Component)VanityButtonGo).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.VanityOption.Value.isOn());
		}

		private static void BuildResetButton(InventoryGui gui)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			Button takeAllButton = gui.m_takeAllButton;
			object obj = ((takeAllButton != null) ? ((Component)takeAllButton).transform : null);
			if (obj == null)
			{
				Button craftButton = gui.m_craftButton;
				obj = ((craftButton != null) ? ((Component)craftButton).transform : null);
			}
			Transform val = (Transform)obj;
			if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)_panel))
			{
				Transform obj2 = PanelUtilities.CloneButton(val, (Transform)(object)_panel, "ResetAllVanityButton", ResetBtnAnchorMin, ResetBtnAnchorMax, ResetBtnPivot, ResetBtnPos, ResetBtnSize);
				PanelUtilities.BindGamePad(obj2, PanelUtilities.KeyCodeToZInputKey((KeyCode)345), (KeyCode)0, gui);
				Button component = ((Component)obj2).GetComponent<Button>();
				((UnityEventBase)component.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = component.onClick;
				object obj3 = <>O.<0>__ResetAllVanities;
				if (obj3 == null)
				{
					UnityAction val2 = ResetAllVanities;
					<>O.<0>__ResetAllVanities = val2;
					obj3 = (object)val2;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj3);
				TMP_Text componentInChildren = ((Component)obj2).GetComponentInChildren<TMP_Text>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.text = Localization.instance.Localize("$azuepi_reset_vanity");
				}
				_resetVanitiesBtn = component;
			}
		}

		private static RectTransform AddHeader(string label, VisSlot slot)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			GameObject val = new GameObject("HeaderRow_" + label, new Type[3]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup),
				typeof(LayoutElement)
			});
			RectTransform containerRt = (RectTransform)val.transform;
			((Transform)containerRt).SetParent((Transform)(object)_content, false);
			HorizontalLayoutGroup component = val.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).spacing = 10f;
			((LayoutGroup)component).padding = new RectOffset(0, 0, 0, 0);
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.minHeight = 26f;
			component2.preferredHeight = 26f;
			component2.flexibleWidth = 1f;
			CreateSlotResetButton(containerRt, slot);
			GameObject val2 = new GameObject("Header_" + label, new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			((Transform)(RectTransform)val2.transform).SetParent((Transform)(object)containerRt, false);
			LayoutElement component3 = val2.GetComponent<LayoutElement>();
			component3.flexibleWidth = 1f;
			component3.minHeight = 24f;
			component3.preferredHeight = 24f;
			TextMeshProUGUI txt = val2.AddComponent<TextMeshProUGUI>();
			ApplyHeaderStyle(txt, label, slot, isExpanded: false);
			_headersBySlot[slot] = txt;
			_headerInfo[txt] = (label, slot);
			_headerRectsBySlot[slot] = containerRt;
			((UnityEvent)val2.AddComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				int siblingIndex = ((Transform)containerRt).GetSiblingIndex();
				if (siblingIndex + 1 < ((Transform)_content).childCount)
				{
					Transform child = ((Transform)_content).GetChild(siblingIndex + 1);
					bool flag = !((Component)child).gameObject.activeSelf;
					((Component)child).gameObject.SetActive(flag);
					ApplyHeaderStyle(txt, label, slot, flag);
					LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
				}
			});
			return containerRt;
		}

		private static void CreateSlotResetButton(RectTransform parent, VisSlot slot)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Button takeAllButton = instance.m_takeAllButton;
				obj = ((takeAllButton != null) ? ((Component)takeAllButton).transform : null);
			}
			if (obj == null)
			{
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					Button craftButton = instance.m_craftButton;
					obj = ((craftButton != null) ? ((Component)craftButton).transform : null);
				}
			}
			Transform val = (Transform)obj;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			Transform val2 = Object.Instantiate<Transform>(val, (Transform)(object)parent);
			((Object)val2).name = $"ResetBtn_{slot}";
			_ = (RectTransform)val2;
			LayoutElement obj2 = ((Component)val2).gameObject.GetComponent<LayoutElement>() ?? ((Component)val2).gameObject.AddComponent<LayoutElement>();
			obj2.ignoreLayout = false;
			obj2.minWidth = 50f;
			obj2.preferredWidth = 50f;
			obj2.minHeight = 22f;
			obj2.preferredHeight = 22f;
			obj2.flexibleWidth = 0f;
			obj2.flexibleHeight = 0f;
			UIGamePad component = ((Component)val2).GetComponent<UIGamePad>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (Object.op_Implicit((Object)(object)component.m_hint))
				{
					component.m_hint.gameObject.SetActive(false);
				}
				Object.Destroy((Object)(object)component);
			}
			Button component2 = ((Component)val2).GetComponent<Button>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					ResetSlotVanity(slot);
				});
			}
			TMP_Text componentInChildren = ((Component)val2).GetComponentInChildren<TMP_Text>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.text = "X";
				componentInChildren.fontSize = 14f;
			}
			_resetButtonsBySlot[slot] = ((Component)val2).gameObject;
			((Component)val2).gameObject.SetActive(false);
		}

		private static void ResetSlotVanity(VisSlot slot)
		{
			//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)
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer))
			{
				VisEquipment visEquipment = ((Humanoid)localPlayer).m_visEquipment;
				if (Object.op_Implicit((Object)(object)visEquipment))
				{
					VanityAPI.ClearVanity(visEquipment, slot);
					UpdateSelectedVisuals(slot);
					VECloneSync.ResetStamp();
					VECloneSync.MirrorFrom(localPlayer, AzuEPICharacterPanel.playerPreviewComp);
				}
			}
		}

		private static void UpdateResetButtonVisibility(VisSlot slot)
		{
			//IL_0005: 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)
			if (!_resetButtonsBySlot.TryGetValue(slot, out GameObject value) || !Object.op_Implicit((Object)(object)value))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				value.SetActive(false);
				return;
			}
			VisEquipment visEquipment = ((Humanoid)localPlayer).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment))
			{
				value.SetActive(false);
				return;
			}
			VanityState state = VanitySlots.GetState(visEquipment, slot);
			bool active = state.HasVanity || state.IsHidden;
			value.SetActive(active);
		}

		private static void UpdateAllResetButtonVisibility()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			foreach (VisSlot key in _resetButtonsBySlot.Keys)
			{
				UpdateResetButtonVisibility(key);
			}
		}

		private static void ApplyHeaderStyle(TextMeshProUGUI txt, string label, VisSlot slot, bool isExpanded)
		{
			//IL_0072: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_fontSample))
			{
				((TMP_Text)txt).font = _fontSample.font;
				((TMP_Text)txt).fontSharedMaterial = _fontSample.fontSharedMaterial;
				((TMP_Text)txt).fontSize = _fontSample.fontSize + 2f;
				((Graphic)txt).color = ((Graphic)_fontSample).color;
				((TMP_Text)txt).enableWordWrapping = false;
				((TMP_Text)txt).alignment = (TextAlignmentOptions)513;
			}
			else
			{
				((TMP_Text)txt).fontSize = 20f;
				((Graphic)txt).color = Color.white;
				((TMP_Text)txt).alignment = (TextAlignmentOptions)513;
			}
			string text = (isExpanded ? "▼" : "▲");
			string currentVanityItemName = GetCurrentVanityItemName(slot);
			if (!string.IsNullOrEmpty(currentVanityItemName))
			{
				((TMP_Text)txt).text = label + ": " + currentVanityItemName + " <size=10>" + text + "</size>";
			}
			else
			{
				((TMP_Text)txt).text = label + " <size=10>" + text + "</size>";
			}
		}

		private static string GetCurrentVanityItemName(VisSlot slot)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				return null;
			}
			VisEquipment visEquipment = ((Humanoid)localPlayer).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment))
			{
				return null;
			}
			VanityState state = VanitySlots.GetState(visEquipment, slot);
			if (state.IsHidden)
			{
				Localization instance = Localization.instance;
				return ((instance != null) ? instance.Localize("$azuepi_hidden") : null) ?? "Hidden";
			}
			if (!state.HasVanity || state.Hash == 0)
			{
				return null;
			}
			if (VanityLookup.TryGetByHash(state.Hash, out string _, out ItemDrop itemDrop) && itemDrop?.m_itemData?.m_shared != null)
			{
				Localization instance2 = Localization.instance;
				return ((instance2 != null) ? instance2.Localize(itemDrop.m_itemData.m_shared.m_name) : null) ?? itemDrop.m_itemData.m_shared.m_name;
			}
			return null;
		}

		private static void UpdateHeaderLabel(VisSlot slot)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (_headersBySlot.TryGetValue(slot, out TextMeshProUGUI value) && Object.op_Implicit((Object)(object)value) && _headerInfo.TryGetValue(value, out (string, VisSlot) value2))
			{
				bool isExpanded = ((TMP_Text)value).text.Contains("▼");
				ApplyHeaderStyle(value, value2.Item1, slot, isExpanded);
				UpdateResetButtonVisibility(slot);
			}
		}

		public static void UpdateAllHeaderLabels()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<TextMeshProUGUI, (string, VisSlot)> item in _headerInfo)
			{
				if (Object.op_Implicit((Object)(object)item.Key))
				{
					bool isExpanded = ((TMP_Text)item.Key).text.Contains("▼");
					ApplyHeaderStyle(item.Key, item.Value.Item1, item.Value.Item2, isExpanded);
				}
			}
		}

		private static GridLayoutGroup AddGrid(string headerLabel)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0044: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			GameObject val = new GameObject(headerLabel + "_Grid", new Type[3]
			{
				typeof(RectTransform),
				typeof(GridLayoutGroup),
				typeof(LayoutElement)
			});
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)_content, false);
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.flexibleWidth = 1f;
			component.flexibleHeight = 0f;
			GridLayoutGroup component2 = val.GetComponent<GridLayoutGroup>();
			((LayoutGroup)component2).childAlignment = (TextAnchor)0;
			component2.cellSize = CellSize;
			component2.spacing = Spacing;
			component2.startCorner = (Corner)0;
			component2.startAxis = (Axis)0;
			component2.constraint = (Constraint)1;
			component2.constraintCount = 7;
			((LayoutGroup)component2).padding = new RectOffset((int)Padding.x, (int)Padding.x, (int)Padding.y, (int)Padding.y);
			val.SetActive(false);
			return component2;
		}

		private static void CreateNoneCell(GameObject slotPrefab, GridLayoutGroup grid, VisSlot slot)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(slotPrefab, ((Component)grid).transform);
			((Transform)(RectTransform)val.transform).localScale = Vector3.one;
			LayoutElement obj = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
			float minWidth = (obj.preferredWidth = grid.cellSize.x);
			obj.minWidth = minWidth;
			minWidth = (obj.preferredHeight = grid.cellSize.y);
			obj.minHeight = minWidth;
			obj.flexibleWidth = 0f;
			obj.flexibleHeight = 0f;
			Image component = ((Component)val.transform.Find("icon")).GetComponent<Image>();
			component.sprite = null;
			((Behaviour)component).enabled = false;
			PanelUtilities.DisableChild(val.transform, "amount");
			PanelUtilities.DisableChild(val.transform, "equiped");
			PanelUtilities.DisableChild(val.transform, "queued");
			PanelUtilities.DisableChild(val.transform, "noteleport");
			PanelUtilities.DisableChild(val.transform, "foodicon");
			PanelUtilities.DisableChild(val.transform, "durability");
			PanelUtilities.DisableChild(val.transform, "quality");
			PanelUtilities.DisableChild(val.transform, "binding");
			PanelUtilities.DisableChildrenContaining(val.transform, "JC_");
			GameObject val2 = new GameObject("NoneLabel", new Type[1] { typeof(RectTransform) });
			RectTransform val3 = (RectTransform)val2.transform;
			((Transform)val3).SetParent(val.transform, false);
			val3.anchorMin = new Vector2(0.5f, 0.5f);
			val3.pivot = new Vector2(0.5f, 0.5f);
			val3.anchoredPosition = Vector2.zero;
			TextMeshProUGUI val4 = val2.AddComponent<TextMeshProUGUI>();
			if (Object.op_Implicit((Object)(object)_fontSample))
			{
				((TMP_Text)val4).font = _fontSample.font;
				((TMP_Text)val4).fontSharedMaterial = _fontSample.fontSharedMaterial;
				((TMP_Text)val4).fontSize = _fontSample.fontSize - 2f;
				((Graphic)val4).color = ((Graphic)_fontSample).color;
				((TMP_Text)val4).enableWordWrapping = false;
				((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			}
			else
			{
				((TMP_Text)val4).fontSize = 16f;
				((Graphic)val4).color = Color.white;
				((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			}
			((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val4).enableWordWrapping = true;
			Localization instance = Localization.instance;
			((TMP_Text)val4).text = ((instance != null) ? instance.Localize("$menu_none") : null) ?? "None";
			GameObject selectedBadge = FindOrCreateSelectedBadge(val.transform);
			GameObject equippedBorder = FindOrCreateEquippedBadge(val.transform);
			val.GetComponent<Button>().onClick = new ButtonClickedEvent();
			VanityCell vanityCell = val.GetComponent<VanityCell>() ?? val.AddComponent<VanityCell>();
			vanityCell.Item = null;
			vanityCell.Icon = component;
			vanityCell.Slot = slot;
			vanityCell.SelectedBadge = selectedBadge;
			vanityCell.EquippedBorder = equippedBorder;
			vanityCell.IsNone = true;
			GetOrCreateSlotList(slot).Add(vanityCell);
			_allCells.Add(vanityCell);
			UITooltip obj2 = val.GetComponent<UITooltip>() ?? val.AddComponent<UITooltip>();
			Localization instance2 = Localization.instance;
			obj2.m_topic = ((instance2 != null) ? instance2.Localize("$menu_none") : null) ?? "None";
			obj2.m_text = "";
		}

		private static void CreateCell(GameObject slotPrefab, GridLayoutGroup grid, ItemData data, VisSlot slot, int variant = 0)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			Sprite[] icons = data.m_shared.m_icons;
			if (icons != null && variant < icons.Length && !((Object)(object)icons[variant] == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(slotPrefab, ((Component)grid).transform);
				((Transform)(RectTransform)val.transform).localScale = Vector3.one;
				LayoutElement obj = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
				float minWidth = (obj.preferredWidth = grid.cellSize.x);
				obj.minWidth = minWidth;
				minWidth = (obj.preferredHeight = grid.cellSize.y);
				obj.minHeight = minWidth;
				obj.flexibleWidth = 0f;
				obj.flexibleHeight = 0f;
				Image component = ((Component)val.transform.Find("icon")).GetComponent<Image>();
				component.sprite = icons[variant];
				component.type = (Type)0;
				component.preserveAspect = true;
				((Graphic)component).color = Color.white;
				PanelUtilities.DisableChild(val.transform, "amount");
				PanelUtilities.DisableChild(val.transform, "equiped");
				PanelUtilities.DisableChild(val.transform, "queued");
				PanelUtilities.DisableChild(val.transform, "noteleport");
				PanelUtilities.DisableChild(val.transform, "foodicon");
				PanelUtilities.DisableChild(val.transform, "durability");
				PanelUtilities.DisableChild(val.transform, "quality");
				PanelUtilities.DisableChild(val.transform, "binding");
				PanelUtilities.DisableChildrenContaining(val.transform, "JC_");
				GameObject selectedBadge = FindOrCreateSelectedBadge(val.transform);
				GameObject equippedBorder = FindOrCreateEquippedBadge(val.transform);
				val.GetComponent<Button>().onClick = new ButtonClickedEvent();
				VanityCell vanityCell = val.GetComponent<VanityCell>() ?? val.AddComponent<VanityCell>();
				vanityCell.Item = data;
				vanityCell.Icon = component;
				vanityCell.Slot = slot;
				vanityCell.Variant = variant;
				vanityCell.SelectedBadge = selectedBadge;
				vanityCell.EquippedBorder = equippedBorder;
				GetOrCreateSlotList(slot).Add(vanityCell);
				_allCells.Add(vanityCell);
			}
		}

		private static VisSlot MapItemTypeToVisSlot(ItemType t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0028: 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_0016: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_0024: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			if ((int)t <= 7)
			{
				if ((int)t == 6)
				{
					return (VisSlot)6;
				}
				if ((int)t == 7)
				{
					return (VisSlot)4;
				}
			}
			else
			{
				if ((int)t == 11)
				{
					return (VisSlot)5;
				}
				if ((int)t == 17)
				{
					return (VisSlot)7;
				}
				if ((int)t == 18)
				{
					return (VisSlot)8;
				}
			}
			throw new NotSupportedException($"Vanity not supported for {t}");
		}

		private static GameObject FindOrCreateSelectedBadge(Transform root)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			Transform val = root.Find("selected") ?? root.Find("Selected");
			if (Object.op_Implicit((Object)(object)val))
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject("Selected", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform val3 = (RectTransform)val2.transform;
			((Transform)val3).SetParent(root, false);
			PanelUtilities.AnchorFill(val3);
			Image component = val2.GetComponent<Image>();
			((Graphic)component).raycastTarget = false;
			((Graphic)component).color = new Color(1f, 1f, 1f, 0.18f);
			val2.SetActive(false);
			return val2;
		}

		private static GameObject FindOrCreateEquippedBadge(Transform root)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			Transform val = root.Find("equiped") ?? root.Find("equiped_jc_disabled");
			if (Object.op_Implicit((Object)(object)val))
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject("equiped", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform val3 = (RectTransform)val2.transform;
			((Transform)val3).SetParent(root, false);
			PanelUtilities.AnchorFill(val3);
			Image component = val2.GetComponent<Image>();
			((Graphic)component).raycastTarget = false;
			((Graphic)component).color = new Color(1f, 1f, 1f, 0.18f);
			val2.SetActive(false);
			return val2;
		}

		private static List<VanityCell> GetOrCreateSlotList(VisSlot slot)
		{
			//IL_0005: 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)
			if (!_cellsBySlot.TryGetValue(slot, out List<VanityCell> value))
			{
				value = new List<VanityCell>();
				_cellsBySlot[slot] = value;
			}
			return value;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Show")]
	internal static class Vanity_OnShow
	{
		private static void Postfix(InventoryGui __instance)
		{
			VanityPanelController.EnsureBuilt(__instance);
		}
	}
	public class VanityCell : MonoBehaviour
	{
		public ItemData Item;

		public Image Icon;

		public VisSlot Slot;

		public int Variant;

		public GameObject SelectedBadge;

		public GameObject EquippedBorder;

		public bool IsNone;

		private UIInputHandler _input;

		private bool? _lastKnownState;

		private void Awake()
		{
			UITooltip component = ((Component)this).gameObject.GetComponent<UITooltip>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_topic = Item?.m_shared?.m_name ?? "";
				component.m_text = "";
			}
			_input = ((Component)this).gameObject.GetComponentInChildren<UIInputHandler>();
			if (!((Object)(object)_input == (Object)null))
			{
				UIInputHandler input = _input;
				input.m_onRightDown = (Action<UIInputHandler>)Delegate.Combine(input.m_onRightDown, new Action<UIInputHandler>(OnRightClick));
				UIInputHandler input2 = _input;
				input2.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(input2.m_onLeftDown, new Action<UIInputHandler>(OnLeftClick));
			}
		}

		private void OnDestroy()
		{
			if (!((Object)(object)_input == (Object)null))
			{
				UIInputHandler input = _input;
				input.m_onRightDown = (Action<UIInputHandler>)Delegate.Remove(input.m_onRightDown, new Action<UIInputHandler>(OnRightClick));
				UIInputHandler input2 = _input;
				input2.m_onLeftDown = (Action<UIInputHandler>)Delegate.Remove(input2.m_onLeftDown, new Action<UIInputHandler>(OnLeftClick));
			}
		}

		private void Update()
		{
			//IL_008a: 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)
			if (IsNone || !Object.op_Implicit((Object)(object)Icon) || Item?.m_shared == null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				bool flag = localPlayer.IsKnownMaterial(Item.m_shared.m_name);
				if (!_lastKnownState.HasValue || _lastKnownState.Value != flag)
				{
					_lastKnownState = flag;
					((Graphic)Icon).color = (flag ? Color.white : Color.black);
				}
			}
		}

		public void OnRightClick(UIInputHandler _)
		{
			//IL_0025: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			VisEquipment val = ((Humanoid)(Player.m_localPlayer?)).m_visEquipment;
			if (Object.op_Implicit((Object)(object)val))
			{
				if (IsNone)
				{
					VanityAPI.SetHidden(val, Slot, hidden: false);
					VanityPanelController.UpdateSelectedVisuals(Slot);
					VECloneSync.ResetStamp();
					VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
				}
				else if (!((Object)(object)Item?.m_dropPrefab == (Object)null))
				{
					VanityAPI.ClearVanity(val, Slot);
					VanityPanelController.UpdateSelectedVisuals(Slot);
					VECloneSync.ResetStamp();
					VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
				}
			}
		}

		public void OnLeftClick(UIInputHandler _)
		{
			//IL_0025: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			VisEquipment val = ((Humanoid)(Player.m_localPlayer?)).m_visEquipment;
			if (Object.op_Implicit((Object)(object)val))
			{
				if (IsNone)
				{
					VanityAPI.SetHidden(val, Slot, hidden: true);
					VanityPanelController.UpdateSelectedVisuals(Slot);
					VECloneSync.ResetStamp();
					VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
				}
				else if (Item?.m_shared != null && !((Object)(object)Item.m_dropPrefab == (Object)null) && Player.m_localPlayer.IsKnownMaterial(Item.m_shared.m_name))
				{
					string name = ((Object)Item.m_dropPrefab).name;
					VanityAPI.SetVanity(val, Slot, name, Variant);
					VanityPanelController.UpdateSelectedVisuals(Slot);
					VECloneSync.ResetStamp();
					VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
				}
			}
		}
	}
	internal static class VanityHelper
	{
		internal static int GetVanityValue(VisEquipment ve, int key)
		{
			if ((Object)(object)CharacterSelectionVanity.PreviewPlayer != (Object)null && (Object)(object)ve == (Object)(object)((Humanoid)CharacterSelectionVanity.PreviewPlayer).m_visEquipment)
			{
				if (!CharacterSelectionVanity.VanityData.TryGetValue(key, out var value))
				{
					return 0;
				}
				return value;
			}
			if ((Object)(object)ve == (Object)(object)((Humanoid)(AzuEPICharacterPanel.playerPreviewComp?)).m_visEquipment)
			{
				VisEquipment val = ((Humanoid)(Player.m_localPlayer?)).m_visEquipment;
				if ((Object)(object)val != (Object)null)
				{
					return VanityAPI.Get(val, key);
				}
			}
			return VanityAPI.Get(ve, key);
		}

		internal static int GetVanityVariant(VisEquipment ve, int key)
		{
			if ((Object)(object)CharacterSelectionVanity.PreviewPlayer != (Object)null && (Object)(object)ve == (Object)(object)((Humanoid)CharacterSelectionVanity.PreviewPlayer).m_visEquipment)
			{
				if (!CharacterSelectionVanity.VanityData.TryGetValue(key, out var value))
				{
					return 0;
				}
				return value;
			}
			if ((Object)(object)ve == (Object)(object)((Humanoid)(AzuEPICharacterPanel.playerPreviewComp?)).m_visEquipment)
			{
				VisEquipment val = ((Humanoid)(Player.m_localPlayer?)).m_visEquipment;
				if ((Object)(object)val != (Object)null)
				{
					return VanityAPI.GetVariant(val, key);
				}
			}
			return VanityAPI.GetVariant(ve, key);
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
	internal static class Vanity_Helmet
	{
		private static void Prefix(VisEquipment __instance, ref int hash, ref int hairHash)
		{
			int vanityValue = VanityHelper.GetVanityValue(__instance, VanityZdoKeys.Helmet);
			if (VanityAPI.IsHidden(vanityValue))
			{
				hash = 0;
			}
			else if (vanityValue != 0)
			{
				hash = vanityValue;
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
	internal static class Vanity_Chest
	{
		private static void Prefix(VisEquipment __instance, ref int hash)
		{
			int vanityValue = VanityHelper.GetVanityValue(__instance, VanityZdoKeys.Chest);
			if (VanityAPI.IsHidden(vanityValue))
			{
				hash = 0;
			}
			else if (vanityValue != 0)
			{
				hash = vanityValue;
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
	internal static class Vanity_Legs
	{
		private static void Prefix(VisEquipment __instance, ref int hash)
		{
			int vanityValue = VanityHelper.GetVanityValue(__instance, VanityZdoKeys.Legs);
			if (VanityAPI.IsHidden(vanityValue))
			{
				hash = 0;
			}
			else if (vanityValue != 0)
			{
				hash = vanityValue;
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
	internal static class Vanity_Shoulder
	{
		private static void Prefix(VisEquipment __instance, ref int hash, ref int variant)
		{
			int vanityValue = VanityHelper.GetVanityValue(__instance, VanityZdoKeys.Shoulder);
			if (VanityAPI.IsHidden(vanityValue))
			{
				hash = 0;
				variant = 0;
			}
			else if (vanityValue != 0)
			{
				hash = vanityValue;
				variant = VanityHelper.GetVanityVariant(__instance, VanityZdoKeys.ShoulderVariant);
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "SetUtilityEquipped")]
	internal static class Vanity_Utility
	{
		private static void Prefix(VisEquipment __instance, ref int hash)
		{
			int vanityValue = VanityHelper.GetVanityValue(__instance, VanityZdoKeys.Utility);
			if (VanityAPI.IsHidden(vanityValue))
			{
				hash = 0;
			}
			else if (vanityValue != 0)
			{
				hash = vanityValue;
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "SetTrinketEquipped")]
	internal static class Vanity_Trinket
	{
		private static void Prefix(VisEquipment __instance, ref int hash)
		{
			int vanityValue = VanityHelper.GetVanityValue(__instance, VanityZdoKeys.Trinket);
			if (VanityAPI.IsHidden(vanityValue))
			{
				hash = 0;
			}
			else if (vanityValue != 0)
			{
				hash = vanityValue;
			}
		}
	}
}
namespace AzuEPI.Game.Panels.Stats
{
	public static class StatsPanelController
	{
		private class StatElement
		{
			public string Name { get; set; } = string.Empty;

			public PlayerStatType StatType { get; set; }

			public TextMeshProUGUI ValueText { get; set; }

			public bool IsLiveStat { get; set; }
		}

		public const string StatsPanelName = "AzuEPI_StatsPanel";

		public const string StatsScrollRootName = "StatsPanelScrollRoot";

		public const string StatsViewportName = "StatsPanelViewport";

		public const string StatsContentName = "StatsPanelContent";

		public const string StatsScrollbarName = "StatsPanelScrollbar";

		public const string StatsToggleButtonName = "AzuEPI_StatsToggleButton";

		private static readonly Vector2 ToggleBtnAnchorMin = new Vector2(0f, 1f);

		private static readonly Vector2 ToggleBtnAnchorMax = new Vector2(0f, 1f);

		private static readonly Vector2 ToggleBtnPivot = new Vector2(0f, 1f);

		private static readonly Vector2 ToggleBtnSize = new Vector2(90f, 32f);

		private static readonly Vector2 ScrollRootOffsetMin = new Vector2(10f, 10f);

		private static readonly Vector2 ScrollRootOffsetMax = new Vector2(-10f, -10f);

		private static readonly Vector2 BarAnchorMin = new Vector2(1f, 0f);

		private static readonly Vector2 BarAnchorMax = new Vector2(1f, 1f);

		private static readonly Vector2 BarPivot = new Vector2(1f, 0.5f);

		private static readonly Vector2 BarOffsetMin = new Vector2(-20f, 10f);

		private static readonly Vector2 BarOffsetMax = new Vector2(-10f, -10f);

		private static readonly Vector2 CellSize = new Vector2(85f, 70f);

		private static readonly Vector2 Spacing = new Vector2(6f, 6f);

		private const int Columns = 4;

		private static bool _visible;

		private static RectTransform? _panel;

		private static ScrollRect? _scroll;

		private static RectTransform? _viewport;

		private static RectTransform? _content;

		private static Scrollbar? _vbar;

		private static Button? _toggleBtn;

		internal static Transform? StatsButtonGo;

		private static TMP_FontAsset? _fontAsset;

		private static Transform? _tabBorderTemplate;

		private static readonly List<StatElement> _statElements = new List<StatElement>();

		private static TMP_Dropdown? _playerDropdown;

		private static RectTransform? _dropdownContainer;

		private static bool _isViewingRemotePlayer;

		private static long _viewingPlayerId;

		private static RemotePlayerStats? _currentRemoteStats;

		private static readonly Dictionary<long, RemotePlayerStats> _remoteStatsCache = new Dictionary<long, RemotePlayerStats>();

		private static bool _isLoadingRemoteStats;

		private static readonly List<PlayerInfo> _playerList = new List<PlayerInfo>();

		public static RectTransform? ToggleButtonParentGlg;

		private static readonly Dictionary<PlayerStatType, string> StatIcons = new Dictionary<PlayerStatType, string>
		{
			{
				(PlayerStatType)6,
				"⚔\ufe0f"
			},
			{
				(PlayerStatType)0,
				"\ud83d\udc80"
			},
			{
				(PlayerStatType)51,
				"\ud83c\udff9"
			},
			{
				(PlayerStatType)5,
				"\ud83c\udfaf"
			},
			{
				(PlayerStatType)10,
				"\ud83d\udee1\ufe0f"
			},
			{
				(PlayerStatType)9,
				"⚔\ufe0f"
			},
			{
				(PlayerStatType)8,
				"\ud83d\udca5"
			},
			{
				(PlayerStatType)85,
				"\ud83d\udc79"
			},
			{
				(PlayerStatType)2,
				"\ud83c\udfd7\ufe0f"
			},
			{
				(PlayerStatType)13,
				"\ud83d\udd28"
			},
			{
				(PlayerStatType)14,
				"⬆\ufe0f"
			},
			{
				(PlayerStatType)12,
				"\ud83d\udce6"
			},
			{
				(PlayerStatType)16,
				"\ud83d\uddfa\ufe0f"
			},
			{
				(PlayerStatType)17,
				"\ud83d\udeb6"
			},
			{
				(PlayerStatType)18,
				"\ud83c\udfc3"
			},
			{
				(PlayerStatType)19,
				"⛵"
			},
			{
				(PlayerStatType)20,
				"✈\ufe0f"
			},
			{
				(PlayerStatType)27,
				"\ud83c\udf32"
			},
			{
				(PlayerStatType)37,
				"⛏\ufe0f"
			},
			{
				(PlayerStatType)49,
				"\ud83c\udf56"
			},
			{
				(PlayerStatType)15,
				"\ud83c\udf00"
			},
			{
				(PlayerStatType)3,
				"\ud83e\udd98"
			},
			{
				(PlayerStatType)23,
				"\ud83d\ude34"
			},
			{
				(PlayerStatType)21,
				"\ud83c\udfe0"
			},
			{
				(PlayerStatType)22,
				"\ud83e\udded"
			},
			{
				(PlayerStatType)1,
				"\ud83d\udd27"
			},
			{
				(PlayerStatType)4,
				"\ud83d\udcbb"
			},
			{
				(PlayerStatType)26,
				"\ud83c\udf0d"
			},
			{
				(PlayerStatType)48,
				"\ud83d\udc3a"
			},
			{
				(PlayerStatType)74,
				"\ud83d\udeaa"
			},
			{
				(PlayerStatType)76,
				"\ud83d\udc1d"
			}
		};

		private static readonly Dictionary<PlayerStatType, string> StatLabels = new Dictionary<PlayerStatType, string>
		{
			{
				(PlayerStatType)6,
				"$azu_epi_stat_kills"
			},
			{
				(PlayerStatType)5,
				"$azu_epi_stat_hits"
			},
			{
				(PlayerStatType)10,
				"$azu_epi_stat_hit_taken"
			},
			{
				(PlayerStatType)9,
				"$azu_epi_stat_pvp_kills"
			},
			{
				(PlayerStatType)8,
				"$azu_epi_stat_pvp_hits"
			},
			{
				(PlayerStatType)85,
				"$azu_epi_stat_bosses"
			},
			{
				(PlayerStatType)12,
				"$azu_epi_stat_items"
			},
			{
				(PlayerStatType)16,
				"$azu_epi_stat_distance"
			},
			{
				(PlayerStatType)17,
				"$azu_epi_stat_walked"
			},
			{
				(PlayerStatType)18,
				"$azu_epi_stat_run"
			},
			{
				(PlayerStatType)19,
				"$azu_epi_stat_sailed"
			},
			{
				(PlayerStatType)20,
				"$azu_epi_stat_air"
			},
			{
				(PlayerStatType)27,
				"$azu_epi_stat_trees"
			},
			{
				(PlayerStatType)37,
				"$azu_epi_stat_mines"
			},
			{
				(PlayerStatType)49,
				"$azu_epi_stat_food"
			},
			{
				(PlayerStatType)15,
				"$azu_epi_stat_portals"
			},
			{
				(PlayerStatType)21,
				"$azu_epi_stat_in_base"
			},
			{
				(PlayerStatType)22,
				"$azu_epi_stat_explored"
			},
			{
				(PlayerStatType)1,
				"$azu_epi_stat_craft_upgrades"
			},
			{
				(PlayerStatType)26,
				"$azu_epi_stat_loads"
			},
			{
				(PlayerStatType)48,
				"$azu_epi_stat_tamed"
			},
			{
				(PlayerStatType)74,
				"$azu_epi_stat_doors"
			},
			{
				(PlayerStatType)76,
				"$azu_epi_stat_bees"
			}
		};

		private static readonly List<(long id, string name)> _fakePlayersForTesting = new List<(long, string)>();

		public static ScrollRect? GetScrollRect()
		{
			return _scroll;
		}

		public static bool IsVisible()
		{
			return _visible;
		}

		public static bool IsViewingRemotePlayer()
		{
			return _isViewingRemotePlayer;
		}

		public static void SetVisible(bool visible)
		{
			_visible = visible;
			if (Object.op_Implicit((Object)(object)_panel))
			{
				((Component)_panel).gameObject.SetActive(visible);
			}
			if (!visible)
			{
				ResetToLocalPlayer();
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)_panel))
				{
					return;
				}
				((Transform)_panel).SetAsLastSibling();
				RefreshPlayerDropdownOptions();
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					if (_isViewingRemotePlayer && _currentRemoteStats != null)
					{
						UpdateStatsFromRemoteData(_currentRemoteStats);
					}
					else
					{
						UpdateStats(Player.m_localPlayer);
					}
				}
			}
		}

		private static void ResetToLocalPlayer()
		{
			_isViewingRemotePlayer = false;
			_currentRemoteStats = null;
			_viewingPlayerId = 0L;
			_isLoadingRemoteStats = false;
			if ((Object)(object)_playerDropdown != (Object)null)
			{
				_playerDropdown.SetValueWithoutNotify(0);
			}
		}

		public static void Hide()
		{
			SetVisible(visible: false);
		}

		public static void EnsureBuilt(InventoryGui gui)
		{
			if (!Object.op_Implicit((Object)(object)_panel))
			{
				_fontAsset = PanelUtilities.GetFontAsset(gui);
				if ((Object)(object)_fontAsset == (Object)null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"Could not find TMP font asset for stats panel. Text may not display correctly.");
				}
				_tabBorderTemplate = ((Component)gui.m_crafting).transform.Find("TabsButtons/TabBorder");
				BuildPanel(gui);
				BuildScrollTree();
				PopulateStats();
				RectTransform? panel = _panel;
				if (panel != null)
				{
					((Component)panel).gameObject.SetActive(false);
				}
			}
		}

		internal static void OnStatsConfigChanged(object sender, EventArgs e)
		{
			RebuildStats();
		}

		public static void RebuildStats()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_content))
			{
				return;
			}
			foreach (Transform item in (Transform)_content)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			PopulateStats();
			if (_visible && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				UpdateStats(Player.m_localPlayer);
			}
		}

		private static void BuildPanel(InventoryGui gui)
		{
			_panel = PanelUtilities.BuildPanel(gui, "AzuEPI_StatsPanel");
			((Component)(object)_panel).GetOrAddComponent<Localize>();
		}

		private static void BuildScrollTree()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00fd: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)_panel))
			{
				StoreGui instance = StoreGui.instance;
				GameObject val;
				if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)((Component)instance).GetComponentInChildren<ScrollRect>()))
				{
					val = Object.Instantiate<GameObject>(((Component)((Component)instance).GetComponentInChildren<ScrollRect>()).gameObject, (Transform)(object)_panel);
				}
				else
				{
					val = new GameObject("StatsPanelScrollRoot", new Type[2]
					{
						typeof(RectTransform),
						typeof(ScrollRect)
					});
					val.transform.SetParent((Transform)(object)_panel, false);
				}
				RectTransform val2 = (RectTransform)val.transform;
				PanelUtilities.AnchorFill(val2);
				val2.offsetMin = ScrollRootOffsetMin;
				val2.offsetMax = ScrollRootOffsetMax;
				_scroll = val.GetComponent<ScrollRect>();
				_scroll.horizontal = false;
				_scroll.vertical = true;
				_scroll.movementType = (MovementType)2;
				_scroll.inertia = true;
				_scroll.decelerationRate = 0.135f;
				_scroll.scrollSensitivity = 800f;
				_viewport = BuildViewport(val2);
				BuildContentStack(_viewport);
				_scroll.viewport = _viewport;
				_scroll.content = _content;
				_vbar = BuildScrollbar((Transform)(object)_panel);
				_scroll.verticalScrollbar = _vbar;
				_scroll.verticalScrollbarVisibility = (ScrollbarVisibility)2;
			}
		}

		private static RectTransform BuildViewport(RectTransform parent)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return PanelUtilities.BuildViewport(parent, "StatsPanelViewport", (Color?)new Color(0f, 0f, 0f, 0.565f));
		}

		private static void BuildContentStack(RectTransform parent)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0027: 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)
			_content = PanelUtilities.BuildVerticalContent(parent, "StatsPanelContent", new RectOffset(16, 16, 16, 16), 8f);
			_content.offsetMin = Vector2.zero;
			_content.offsetMax = Vector2.zero;
		}

		private static Scrollbar BuildScrollbar(Transform panelParent)
		{
			//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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			return PanelUtilities.BuildScrollbar(panelParent, new PanelUtilities.ScrollbarConfig
			{
				Name = "StatsPanelScrollbar",
				AnchorMin = BarAnchorMin,
				AnchorMax = BarAnchorMax,
				Pivot = BarPivot,
				OffsetMin = BarOffsetMin,
				OffsetMax = BarOffsetMax
			});
		}

		private static void PopulateStats()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Invalid comparison between Unknown and I4
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Invalid comparison between Unknown and I4
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected I4, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Invalid comparison between Unknown and I4
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)_content))
			{
				return;
			}
			_statElements.Clear();
			CreatePlayerDropdown();
			CreateLiveStatsSection();
			List<PlayerStatType> list = AzuExtendedPlayerInventoryPlugin.ParseStatsList(AzuExtendedPlayerInventoryPlugin.SelectedPlayerStats.Value);
			if (list.Count == 0)
			{
				list = GetDefaultStats();
			}
			List<PlayerStatType> list2 = new List<PlayerStatType>();
			List<PlayerStatType> list3 = new List<PlayerStatType>();
			List<PlayerStatType> list4 = new List<PlayerStatType>();
			List<PlayerStatType> list5 = new List<PlayerStatType>();
			List<PlayerStatType> list6 = new List<PlayerStatType>();
			foreach (PlayerStatType item in list)
			{
				if ((int)item <= 49)
				{
					switch ((int)item)
					{
					default:
						if ((int)item == 49)
						{
							goto case 1;
						}
						goto IL_015c;
					case 0:
					case 4:
					case 26:
						list2.Add(item);
						continue;
					case 5:
					case 6:
					case 8:
					case 9:
					case 10:
						break;
					case 3:
					case 15:
					case 16:
					case 17:
					case 18:
					case 19:
					case 20:
						list4.Add(item);
						continue;
					case 1:
					case 2:
					case 12:
					case 13:
					case 14:
					case 23:
					case 27:
					case 37:
						list5.Add(item);
						continue;
					case 7:
					case 11:
					case 21:
					case 22:
					case 24:
					case 25:
					case 28:
					case 29:
					case 30:
					case 31:
					case 32:
					case 33:
					case 34:
					case 35:
					case 36:
						goto IL_015c;
					}
				}
				else if ((int)item != 51 && (int)item != 85)
				{
					goto IL_015c;
				}
				list3.Add(item);
				continue;
				IL_015c:
				list6.Add(item);
			}
			if (list2.Count > 0)
			{
				CreateSection(Localization.instance.Localize("$azu_epi_stat_section_general"), list2.ToArray());
			}
			if (list3.Count > 0)
			{
				CreateSection(Localization.instance.Localize("$azu_epi_stat_section_combat"), list3.ToArray());
			}
			if (list4.Count > 0)
			{
				CreateSection(Localization.instance.Localize("$azu_epi_stat_section_exploration"), list4.ToArray());
			}
			if (list5.Count > 0)
			{
				CreateSection(Localization.instance.Localize("$azu_epi_stat_section_activity"), list5.ToArray());
			}
			if (list6.Count > 0)
			{
				CreateSection(Localization.instance.Localize("$azu_epi_stat_section_other"), list6.ToArray());
			}
		}

		private static bool IsLiveStatEnabled(LiveStatType stat)
		{
			List<LiveStatType> list = AzuExtendedPlayerInventoryPlugin.ParseLiveStatsList(AzuExtendedPlayerInventoryPlugin.SelectedLiveStats.Value);
			if (list.Count > 0)
			{
				return list.Contains(stat);
			}
			return false;
		}

		private static void CreateLiveStatsSection()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_067c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_099d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab1: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_content))
			{
				return;
			}
			if (IsLiveStatEnabled(LiveStatType.Health) || IsLiveStatEnabled(LiveStatType.Stamina) || IsLiveStatEnabled(LiveStatType.Eitr) || IsLiveStatEnabled(LiveStatType.Adrenaline))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_attributes"), new Color(1f, 0.84f, 0f, 1f));
				if (IsLiveStatEnabled(LiveStatType.Health))
				{
					CreateLiveStatRow("Health", Localization.instance.Localize("$azu_epi_stat_health"));
				}
				if (IsLiveStatEnabled(LiveStatType.Stamina))
				{
					CreateLiveStatRow("Stamina", Localization.instance.Localize("$azu_epi_stat_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.Eitr))
				{
					CreateLiveStatRow("Eitr", Localization.instance.Localize("$azu_epi_stat_eitr"));
				}
				if (IsLiveStatEnabled(LiveStatType.Adrenaline))
				{
					CreateLiveStatRow("Adrenaline", Localization.instance.Localize("$azu_epi_stat_adrenaline"));
				}
				CreateSpacer("Spacer_Attributes");
			}
			if (IsLiveStatEnabled(LiveStatType.HealthRegen) || IsLiveStatEnabled(LiveStatType.HealthRegenMulti) || IsLiveStatEnabled(LiveStatType.FoodRegen) || IsLiveStatEnabled(LiveStatType.StaminaRegen) || IsLiveStatEnabled(LiveStatType.StaminaRegenMulti) || IsLiveStatEnabled(LiveStatType.EitrRegen) || IsLiveStatEnabled(LiveStatType.EitrRegenMulti))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_regeneration"), new Color(0.4f, 1f, 0.4f, 1f));
				if (IsLiveStatEnabled(LiveStatType.HealthRegen))
				{
					CreateLiveStatRow("Health Regen", Localization.instance.Localize("$azu_epi_stat_health_regen"));
				}
				if (IsLiveStatEnabled(LiveStatType.HealthRegenMulti))
				{
					CreateLiveStatRow("Health Regen Multi", Localization.instance.Localize("$azu_epi_stat_health_regen_multi"));
				}
				if (IsLiveStatEnabled(LiveStatType.FoodRegen))
				{
					CreateLiveStatRow("Food Regen", Localization.instance.Localize("$azu_epi_stat_food_regen"));
				}
				if (IsLiveStatEnabled(LiveStatType.StaminaRegen))
				{
					CreateLiveStatRow("Stamina Regen", Localization.instance.Localize("$azu_epi_stat_stamina_regen"));
				}
				if (IsLiveStatEnabled(LiveStatType.StaminaRegenMulti))
				{
					CreateLiveStatRow("Stamina Regen Multi", Localization.instance.Localize("$azu_epi_stat_stamina_regen_multi"));
				}
				if (IsLiveStatEnabled(LiveStatType.EitrRegen))
				{
					CreateLiveStatRow("Eitr Regen", Localization.instance.Localize("$azu_epi_stat_eitr_regen"));
				}
				if (IsLiveStatEnabled(LiveStatType.EitrRegenMulti))
				{
					CreateLiveStatRow("Eitr Regen Multi", Localization.instance.Localize("$azu_epi_stat_eitr_regen_multi"));
				}
				CreateSpacer("Spacer_Regen");
			}
			if (IsLiveStatEnabled(LiveStatType.AttackSpeed) || IsLiveStatEnabled(LiveStatType.DamageModifier) || IsLiveStatEnabled(LiveStatType.StaggerResist) || IsLiveStatEnabled(LiveStatType.TimedBlockBonus) || IsLiveStatEnabled(LiveStatType.CritChance) || IsLiveStatEnabled(LiveStatType.Lifesteal))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_combat"), new Color(1f, 0.5f, 0f, 1f));
				if (IsLiveStatEnabled(LiveStatType.AttackSpeed))
				{
					CreateLiveStatRow("Attack Speed", Localization.instance.Localize("$azu_epi_stat_attack_speed"));
				}
				if (IsLiveStatEnabled(LiveStatType.DamageModifier))
				{
					CreateLiveStatRow("Damage Modifier", Localization.instance.Localize("$azu_epi_stat_damage_modifier"));
				}
				if (IsLiveStatEnabled(LiveStatType.StaggerResist))
				{
					CreateLiveStatRow("Stagger Resist", Localization.instance.Localize("$azu_epi_stat_stagger_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.TimedBlockBonus))
				{
					CreateLiveStatRow("Timed Block Bonus", Localization.instance.Localize("$azu_epi_stat_timed_block_bonus"));
				}
				if (IsLiveStatEnabled(LiveStatType.CritChance))
				{
					CreateLiveStatRow("Crit Chance", Localization.instance.Localize("$azu_epi_stat_crit_chance"));
				}
				if (IsLiveStatEnabled(LiveStatType.Lifesteal))
				{
					CreateLiveStatRow("Lifesteal", Localization.instance.Localize("$azu_epi_stat_lifesteal"));
				}
				CreateSpacer("Spacer_Combat");
			}
			if (IsLiveStatEnabled(LiveStatType.BluntDamage) || IsLiveStatEnabled(LiveStatType.SlashDamage) || IsLiveStatEnabled(LiveStatType.PierceDamage) || IsLiveStatEnabled(LiveStatType.FireDamage) || IsLiveStatEnabled(LiveStatType.FrostDamage) || IsLiveStatEnabled(LiveStatType.LightningDamage) || IsLiveStatEnabled(LiveStatType.PoisonDamage) || IsLiveStatEnabled(LiveStatType.SpiritDamage))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_elemental_damage"), new Color(1f, 0.6f, 0.2f, 1f));
				if (IsLiveStatEnabled(LiveStatType.BluntDamage))
				{
					CreateLiveStatRow("Blunt Damage", Localization.instance.Localize("$azu_epi_stat_blunt_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.SlashDamage))
				{
					CreateLiveStatRow("Slash Damage", Localization.instance.Localize("$azu_epi_stat_slash_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.PierceDamage))
				{
					CreateLiveStatRow("Pierce Damage", Localization.instance.Localize("$azu_epi_stat_pierce_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.FireDamage))
				{
					CreateLiveStatRow("Fire Damage", Localization.instance.Localize("$azu_epi_stat_fire_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.FrostDamage))
				{
					CreateLiveStatRow("Frost Damage", Localization.instance.Localize("$azu_epi_stat_frost_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.LightningDamage))
				{
					CreateLiveStatRow("Lightning Damage", Localization.instance.Localize("$azu_epi_stat_lightning_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.PoisonDamage))
				{
					CreateLiveStatRow("Poison Damage", Localization.instance.Localize("$azu_epi_stat_poison_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.SpiritDamage))
				{
					CreateLiveStatRow("Spirit Damage", Localization.instance.Localize("$azu_epi_stat_spirit_damage"));
				}
				CreateSpacer("Spacer_ElementalDamage");
			}
			if (IsLiveStatEnabled(LiveStatType.CurrentWeight) || IsLiveStatEnabled(LiveStatType.MaxWeight) || IsLiveStatEnabled(LiveStatType.WeightPercentage) || IsLiveStatEnabled(LiveStatType.ExtraCarryWeight))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_carry_weight"), new Color(0.7f, 0.7f, 1f, 1f));
				if (IsLiveStatEnabled(LiveStatType.CurrentWeight))
				{
					CreateLiveStatRow("Current Weight", Localization.instance.Localize("$azu_epi_stat_current_weight"));
				}
				if (IsLiveStatEnabled(LiveStatType.MaxWeight))
				{
					CreateLiveStatRow("Max Weight", Localization.instance.Localize("$azu_epi_stat_max_weight"));
				}
				if (IsLiveStatEnabled(LiveStatType.WeightPercentage))
				{
					CreateLiveStatRow("Weight Percentage", Localization.instance.Localize("$azu_epi_stat_weight_percentage"));
				}
				if (IsLiveStatEnabled(LiveStatType.ExtraCarryWeight))
				{
					CreateLiveStatRow("Extra Carry Weight", Localization.instance.Localize("$azu_epi_stat_extra_carry_weight"));
				}
				CreateSpacer("Spacer_CarryWeight");
			}
			if (IsLiveStatEnabled(LiveStatType.JumpStamina) || IsLiveStatEnabled(LiveStatType.AttackStamina) || IsLiveStatEnabled(LiveStatType.BlockStamina) || IsLiveStatEnabled(LiveStatType.DodgeStamina) || IsLiveStatEnabled(LiveStatType.SwimStamina) || IsLiveStatEnabled(LiveStatType.RunStamina) || IsLiveStatEnabled(LiveStatType.SneakStamina) || IsLiveStatEnabled(LiveStatType.HomeItemStamina))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_stamina_usage"), new Color(1f, 1f, 0.5f, 1f));
				if (IsLiveStatEnabled(LiveStatType.JumpStamina))
				{
					CreateLiveStatRow("Jump Stamina", Localization.instance.Localize("$azu_epi_stat_jump_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.AttackStamina))
				{
					CreateLiveStatRow("Attack Stamina", Localization.instance.Localize("$azu_epi_stat_attack_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.BlockStamina))
				{
					CreateLiveStatRow("Block Stamina", Localization.instance.Localize("$azu_epi_stat_block_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.DodgeStamina))
				{
					CreateLiveStatRow("Dodge Stamina", Localization.instance.Localize("$azu_epi_stat_dodge_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.SwimStamina))
				{
					CreateLiveStatRow("Swim Stamina", Localization.instance.Localize("$azu_epi_stat_swim_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.RunStamina))
				{
					CreateLiveStatRow("Run Stamina", Localization.instance.Localize("$azu_epi_stat_run_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.SneakStamina))
				{
					CreateLiveStatRow("Sneak Stamina", Localization.instance.Localize("$azu_epi_stat_sneak_stamina"));
				}
				if (IsLiveStatEnabled(LiveStatType.HomeItemStamina))
				{
					CreateLiveStatRow("Home Item Stamina", Localization.instance.Localize("$azu_epi_stat_home_item_stamina"));
				}
				CreateSpacer("Spacer_StaminaUsage");
			}
			if (IsLiveStatEnabled(LiveStatType.TotalArmor) || IsLiveStatEnabled(LiveStatType.HeatResistance) || IsLiveStatEnabled(LiveStatType.EquipmentMovement))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_equipment_bonuses"), new Color(1f, 0.8f, 0.5f, 1f));
				if (IsLiveStatEnabled(LiveStatType.TotalArmor))
				{
					CreateLiveStatRow("Total Armor", Localization.instance.Localize("$azu_epi_stat_total_armor"));
				}
				if (IsLiveStatEnabled(LiveStatType.HeatResistance))
				{
					CreateLiveStatRow("Heat Resistance", Localization.instance.Localize("$azu_epi_stat_heat_resistance"));
				}
				if (IsLiveStatEnabled(LiveStatType.EquipmentMovement))
				{
					CreateLiveStatRow("Equipment Movement", Localization.instance.Localize("$azu_epi_stat_equipment_movement"));
				}
				CreateSpacer("Spacer_EquipmentBonuses");
			}
			if (IsLiveStatEnabled(LiveStatType.TopSkills) || IsLiveStatEnabled(LiveStatType.SkillBonuses) || IsLiveStatEnabled(LiveStatType.SkillRaiseSpeed))
			{
				if (IsLiveStatEnabled(LiveStatType.TopSkills))
				{
					CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_top_skills"), new Color(0.8f, 0.5f, 1f, 1f));
					CreateDynamicTextRow("Top Skills");
					CreateSpacer("Spacer_TopSkills");
				}
				if (IsLiveStatEnabled(LiveStatType.SkillBonuses) || IsLiveStatEnabled(LiveStatType.SkillRaiseSpeed))
				{
					CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_skill_bonuses"), new Color(0.8f, 0.5f, 1f, 1f));
					if (IsLiveStatEnabled(LiveStatType.SkillBonuses))
					{
						CreateDynamicTextRow("Skill Bonuses");
					}
					if (IsLiveStatEnabled(LiveStatType.SkillRaiseSpeed))
					{
						CreateLiveStatRow("Skill Raise Speed", Localization.instance.Localize("$azu_epi_stat_skill_raise_speed"));
					}
					CreateSpacer("Spacer_SkillBonuses");
				}
			}
			if (IsLiveStatEnabled(LiveStatType.NoiseLevel) || IsLiveStatEnabled(LiveStatType.StealthLevel) || IsLiveStatEnabled(LiveStatType.CoverPercentage) || IsLiveStatEnabled(LiveStatType.FallDamage) || IsLiveStatEnabled(LiveStatType.ComfortLevel))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_stealth_utility"), new Color(0.6f, 0.6f, 0.8f, 1f));
				if (IsLiveStatEnabled(LiveStatType.NoiseLevel))
				{
					CreateLiveStatRow("Noise Level", Localization.instance.Localize("$azu_epi_stat_noise_level"));
				}
				if (IsLiveStatEnabled(LiveStatType.StealthLevel))
				{
					CreateLiveStatRow("Stealth Level", Localization.instance.Localize("$azu_epi_stat_stealth_level"));
				}
				if (IsLiveStatEnabled(LiveStatType.CoverPercentage))
				{
					CreateLiveStatRow("Cover Percentage", Localization.instance.Localize("$azu_epi_stat_cover_percentage"));
				}
				if (IsLiveStatEnabled(LiveStatType.FallDamage))
				{
					CreateLiveStatRow("Fall Damage", Localization.instance.Localize("$azu_epi_stat_fall_damage"));
				}
				if (IsLiveStatEnabled(LiveStatType.ComfortLevel))
				{
					CreateLiveStatRow("Comfort Level", Localization.instance.Localize("$azu_epi_stat_comfort_level"));
				}
				CreateSpacer("Spacer_Utility");
			}
			if (IsLiveStatEnabled(LiveStatType.MovementSpeed) || IsLiveStatEnabled(LiveStatType.SpeedModifier) || IsLiveStatEnabled(LiveStatType.RunSpeed) || IsLiveStatEnabled(LiveStatType.SwimSpeed) || IsLiveStatEnabled(LiveStatType.JumpHeight))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_movement"), new Color(0.5f, 1f, 0.5f, 1f));
				if (IsLiveStatEnabled(LiveStatType.MovementSpeed))
				{
					CreateLiveStatRow("Movement Speed", Localization.instance.Localize("$azu_epi_stat_movement_speed"));
				}
				if (IsLiveStatEnabled(LiveStatType.SpeedModifier))
				{
					CreateLiveStatRow("Speed Modifier", Localization.instance.Localize("$azu_epi_stat_speed_modifier"));
				}
				if (IsLiveStatEnabled(LiveStatType.RunSpeed))
				{
					CreateLiveStatRow("Run Speed", Localization.instance.Localize("$azu_epi_stat_run_speed"));
				}
				if (IsLiveStatEnabled(LiveStatType.SwimSpeed))
				{
					CreateLiveStatRow("Swim Speed", Localization.instance.Localize("$azu_epi_stat_swim_speed"));
				}
				if (IsLiveStatEnabled(LiveStatType.JumpHeight))
				{
					CreateLiveStatRow("Jump Height", Localization.instance.Localize("$azu_epi_stat_jump_height"));
				}
				CreateSpacer("Spacer_Movement");
			}
			CreateResistancesSection();
			CreateActiveFoodSection();
			CreateActiveEffectsSection();
			CreateSetBonusesSection();
		}

		private static void CreateSectionHeader(string title, Color color)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0037: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content))
			{
				GameObject val = new GameObject("Section_" + title, new Type[1] { typeof(RectTransform) });
				GameObjectHelper.SafeSetActive(val, active: false);
				((Transform)val.GetComponent<RectTransform>()).SetParent((Transform)(object)_content, false);
				TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
				if (Object.op_Implicit((Object)(object)_fontAsset))
				{
					((TMP_Text)val2).font = _fontAsset;
					((TMP_Text)val2).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val, active: true);
				((TMP_Text)val2).text = title;
				((TMP_Text)val2).fontSize = 20f;
				((TMP_Text)val2).fontStyle = (FontStyles)1;
				((TMP_Text)val2).alignment = (TextAlignmentOptions)513;
				((Graphic)val2).color = color;
				((Graphic)val2).raycastTarget = false;
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredHeight = 20f;
				obj.minHeight = 20f;
			}
		}

		private static void CreateSpacer(string name)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content))
			{
				GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
				((Transform)val.GetComponent<RectTransform>()).SetParent((Transform)(object)_content, false);
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredHeight = 8f;
				obj.minHeight = 8f;
			}
		}

		private static void CreateResistancesSection()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0086: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content) && (IsLiveStatEnabled(LiveStatType.Armor) || IsLiveStatEnabled(LiveStatType.BluntResist) || IsLiveStatEnabled(LiveStatType.SlashResist) || IsLiveStatEnabled(LiveStatType.PierceResist) || IsLiveStatEnabled(LiveStatType.FireResist) || IsLiveStatEnabled(LiveStatType.FrostResist) || IsLiveStatEnabled(LiveStatType.LightningResist) || IsLiveStatEnabled(LiveStatType.PoisonResist) || IsLiveStatEnabled(LiveStatType.SpiritResist)))
			{
				GameObject val = new GameObject("Section_Resistances", new Type[1] { typeof(RectTransform) });
				GameObjectHelper.SafeSetActive(val, active: false);
				((Transform)val.GetComponent<RectTransform>()).SetParent((Transform)(object)_content, false);
				TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
				if (Object.op_Implicit((Object)(object)_fontAsset))
				{
					((TMP_Text)val2).font = _fontAsset;
					((TMP_Text)val2).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val, active: true);
				((TMP_Text)val2).text = Localization.instance.Localize("$azu_epi_stat_section_resistances");
				((TMP_Text)val2).fontSize = 20f;
				((TMP_Text)val2).fontStyle = (FontStyles)1;
				((TMP_Text)val2).alignment = (TextAlignmentOptions)513;
				((Graphic)val2).color = new Color(1f, 0.84f, 0f, 1f);
				((Graphic)val2).raycastTarget = false;
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredHeight = 20f;
				obj.minHeight = 20f;
				if (IsLiveStatEnabled(LiveStatType.Armor))
				{
					CreateLiveStatRow("Armor", Localization.instance.Localize("$azu_epi_stat_armor"));
				}
				if (IsLiveStatEnabled(LiveStatType.BluntResist))
				{
					CreateLiveStatRow("Blunt Resist", Localization.instance.Localize("$azu_epi_stat_blunt_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.SlashResist))
				{
					CreateLiveStatRow("Slash Resist", Localization.instance.Localize("$azu_epi_stat_slash_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.PierceResist))
				{
					CreateLiveStatRow("Pierce Resist", Localization.instance.Localize("$azu_epi_stat_pierce_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.FireResist))
				{
					CreateLiveStatRow("Fire Resist", Localization.instance.Localize("$azu_epi_stat_fire_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.FrostResist))
				{
					CreateLiveStatRow("Frost Resist", Localization.instance.Localize("$azu_epi_stat_frost_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.LightningResist))
				{
					CreateLiveStatRow("Lightning Resist", Localization.instance.Localize("$azu_epi_stat_lightning_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.PoisonResist))
				{
					CreateLiveStatRow("Poison Resist", Localization.instance.Localize("$azu_epi_stat_poison_resist"));
				}
				if (IsLiveStatEnabled(LiveStatType.SpiritResist))
				{
					CreateLiveStatRow("Spirit Resist", Localization.instance.Localize("$azu_epi_stat_spirit_resist"));
				}
				GameObject val3 = new GameObject("Spacer_Resistances", new Type[1] { typeof(RectTransform) });
				((Transform)val3.GetComponent<RectTransform>()).SetParent((Transform)(object)_content, false);
				LayoutElement obj2 = val3.AddComponent<LayoutElement>();
				obj2.preferredHeight = 8f;
				obj2.minHeight = 8f;
			}
		}

		private static void CreateActiveEffectsSection()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content) && IsLiveStatEnabled(LiveStatType.ActiveEffects))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_active_effects"), new Color(0.5f, 0.8f, 1f, 1f));
				CreateDynamicTextRow("ActiveEffects");
				CreateSpacer("Spacer_ActiveEffects");
			}
		}

		private static void CreateSetBonusesSection()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content) && IsLiveStatEnabled(LiveStatType.SetBonuses))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_set_bonuses"), new Color(0.8f, 0.6f, 1f, 1f));
				CreateDynamicTextRow("SetBonuses");
				CreateSpacer("Spacer_SetBonuses");
			}
		}

		private static void CreateActiveFoodSection()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content) && IsLiveStatEnabled(LiveStatType.FoodBuffs))
			{
				CreateSectionHeader(Localization.instance.Localize("$azu_epi_stat_section_food_buffs"), new Color(1f, 0.7f, 0.3f, 1f));
				CreateDynamicTextRow("FoodBuffs");
				CreateSpacer("Spacer_FoodBuffs");
			}
		}

		private static void CreateDynamicTextRow(string id)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_004a: 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_007f: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content))
			{
				GameObject val = new GameObject("DynamicText_" + id, new Type[1] { typeof(RectTransform) });
				RectTransform component = val.GetComponent<RectTransform>();
				GameObjectHelper.SafeSetActive(val, active: false);
				((Transform)component).SetParent((Transform)(object)_content, false);
				TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
				if (Object.op_Implicit((Object)(object)_fontAsset))
				{
					((TMP_Text)val2).font = _fontAsset;
					((TMP_Text)val2).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val, active: true);
				((TMP_Text)val2).text = "";
				((TMP_Text)val2).fontSize = 16f;
				((TMP_Text)val2).alignment = (TextAlignmentOptions)257;
				((Graphic)val2).color = new Color(0.9f, 0.9f, 0.9f, 1f);
				((Graphic)val2).raycastTarget = false;
				((TMP_Text)val2).enableWordWrapping = true;
				((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
				ContentSizeFitter obj = val.AddComponent<ContentSizeFitter>();
				obj.horizontalFit = (FitMode)0;
				obj.verticalFit = (FitMode)2;
				LayoutElement obj2 = val.AddComponent<LayoutElement>();
				obj2.minHeight = 16f;
				obj2.preferredHeight = -1f;
				obj2.flexibleHeight = 0f;
				_statElements.Add(new StatElement
				{
					Name = id,
					StatType = (PlayerStatType)(-2),
					ValueText = val2,
					IsLiveStat = true
				});
			}
		}

		private static void CreateLiveStatRow(string id, string displayName)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00b4: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("LiveStatRow_" + id, new Type[2]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)_content, false);
			HorizontalLayoutGroup component2 = val.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = 18f;
			obj.minHeight = 18f;
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			GameObjectHelper.SafeSetActive(val2, active: false);
			((Transform)val2.GetComponent<RectTransform>()).SetParent((Transform)(object)component, false);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			if (Object.op_Implicit((Object)(object)_fontAsset))
			{
				((TMP_Text)val3).font = _fontAsset;
				((TMP_Text)val3).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
			}
			GameObjectHelper.SafeSetActive(val2, active: true);
			((TMP_Text)val3).text = displayName;
			((TMP_Text)val3).fontSize = 18f;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			((Graphic)val3).color = new Color(0.9f, 0.9f, 0.9f, 1f);
			((Graphic)val3).raycastTarget = false;
			LayoutElement obj2 = val2.AddComponent<LayoutElement>();
			obj2.flexibleWidth = 1f;
			obj2.minWidth = 100f;
			GameObject val4 = new GameObject("Value", new Type[1] { typeof(RectTransform) });
			((Transform)val4.GetComponent<RectTransform>()).SetParent((Transform)(object)component, false);
			GameObjectHelper.SafeSetActive(val4, active: false);
			TextMeshProUGUI val5 = val4.AddComponent<TextMeshProUGUI>();
			if (Object.op_Implicit((Object)(object)_fontAsset))
			{
				((TMP_Text)val5).font = _fontAsset;
				((TMP_Text)val5).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
			}
			GameObjectHelper.SafeSetActive(val4, active: true);
			((TMP_Text)val5).text = "0";
			((TMP_Text)val5).fontSize = 18f;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)516;
			((TMP_Text)val5).textWrappingMode = (TextWrappingModes)3;
			((Graphic)val5).color = Color.white;
			((Graphic)val5).raycastTarget = false;
			((TMP_Text)val5).fontStyle = (FontStyles)1;
			LayoutElement obj3 = val4.AddComponent<LayoutElement>();
			obj3.minWidth = 60f;
			obj3.preferredWidth = 60f;
			_statElements.Add(new StatElement
			{
				Name = id,
				StatType = (PlayerStatType)(-1),
				ValueText = val5,
				IsLiveStat = true
			});
			CreateSeparator();
		}

		private static void CreateSeparator()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content) && Object.op_Implicit((Object)(object)_tabBorderTemplate))
			{
				GameObject obj = Object.Instantiate<GameObject>(((Component)_tabBorderTemplate).gameObject, (Transform)(object)_content);
				((Object)obj).name = "Separator";
				RectTransform component = obj.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 0f);
				component.anchorMax = new Vector2(1f, 0f);
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(0f, 2f);
				LayoutElement obj2 = obj.AddComponent<LayoutElement>();
				obj2.preferredHeight = 2f;
				obj2.minHeight = 2f;
				Image component2 = obj.GetComponent<Image>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					Color color = ((Graphic)component2).color;
					color.a = 0.3f;
					((Graphic)component2).color = color;
				}
			}
		}

		private unsafe static void CreateSection(string title, PlayerStatType[] stats)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_content))
			{
				GameObject val = new GameObject("Section_" + title, new Type[1] { typeof(RectTransform) });
				((Transform)val.GetComponent<RectTransform>()).SetParent((Transform)(object)_content, false);
				GameObjectHelper.SafeSetActive(val, active: false);
				TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
				if (Object.op_Implicit((Object)(object)_fontAsset))
				{
					((TMP_Text)val2).font = _fontAsset;
					((TMP_Text)val2).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val, active: true);
				((TMP_Text)val2).text = title;
				((TMP_Text)val2).fontSize = 20f;
				((TMP_Text)val2).fontStyle = (FontStyles)1;
				((TMP_Text)val2).alignment = (TextAlignmentOptions)513;
				((Graphic)val2).color = new Color(1f, 0.84f, 0f, 1f);
				((Graphic)val2).raycastTarget = false;
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredHeight = 20f;
				obj.minHeight = 20f;
				for (int i = 0; i < stats.Length; i++)
				{
					PlayerStatType val3 = stats[i];
					string value;
					string statName = (StatLabels.TryGetValue(val3, out value) ? value : ((object)(*(PlayerStatType*)(&val3))/*cast due to .constrained prefix*/).ToString());
					CreateStatRow(((Component)_content).gameObject, statName, val3);
				}
				GameObject val4 = new GameObject("Spacer_" + title, new Type[1] { typeof(RectTransform) });
				((Transform)val4.GetComponent<RectTransform>()).SetParent((Transform)(object)_content, false);
				LayoutElement obj2 = val4.AddComponent<LayoutElement>();
				obj2.preferredHeight = 8f;
				obj2.minHeight = 8f;
			}
		}

		private static List<PlayerStatType> GetDefaultStats()
		{
			return (from PlayerStatType stat in Enum.GetValues(typeof(PlayerStatType))
				where (int)stat != 105
				select stat).ToList();
		}

		private static void CreateStatRow(GameObject parent, string statName, PlayerStatType statType)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			string text = Localization.instance.Localize(statName);
			GameObject val = new GameObject("StatRow_" + text, new Type[2]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent.transform, false);
			HorizontalLayoutGroup component2 = val.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = 18f;
			obj.minHeight = 18f;
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			GameObjectHelper.SafeSetActive(val2, active: false);
			((Transform)val2.GetComponent<RectTransform>()).SetParent((Transform)(object)component, false);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			if (Object.op_Implicit((Object)(object)_fontAsset))
			{
				((TMP_Text)val3).font = _fontAsset;
				((TMP_Text)val3).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
			}
			GameObjectHelper.SafeSetActive(val2, active: true);
			((TMP_Text)val3).text = text;
			((TMP_Text)val3).fontSize = 18f;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			((Graphic)val3).color = new Color(0.9f, 0.9f, 0.9f, 1f);
			((Graphic)val3).raycastTarget = false;
			LayoutElement obj2 = val2.AddComponent<LayoutElement>();
			obj2.flexibleWidth = 1f;
			obj2.minWidth = 100f;
			GameObject val4 = new GameObject("Value", new Type[1] { typeof(RectTransform) });
			((Transform)val4.GetComponent<RectTransform>()).SetParent((Transform)(object)component, false);
			GameObjectHelper.SafeSetActive(val4, active: false);
			TextMeshProUGUI val5 = val4.AddComponent<TextMeshProUGUI>();
			if (Object.op_Implicit((Object)(object)_fontAsset))
			{
				((TMP_Text)val5).font = _fontAsset;
				((TMP_Text)val5).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
			}
			GameObjectHelper.SafeSetActive(val4, active: true);
			((TMP_Text)val5).text = "0";
			((TMP_Text)val5).fontSize = 18f;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)516;
			((TMP_Text)val5).textWrappingMode = (TextWrappingModes)3;
			((Graphic)val5).color = Color.white;
			((Graphic)val5).raycastTarget = false;
			((TMP_Text)val5).fontStyle = (FontStyles)1;
			LayoutElement obj3 = val4.AddComponent<LayoutElement>();
			obj3.minWidth = 60f;
			obj3.preferredWidth = 60f;
			_statElements.Add(new StatElement
			{
				Name = text,
				StatType = statType,
				ValueText = val5
			});
			CreateSeparator();
		}

		internal static void BuildToggleButton(InventoryGui gui)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ToggleButtonParentGlg == (Object)null)
			{
				return;
			}
			PanelUtilities.ButtonConfig config = new PanelUtilities.ButtonConfig("AzuEPI_StatsToggleButton", ToggleBtnAnchorMin, ToggleBtnAnchorMax, ToggleBtnPivot, new Vector2(-50f, -30f), ToggleBtnSize, PanelUtilities.KeyCodeToZInputKey(AzuExtendedPlayerInventoryPlugin.StatsToggleGamepadKey.Value), AzuExtendedPlayerInventoryPlugin.StatsToggleGamepadKey.Value, "\ud83d\udcca", 36f, delegate
			{
				_visible = !_visible;
				SetVisible(_visible);
				if (VanityPanelController.IsVisible())
				{
					VanityPanelController.SetVisible(visible: false);
				}
				if (PersonalLoadoutGui.IsVisible())
				{
					PersonalLoadoutGui.Hide();
				}
				PanelUtilities.HideCraftingElements(_visible);
			});
			(StatsButtonGo, _toggleBtn) = PanelUtilities.BuildToggleButton(gui, (Transform)(object)ToggleButtonParentGlg, config);
			((Component)StatsButtonGo).gameObject.SetActive(true);
		}

		public static void UpdateStats(Player player)
		{
			//IL_1086: Unknown result type (might be due to invalid IL or missing references)
			//IL_1098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e30: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e50: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e70: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || _statElements.Count == 0)
			{
				return;
			}
			Game instance = Game.instance;
			PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
			if (val == null)
			{
				return;
			}
			foreach (StatElement statElement in _statElements)
			{
				if (statElement.IsLiveStat)
				{
					switch (statElement.Name)
					{
					case "Health":
						((TMP_Text)statElement.ValueText).text = FormatCurrentMax(((Character)player).GetHealth(), ((Character)player).GetMaxHealth());
						break;
					case "Stamina":
						((TMP_Text)statElement.ValueText).text = FormatCurrentMax(player.GetStamina(), ((Character)player).GetMaxStamina());
						break;
					case "Eitr":
						((TMP_Text)statElement.ValueText).text = FormatCurrentMax(player.GetEitr(), ((Character)player).GetMaxEitr());
						break;
					case "Adrenaline":
						((TMP_Text)statElement.ValueText).text = FormatPercent(CalculateAdrenaline(player));
						break;
					case "Health Regen":
						((TMP_Text)statElement.ValueText).text = FormatRegen(CalculateHealthRegen(player), "/tick");
						break;
					case "Health Regen Multi":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateHealthRegenMultiplier(player));
						break;
					case "Food Regen":
						((TMP_Text)statElement.ValueText).text = FormatRegen(CalculateFoodRegen(player), "/s");
						break;
					case "Stamina Regen":
						((TMP_Text)statElement.ValueText).text = FormatRegen(player.m_staminaRegen, "/s");
						break;
					case "Stamina Regen Multi":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateStaminaRegenMultiplier(player));
						break;
					case "Eitr Regen":
						((TMP_Text)statElement.ValueText).text = FormatRegen(player.m_eiterRegen, "/s");
						break;
					case "Eitr Regen Multi":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateEitrRegenMultiplier(player));
						break;
					case "Attack Speed":
						((TMP_Text)statElement.ValueText).text = FormatPercent(CalculateAttackSpeed(player));
						break;
					case "Damage Modifier":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateDamageModifier(player));
						break;
					case "Stagger Resist":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateStaggerResist(player));
						break;
					case "Timed Block Bonus":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateTimedBlockBonus(player));
						break;
					case "Crit Chance":
						((TMP_Text)statElement.ValueText).text = FormatPercent(CalculateCritChance(player));
						break;
					case "Lifesteal":
						((TMP_Text)statElement.ValueText).text = FormatPercent(CalculateLifesteal(player));
						break;
					case "Blunt Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)1));
						break;
					case "Slash Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)2));
						break;
					case "Pierce Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)4));
						break;
					case "Fire Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)32));
						break;
					case "Frost Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)64));
						break;
					case "Lightning Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)128));
						break;
					case "Poison Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)256));
						break;
					case "Spirit Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateElementalDamageBonus(player, (DamageType)512));
						break;
					case "Current Weight":
					{
						TextMeshProUGUI valueText = statElement.ValueText;
						Inventory inventory2 = ((Humanoid)player).GetInventory();
						((TMP_Text)valueText).text = ((inventory2 != null) ? inventory2.GetTotalWeight() : 0f).ToString("F0", CultureInfo.InvariantCulture);
						break;
					}
					case "Max Weight":
						((TMP_Text)statElement.ValueText).text = player.GetMaxCarryWeight().ToString("F0", CultureInfo.InvariantCulture);
						break;
					case "Weight Percentage":
					{
						Inventory inventory = ((Humanoid)player).GetInventory();
						float num3 = ((inventory != null) ? inventory.GetTotalWeight() : 0f);
						float maxCarryWeight = player.GetMaxCarryWeight();
						((TMP_Text)statElement.ValueText).text = FormatPercent((maxCarryWeight > 0f) ? (num3 / maxCarryWeight * 100f) : 0f);
						break;
					}
					case "Extra Carry Weight":
					{
						float num2 = CalculateExtraCarryWeight(player);
						((TMP_Text)statElement.ValueText).text = ((num2 > 0f) ? ("+" + num2.ToString("F0", CultureInfo.InvariantCulture)) : "0");
						break;
					}
					case "Jump Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateJumpStaminaUsage(player));
						break;
					case "Attack Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateAttackStaminaUsage(player));
						break;
					case "Block Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateBlockStaminaUsage(player));
						break;
					case "Dodge Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateDodgeStaminaUsage(player));
						break;
					case "Swim Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateSwimStaminaUsage(player));
						break;
					case "Run Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateRunStaminaUsage(player));
						break;
					case "Sneak Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateSneakStaminaUsage(player));
						break;
					case "Home Item Stamina":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateHomeItemStaminaUsage(player));
						break;
					case "Total Armor":
					case "Armor":
						((TMP_Text)statElement.ValueText).text = ((Character)player).GetBodyArmor().ToString("F0", CultureInfo.InvariantCulture);
						break;
					case "Heat Resistance":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateHeatResistance(player));
						break;
					case "Equipment Movement":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateEquipmentMovement(player));
						break;
					case "Blunt Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)1));
						break;
					case "Slash Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)2));
						break;
					case "Pierce Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)4));
						break;
					case "Fire Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)32));
						break;
					case "Frost Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)64));
						break;
					case "Lightning Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)128));
						break;
					case "Poison Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)256));
						break;
					case "Spirit Resist":
						((TMP_Text)statElement.ValueText).text = FormatResistance(GetResistance(player, (DamageType)512));
						break;
					case "Top Skills":
						((TMP_Text)statElement.ValueText).text = GetTopSkills(player);
						break;
					case "Skill Bonuses":
						((TMP_Text)statElement.ValueText).text = GetAddedSkillPoints(player);
						break;
					case "Skill Raise Speed":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateSkillRaiseSpeed(player));
						break;
					case "Noise Level":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateNoiseLevel(player));
						break;
					case "Stealth Level":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateStealthLevel(player));
						break;
					case "Cover Percentage":
						((TMP_Text)statElement.ValueText).text = FormatPercent(player.m_coverPercentage);
						break;
					case "Fall Damage":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateFallDamage(player));
						break;
					case "Comfort Level":
						((TMP_Text)statElement.ValueText).text = $"{player.GetComfortLevel()}";
						break;
					case "Movement Speed":
						((TMP_Text)statElement.ValueText).text = FormatPercent(((Character)player).GetJogSpeedFactor() * 100f);
						break;
					case "Speed Modifier":
						((TMP_Text)statElement.ValueText).text = FormatPercentModifier(CalculateSpeedModifier(player));
						break;
					case "Run Speed":
						((TMP_Text)statElement.ValueText).text = FormatPercent(((Character)player).GetRunSpeedFactor() * 100f);
						break;
					case "Swim Speed":
						((TMP_Text)statElement.ValueText).text = FormatPercent(((Character)player).m_swimSpeed * ((Character)player).GetAttackSpeedFactorMovement());
						break;
					case "Jump Height":
					{
						float num = CalculateJumpModifier(player);
						((TMP_Text)statElement.ValueText).text = ((num > 0f) ? ("+" + num.ToString("F0", CultureInfo.InvariantCulture) + "%") : ((num < 0f) ? (num.ToString("F0", CultureInfo.InvariantCulture) + "%") : "100%"));
						break;
					}
					case "FoodBuffs":
						((TMP_Text)statElement.ValueText).text = GetActiveFoodBuffs(player);
						break;
					case "ActiveEffects":
						((TMP_Text)statElement.ValueText).text = GetActiveEffects(player);
						break;
					case "SetBonuses":
						((TMP_Text)statElement.ValueText).text = GetActiveSetBonuses(player);
						break;
					}
				}
				else
				{
					float statValue = val.m_playerStats[statElement.StatType];
					((TMP_Text)statElement.ValueText).text = FormatHistoricalStat(statElement.StatType, statValue);
				}
			}
		}

		private static float CalculateHealthRegen(Player player)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
						if (val != null)
						{
							if (val.m_tickInterval > 0f && val.m_healthPerTick != 0f)
							{
								num += val.m_healthPerTick;
							}
							if (val != null && val.m_healthOverTime > 0f && val.m_healthOverTimeInterval > 0f)
							{
								num += val.m_healthOverTimeTickHP;
							}
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateFoodRegen(Player player)
		{
			float num = 0f;
			try
			{
				List<Food> foods = player.m_foods;
				if (foods != null && foods.Count > 0)
				{
					foreach (Food food2 in player.m_foods)
					{
						if (food2 != null && food2.m_item != null)
						{
							float food = food2.m_item.m_shared.m_food;
							float foodBurnTime = food2.m_item.m_shared.m_foodBurnTime;
							if (foodBurnTime > 0f)
							{
								num += food / foodBurnTime;
							}
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateMultiplierModifier(Player player, Func<SE_Stats, float> getMultiplier)
		{
			return PlayerStatsCalculator.CalculateMultiplierModifierPercent(((Character)player).m_seman, getMultiplier);
		}

		private static float CalculateAdrenaline(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_adrenalineModifier);
		}

		private static float CalculateHealthRegenMultiplier(Player player)
		{
			return PlayerStatsCalculator.CalculateHealthRegenMultiplier(player);
		}

		private static float CalculateStaminaRegenMultiplier(Player player)
		{
			return PlayerStatsCalculator.CalculateStaminaRegenMultiplier(player);
		}

		private static float CalculateEitrRegenMultiplier(Player player)
		{
			return PlayerStatsCalculator.CalculateEitrRegenMultiplier(player);
		}

		private static float CalculateAttackSpeed(Player player)
		{
			return PlayerStatsCalculator.CalculateAttackSpeed(player);
		}

		private static float CalculateDamageModifier(Player player)
		{
			return PlayerStatsCalculator.CalculateDamageModifier(player);
		}

		private static float CalculateStaggerResist(Player player)
		{
			return PlayerStatsCalculator.CalculateStaggerResist(player);
		}

		private static float CalculateTimedBlockBonus(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_timedBlockBonus);
		}

		private static float CalculateMaxCarryWeight(Player player)
		{
			float result = 0f;
			try
			{
				result = player.m_maxCarryWeight;
			}
			catch
			{
			}
			return result;
		}

		private static float CalculateExtraCarryWeight(Player player)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
						if (val != null && val.m_addMaxCarryWeight > 0f)
						{
							num += val.m_addMaxCarryWeight;
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateModifiers(Player player, Func<SE_Stats, float> getSeStatsModifier, Func<SharedData, float>? getItemModifier = null)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
						if (val != null)
						{
							float num2 = getSeStatsModifier(val);
							if (num2 != 0f)
							{
								num += num2 * 100f;
							}
						}
					}
				}
				if (getItemModifier != null)
				{
					Inventory inventory = ((Humanoid)player).GetInventory();
					foreach (ItemData item in ((inventory != null) ? inventory.GetEquippedItems() : null) ?? new List<ItemData>())
					{
						if (item != null)
						{
							float num3 = getItemModifier(item.m_shared);
							if (num3 != 0f)
							{
								num += num3 * 100f;
							}
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateJumpStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_jumpStaminaUseModifier, (SharedData shared) => shared.m_jumpStaminaModifier);
		}

		private static float CalculateAttackStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_attackStaminaUseModifier, (SharedData shared) => shared.m_attackStaminaModifier);
		}

		private static float CalculateBlockStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_blockStaminaUseModifier, (SharedData shared) => shared.m_blockStaminaModifier);
		}

		private static float CalculateDodgeStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_dodgeStaminaUseModifier, (SharedData shared) => shared.m_dodgeStaminaModifier);
		}

		private static float CalculateSwimStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_swimStaminaUseModifier, (SharedData shared) => shared.m_swimStaminaModifier);
		}

		private static float CalculateRunStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_runStaminaUseModifier, (SharedData shared) => shared.m_runStaminaModifier);
		}

		private static float CalculateSneakStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_sneakStaminaUseModifier, (SharedData shared) => shared.m_sneakStaminaModifier);
		}

		private static float CalculateHomeItemStaminaUsage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats _) => 0f, (SharedData shared) => shared.m_homeItemsStaminaModifier);
		}

		private static float CalculateNoiseLevel(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_noiseModifier);
		}

		private static float CalculateStealthLevel(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_stealthModifier);
		}

		private static float CalculateFallDamage(Player player)
		{
			return CalculateModifiers(player, (SE_Stats seStats) => seStats.m_fallDamageModifier);
		}

		private static float CalculateCritChance(Player player)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						if (!((Object)(object)statusEffect == (Object)null))
						{
							string text = statusEffect.m_name?.ToLower() ?? "";
							string text2 = statusEffect.m_tooltip?.ToLower() ?? "";
							if (text.Contains("crit") || text2.Contains("crit"))
							{
								num += 5f;
							}
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateLifesteal(Player player)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						if (!((Object)(object)statusEffect == (Object)null))
						{
							string text = statusEffect.m_name?.ToLower() ?? "";
							string text2 = statusEffect.m_tooltip?.ToLower() ?? "";
							if (text.Contains("lifesteal") || text2.Contains("lifesteal"))
							{
								num += 5f;
							}
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateJumpModifier(Player player)
		{
			return PlayerStatsCalculator.CalculateJumpModifier(player);
		}

		private static DamageModifier GetResistance(Player player, DamageType damageType)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected I4, but got Unknown
			//IL_0090: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0040: Invalid comparison between Unknown and I4
			//IL_00ad: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			DamageModifiers val = (DamageModifiers)((((Character)player).GetBodyArmor() > 0f) ? ((Character)player).GetDamageModifiers((WeakSpot)null) : default(DamageModifiers));
			if ((int)damageType <= 64)
			{
				switch (damageType - 1)
				{
				default:
					if ((int)damageType != 32)
					{
						if ((int)damageType != 64)
						{
							break;
						}
						return val.m_frost;
					}
					return val.m_fire;
				case 0:
					return val.m_blunt;
				case 1:
					return val.m_slash;
				case 3:
					return val.m_pierce;
				case 2:
					break;
				}
			}
			else
			{
				if ((int)damageType == 128)
				{
					return val.m_lightning;
				}
				if ((int)damageType == 256)
				{
					return val.m_poison;
				}
				if ((int)damageType == 512)
				{
					return val.m_spirit;
				}
			}
			return (DamageModifier)0;
		}

		private static string FormatResistance(DamageModifier modifier)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected I4, but got Unknown
			return (int)modifier switch
			{
				3 => Localization.instance.Localize("$azu_epi_stat_resist_immune"), 
				5 => Localization.instance.Localize("$azu_epi_stat_resist_very_resistant"), 
				1 => Localization.instance.Localize("$azu_epi_stat_resist_resistant"), 
				7 => Localization.instance.Localize("$azu_epi_stat_resist_slightly_resistant"), 
				0 => Localization.instance.Localize("$azu_epi_stat_resist_normal"), 
				8 => Localization.instance.Localize("$azu_epi_stat_resist_slightly_weak"), 
				2 => Localization.instance.Localize("$azu_epi_stat_resist_weak"), 
				6 => Localization.instance.Localize("$azu_epi_stat_resist_very_weak"), 
				_ => Localization.instance.Localize("$azu_epi_stat_resist_unknown"), 
			};
		}

		private static float CalculateHeatResistance(Player player)
		{
			return CalculateModifiers(player, (SE_Stats _) => 0f, (SharedData shared) => shared.m_heatResistanceModifier);
		}

		private static float CalculateEquipmentMovement(Player player)
		{
			return CalculateModifiers(player, (SE_Stats _) => 0f, (SharedData shared) => shared.m_movementModifier);
		}

		private static string GetTopSkills(Player player)
		{
			try
			{
				if ((Object)(object)player.m_skills == (Object)null)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				StringBuilder stringBuilder = new StringBuilder();
				List<Skill> list = (from s in player.m_skills.GetSkillList()
					where s != null && s.m_level > 0f
					orderby s.m_level descending
					select s).Take(5).ToList();
				if (list.Count == 0)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				foreach (Skill item in list)
				{
					string text = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_info.m_skill)/*cast due to .constrained prefix*/).ToString();
					stringBuilder.Append("• " + text + ": " + item.m_level.ToString("F0", CultureInfo.InvariantCulture));
					if (item != list.Last())
					{
						stringBuilder.AppendLine();
					}
				}
				return stringBuilder.ToString();
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting skills: " + ex.Message));
				return Localization.instance.Localize("$azu_epi_stat_error");
			}
		}

		private static string GetAddedSkillPoints(Player player)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Skills skills = ((Character)player).GetSkills();
				StringBuilder stringBuilder = new StringBuilder();
				List<Skill> skillList = skills.GetSkillList();
				if (skillList.Count == 0)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				foreach (Skill item in skillList)
				{
					float skillLevel = skills.GetSkillLevel(item.m_info.m_skill);
					bool num = Math.Abs((double)skillLevel - (double)Mathf.Floor(item.m_level)) > 0.009999999776482582;
					string text = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_info.m_skill)/*cast due to .constrained prefix*/).ToString();
					if (num)
					{
						stringBuilder.Append("• " + text + ": " + (skillLevel - item.m_level).ToString("+0", CultureInfo.InvariantCulture));
					}
				}
				return (stringBuilder.Length > 0) ? stringBuilder.ToString() : Localization.instance.Localize("$azu_epi_stat_none");
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting skills: " + ex.Message));
				return Localization.instance.Localize("$azu_epi_stat_error");
			}
		}

		private static string GetActiveEffects(Player player)
		{
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) == null)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				List<StatusEffect> statusEffects = ((Character)player).m_seman.GetStatusEffects();
				if (statusEffects.Count == 0)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				StringBuilder stringBuilder = new StringBuilder();
				int num = 0;
				int num2 = 0;
				foreach (StatusEffect item in statusEffects)
				{
					if ((Object)(object)item == (Object)null || string.IsNullOrEmpty(item.m_name) || item.m_name.Contains("Food") || item.m_name.Contains("food"))
					{
						continue;
					}
					if (item.m_name.Contains("set") || item.m_name.Contains("Set"))
					{
						num2++;
						continue;
					}
					string text = "";
					if (item.m_ttl > 0f)
					{
						float time = item.m_time;
						if (time > 60f)
						{
							text = " " + (time / 60f).ToString("F0", CultureInfo.InvariantCulture) + "m";
						}
						else if (time > 0f)
						{
							text = " " + time.ToString("F0", CultureInfo.InvariantCulture) + "s";
						}
					}
					stringBuilder.Append("• " + Localization.instance.Localize(item.m_name) + text);
					num++;
					if (num < statusEffects.Count - num2)
					{
						stringBuilder.AppendLine();
					}
					if (num < 5)
					{
						continue;
					}
					int num3 = statusEffects.Count - num - num2;
					if (num3 > 0)
					{
						stringBuilder.Append($"\n+{num3} more...");
					}
					break;
				}
				return (num > 0) ? stringBuilder.ToString() : Localization.instance.Localize("$azu_epi_stat_none");
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting active effects: " + ex.Message));
				return Localization.instance.Localize("$azu_epi_stat_error");
			}
		}

		private static string GetActiveSetBonuses(Player player)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>();
			try
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				foreach (ItemData item in ((inventory != null) ? inventory.GetEquippedItems() : null) ?? new List<ItemData>())
				{
					if (item != null && !((Object)(object)item.m_shared?.m_setStatusEffect == (Object)null) && !string.IsNullOrEmpty(item.m_shared.m_setStatusEffect.m_name))
					{
						string name = item.m_shared.m_setStatusEffect.m_name;
						if (!dictionary.ContainsKey(name))
						{
							dictionary[name] = 0;
							dictionary2[name] = item.m_shared.m_setSize;
						}
						dictionary[name]++;
					}
				}
				if (dictionary.Count == 0)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				StringBuilder stringBuilder = new StringBuilder();
				int num = 0;
				foreach (KeyValuePair<string, int> item2 in dictionary.OrderByDescending((KeyValuePair<string, int> x) => x.Value))
				{
					string key = item2.Key;
					int value = item2.Value;
					int value2;
					int num2 = ((!dictionary2.TryGetValue(key, out value2)) ? 1 : value2);
					bool num3 = value >= num2;
					string text = (num3 ? "✓" : "x");
					string text2 = (num3 ? "#00FF00" : "#FF6666");
					stringBuilder.Append($"<color={text2}>{text}</color> {Localization.instance.Localize(key)} ({value}/{num2})");
					num++;
					if (num < dictionary.Count)
					{
						stringBuilder.AppendLine();
					}
					if (num >= 5)
					{
						int num4 = dictionary.Count - num;
						if (num4 > 0)
						{
							stringBuilder.Append($"\n+{num4} more...");
						}
						break;
					}
				}
				return stringBuilder.ToString();
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting set bonuses: " + ex.Message));
				return Localization.instance.Localize("$azu_epi_stat_error");
			}
		}

		internal static void HandleScrollInput()
		{
			if (!IsVisible())
			{
				return;
			}
			ScrollRect scrollRect = GetScrollRect();
			if ((Object)(object)scrollRect == (Object)null || (Object)(object)scrollRect.content == (Object)null || !ZInput.IsGamepadActive())
			{
				return;
			}
			float num = 0f;
			if (ZInput.instance != null)
			{
				try
				{
					num = ZInput.GetJoyRightStickY(true);
				}
				catch
				{
				}
			}
			if (Mathf.Approximately(num, 0f))
			{
				try
				{
					num = Input.GetAxis("Joy2 Axis 5");
					if (Mathf.Approximately(num, 0f))
					{
						num = Input.GetAxis("Joy2 Axis 10");
					}
				}
				catch
				{
				}
			}
			if (Mathf.Abs(num) > 0.1f)
			{
				float num2 = (0f - num) * 1f * Time.deltaTime;
				float verticalNormalizedPosition = Mathf.Clamp01(scrollRect.verticalNormalizedPosition + num2);
				scrollRect.verticalNormalizedPosition = verticalNormalizedPosition;
			}
		}

		private static float CalculateElementalDamageBonus(Player player, DamageType damageType)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_004b: 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_0063: Expected I4, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Invalid comparison between Unknown and I4
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Invalid comparison between Unknown and I4
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Invalid comparison between Unknown and I4
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
						if (val == null)
						{
							continue;
						}
						float num2;
						if ((int)damageType <= 64)
						{
							switch (damageType - 1)
							{
							case 0:
								goto IL_008c;
							case 1:
								goto IL_009b;
							case 3:
								goto IL_00aa;
							case 2:
								goto IL_0104;
							}
							if ((int)damageType != 32)
							{
								if ((int)damageType != 64)
								{
									goto IL_0104;
								}
								num2 = val.m_percentigeDamageModifiers.m_frost;
							}
							else
							{
								num2 = val.m_percentigeDamageModifiers.m_fire;
							}
						}
						else if ((int)damageType != 128)
						{
							if ((int)damageType != 256)
							{
								if ((int)damageType != 512)
								{
									goto IL_0104;
								}
								num2 = val.m_percentigeDamageModifiers.m_spirit;
							}
							else
							{
								num2 = val.m_percentigeDamageModifiers.m_poison;
							}
						}
						else
						{
							num2 = val.m_percentigeDamageModifiers.m_lightning;
						}
						goto IL_010b;
						IL_008c:
						num2 = val.m_percentigeDamageModifiers.m_blunt;
						goto IL_010b;
						IL_0104:
						num2 = 0f;
						goto IL_010b;
						IL_010b:
						float num3 = num2;
						if (num3 != 0f)
						{
							num += num3 * 100f;
						}
						continue;
						IL_00aa:
						num2 = val.m_percentigeDamageModifiers.m_pierce;
						goto IL_010b;
						IL_009b:
						num2 = val.m_percentigeDamageModifiers.m_slash;
						goto IL_010b;
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static float CalculateSkillRaiseSpeed(Player player)
		{
			return CalculateMultiplierModifier(player, (SE_Stats seStats) => seStats.m_raiseSkillModifier);
		}

		private static float CalculateSpeedModifier(Player player)
		{
			return CalculateMultiplierModifier(player, (SE_Stats seStats) => seStats.m_speedModifier);
		}

		private static string GetActiveFoodBuffs(Player player)
		{
			try
			{
				if (player.m_foods == null || player.m_foods.Count == 0)
				{
					return Localization.instance.Localize("$azu_epi_stat_none");
				}
				StringBuilder stringBuilder = new StringBuilder();
				int num = 0;
				foreach (Food food2 in player.m_foods)
				{
					if (food2?.m_item != null)
					{
						string name = food2.m_item.m_shared.m_name;
						float time = food2.m_time;
						string text = "";
						if (time > 0f)
						{
							text = ((!(time >= 60f)) ? (" (" + time.ToString("F0", CultureInfo.InvariantCulture) + "s)") : (" (" + (time / 60f).ToString("F0", CultureInfo.InvariantCulture) + "m)"));
						}
						float food = food2.m_item.m_shared.m_food;
						float foodStamina = food2.m_item.m_shared.m_foodStamina;
						float foodEitr = food2.m_item.m_shared.m_foodEitr;
						string text2 = "";
						if (food > 0f)
						{
							text2 = text2 + " +" + food.ToString("F0", CultureInfo.InvariantCulture) + "HP";
						}
						if (foodStamina > 0f)
						{
							text2 = text2 + " +" + foodStamina.ToString("F0", CultureInfo.InvariantCulture) + "Stam";
						}
						if (foodEitr > 0f)
						{
							text2 = text2 + " +" + foodEitr.ToString("F0", CultureInfo.InvariantCulture) + "Eitr";
						}
						stringBuilder.Append("• " + Localization.instance.Localize(name) + text2 + text);
						num++;
						if (num < player.m_foods.Count)
						{
							stringBuilder.AppendLine();
						}
					}
				}
				return (num > 0) ? stringBuilder.ToString() : Localization.instance.Localize("$azu_epi_stat_none");
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Error getting food buffs: " + ex.Message));
				return Localization.instance.Localize("$azu_epi_stat_error");
			}
		}

		private static string FormatHistoricalStat(PlayerStatType statType, float statValue)
		{
			//IL_0000: 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_0005: Invalid comparison between Unknown and I4
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			if (statType - 16 > 4)
			{
				if (statType - 21 <= 2)
				{
					return FormatTime(statValue);
				}
				return FormatLargeNumber(statValue);
			}
			return (statValue >= 1000f) ? ((statValue / 1000f).ToString("F1", CultureInfo.InvariantCulture) + "km") : (statValue.ToString("F0", CultureInfo.InvariantCulture) + "m");
		}

		private static string FormatTime(float seconds)
		{
			if (seconds >= 86400f)
			{
				return (seconds / 86400f).ToString("F1", CultureInfo.InvariantCulture) + "d";
			}
			if (seconds >= 3600f)
			{
				return (seconds / 3600f).ToString("F1", CultureInfo.InvariantCulture) + "h";
			}
			if (seconds >= 60f)
			{
				return (seconds / 60f).ToString("F0", CultureInfo.InvariantCulture) + "m";
			}
			return seconds.ToString("F0", CultureInfo.InvariantCulture) + "s";
		}

		private static string FormatLargeNumber(float value)
		{
			if (value >= 1000000f)
			{
				return (value / 1000000f).ToString("F1", CultureInfo.InvariantCulture) + "M";
			}
			if (value >= 10000f)
			{
				return (value / 1000f).ToString("F1", CultureInfo.InvariantCulture) + "k";
			}
			return value.ToString("N0", CultureInfo.InvariantCulture);
		}

		private static string FormatCurrentMax(float current, float max)
		{
			return current.ToString("F0", CultureInfo.InvariantCulture) + " / " + max.ToString("F0", CultureInfo.InvariantCulture);
		}

		private static string FormatPercentModifier(float value)
		{
			if (value == 0f)
			{
				return "0%";
			}
			return value.ToString("+0;-0", CultureInfo.InvariantCulture) + "%";
		}

		private static string FormatRegen(float value, string suffix)
		{
			return value.ToString("F1", CultureInfo.InvariantCulture) + suffix;
		}

		private static string FormatPercent(float value)
		{
			return value.ToString("F0", CultureInfo.InvariantCulture) + "%";
		}

		private static void CreatePlayerDropdown()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Expected O, but got Unknown
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Expected O, but got Unknown
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Expected O, but got Unknown
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Expected O, but got Unknown
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Expected O, but got Unknown
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Expected O, but got Unknown
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Expected O, but got Unknown
			//IL_0714: Unknown result type (might be due to invalid IL or missing references)
			//IL_072a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0740: Unknown result type (might be due to invalid IL or missing references)
			//IL_074c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Expected O, but got Unknown
			//IL_07f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_080b: Unknown result type (might be due to invalid IL or missing references)
			//IL_081f: Unknown result type (might be due to invalid IL or missing references)
			//IL_084d: Unknown result type (might be due to invalid IL or missing references)
			//IL_087c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0881: Unknown result type (might be due to invalid IL or missing references)
			//IL_0894: Unknown result type (might be due to invalid IL or missing references)
			//IL_089b: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_091a: Unknown result type (might be due to invalid IL or missing references)
			//IL_091f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0932: Unknown result type (might be due to invalid IL or missing references)
			//IL_0943: Unknown result type (might be due to invalid IL or missing references)
			//IL_0958: Unknown result type (might be due to invalid IL or missing references)
			//IL_096d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0982: Unknown result type (might be due to invalid IL or missing references)
			//IL_0996: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a00: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a07: Expected O, but got Unknown
			//IL_0a07: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a19: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a42: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a84: Expected O, but got Unknown
			//IL_0ab2: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_content) || (Object)(object)_playerDropdown != (Object)null)
			{
				return;
			}
			GameObject val = new GameObject("PlayerDropdownContainer", new Type[2]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup)
			});
			val.transform.SetParent((Transform)(object)_content, false);
			val.transform.SetAsFirstSibling();
			_dropdownContainer = (RectTransform)val.transform;
			_dropdownContainer.sizeDelta = new Vector2(0f, 36f);
			HorizontalLayoutGroup component = val.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			((LayoutGroup)component).padding = new RectOffset(0, 0, 4, 4);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.minHeight = 36f;
			obj.preferredHeight = 36f;
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			GameObjectHelper.SafeSetActive(val2, active: false);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_fontAsset != (Object)null)
			{
				((TMP_Text)val3).font = _fontAsset;
				((TMP_Text)val3).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
			}
			GameObjectHelper.SafeSetActive(val2, active: true);
			((TMP_Text)val3).text = Localization.instance.Localize("$azu_epi_stat_player_label");
			((TMP_Text)val3).fontSize = 16f;
			((TMP_Text)val3).fontStyle = (FontStyles)1;
			((Graphic)val3).color = Color.white;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)4097;
			if ((Object)(object)_fontAsset != (Object)null)
			{
				((TMP_Text)val3).font = _fontAsset;
			}
			LayoutElement obj2 = val2.AddComponent<LayoutElement>();
			obj2.minWidth = 60f;
			obj2.preferredWidth = 60f;
			obj2.flexibleWidth = 0f;
			TMP_Dropdown val4 = null;
			GameObject val5;
			if ((Object)(object)val4 != (Object)null)
			{
				val5 = Object.Instantiate<GameObject>(((Component)val4).gameObject, val.transform);
				((Object)val5).name = "PlayerDropdown";
				val5.SetActive(true);
				_playerDropdown = val5.GetComponent<TMP_Dropdown>();
				Transform val6 = val5.transform.Find("Template");
				if ((Object)(object)val6 != (Object)null)
				{
					_playerDropdown.template = ((Component)val6).GetComponent<RectTransform>();
					((Component)val6).gameObject.SetActive(false);
					Transform val7 = val6.Find("Viewport/Content/Item/Item Label");
					if ((Object)(object)val7 != (Object)null)
					{
						_playerDropdown.itemText = (TMP_Text)(object)((Component)val7).GetComponent<TextMeshProUGUI>();
					}
				}
				Transform val8 = val5.transform.Find("Label");
				if ((Object)(object)val8 != (Object)null)
				{
					_playerDropdown.captionText = (TMP_Text)(object)((Component)val8).GetComponent<TextMeshProUGUI>();
				}
			}
			else
			{
				val5 = new GameObject("PlayerDropdown", new Type[3]
				{
					typeof(RectTransform),
					typeof(TMP_Dropdown),
					typeof(Image)
				});
				val5.transform.SetParent(val.transform, false);
				_playerDropdown = val5.GetComponent<TMP_Dropdown>();
				((Graphic)val5.GetComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f, 0.8f);
				GameObject val9 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
				val9.transform.SetParent(val5.transform, false);
				GameObjectHelper.SafeSetActive(val9, active: false);
				RectTransform component2 = val9.GetComponent<RectTransform>();
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.offsetMin = new Vector2(10f, 2f);
				component2.offsetMax = new Vector2(-25f, -2f);
				TextMeshProUGUI val10 = val9.AddComponent<TextMeshProUGUI>();
				if ((Object)(object)_fontAsset != (Object)null)
				{
					((TMP_Text)val10).font = _fontAsset;
					((TMP_Text)val10).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val9, active: true);
				((TMP_Text)val10).alignment = (TextAlignmentOptions)4097;
				((TMP_Text)val10).fontSize = 16f;
				((Graphic)val10).color = new Color(1f, 0.84f, 0f, 1f);
				((TMP_Text)val10).fontStyle = (FontStyles)1;
				((Graphic)val10).raycastTarget = false;
				_playerDropdown.captionText = (TMP_Text)(object)val10;
				GameObject val11 = new GameObject("Arrow", new Type[1] { typeof(RectTransform) });
				val11.transform.SetParent(val5.transform, false);
				GameObjectHelper.SafeSetActive(val11, active: false);
				RectTransform component3 = val11.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(1f, 0.5f);
				component3.anchorMax = new Vector2(1f, 0.5f);
				component3.pivot = new Vector2(1f, 0.5f);
				component3.anchoredPosition = new Vector2(-6f, 0f);
				component3.sizeDelta = new Vector2(20f, 20f);
				TextMeshProUGUI val12 = val11.AddComponent<TextMeshProUGUI>();
				if ((Object)(object)_fontAsset != (Object)null)
				{
					((TMP_Text)val12).font = _fontAsset;
					((TMP_Text)val12).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val11, active: true);
				((TMP_Text)val12).text = "▼";
				((TMP_Text)val12).fontSize = 12f;
				((TMP_Text)val12).alignment = (TextAlignmentOptions)514;
				((Graphic)val12).color = new Color(1f, 0.84f, 0f, 1f);
				((Graphic)val12).raycastTarget = false;
				GameObject val13 = new GameObject("Template", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(ScrollRect)
				});
				val13.transform.SetParent(val5.transform, false);
				RectTransform component4 = val13.GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(0f, 0f);
				component4.anchorMax = new Vector2(1f, 0f);
				component4.pivot = new Vector2(0.5f, 1f);
				component4.anchoredPosition = Vector2.zero;
				component4.sizeDelta = new Vector2(0f, 150f);
				((Graphic)val13.GetComponent<Image>()).color = new Color(0.05f, 0.05f, 0.05f, 0.95f);
				GameObject val14 = new GameObject("Viewport", new Type[3]
				{
					typeof(RectTransform),
					typeof(Mask),
					typeof(Image)
				});
				val14.transform.SetParent(val13.transform, false);
				RectTransform component5 = val14.GetComponent<RectTransform>();
				component5.anchorMin = Vector2.zero;
				component5.anchorMax = Vector2.one;
				component5.offsetMin = Vector2.zero;
				component5.offsetMax = Vector2.zero;
				((Graphic)val14.GetComponent<Image>()).color = Color.white;
				val14.GetComponent<Mask>().showMaskGraphic = false;
				GameObject val15 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
				val15.transform.SetParent(val14.transform, false);
				RectTransform component6 = val15.GetComponent<RectTransform>();
				component6.anchorMin = new Vector2(0f, 1f);
				component6.anchorMax = new Vector2(1f, 1f);
				component6.pivot = new Vector2(0.5f, 1f);
				component6.anchoredPosition = Vector2.zero;
				component6.sizeDelta = new Vector2(0f, 28f);
				ScrollRect component7 = val13.GetComponent<ScrollRect>();
				component7.content = component6;
				component7.viewport = component5;
				component7.horizontal = false;
				component7.vertical = true;
				component7.movementType = (MovementType)2;
				GameObject val16 = new GameObject("Item", new Type[3]
				{
					typeof(RectTransform),
					typeof(Toggle),
					typeof(Image)
				});
				val16.transform.SetParent(val15.transform, false);
				RectTransform component8 = val16.GetComponent<RectTransform>();
				component8.anchorMin = new Vector2(0f, 0.5f);
				component8.anchorMax = new Vector2(1f, 0.5f);
				component8.sizeDelta = new Vector2(0f, 30f);
				Toggle component9 = val16.GetComponent<Toggle>();
				((Graphic)val16.GetComponent<Image>()).color = new Color(0.08f, 0.08f, 0.08f, 0.9f);
				GameObject val17 = new GameObject("Item Background", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val17.transform.SetParent(val16.transform, false);
				RectTransform component10 = val17.GetComponent<RectTransform>();
				component10.anchorMin = Vector2.zero;
				component10.anchorMax = Vector2.one;
				component10.offsetMin = Vector2.zero;
				component10.offsetMax = Vector2.zero;
				Image component11 = val17.GetComponent<Image>();
				((Graphic)component11).color = new Color(0.2f, 0.2f, 0.2f, 0.8f);
				((Selectable)component9).targetGraphic = (Graphic)(object)component11;
				GameObject val18 = new GameObject("Item Checkmark", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val18.transform.SetParent(val16.transform, false);
				RectTransform component12 = val18.GetComponent<RectTransform>();
				component12.anchorMin = new Vector2(0f, 0.5f);
				component12.anchorMax = new Vector2(0f, 0.5f);
				component12.pivot = new Vector2(0f, 0.5f);
				component12.anchoredPosition = new Vector2(8f, 0f);
				component12.sizeDelta = new Vector2(14f, 14f);
				Image component13 = val18.GetComponent<Image>();
				((Graphic)component13).color = new Color(1f, 0.84f, 0f, 1f);
				component9.graphic = (Graphic)(object)component13;
				GameObject val19 = new GameObject("Item Label", new Type[1] { typeof(RectTransform) });
				val19.transform.SetParent(val16.transform, false);
				GameObjectHelper.SafeSetActive(val19, active: false);
				RectTransform component14 = val19.GetComponent<RectTransform>();
				component14.anchorMin = Vector2.zero;
				component14.anchorMax = Vector2.one;
				component14.offsetMin = new Vector2(28f, 2f);
				component14.offsetMax = new Vector2(-10f, -2f);
				TextMeshProUGUI val20 = val19.AddComponent<TextMeshProUGUI>();
				if ((Object)(object)_fontAsset != (Object)null)
				{
					((TMP_Text)val20).font = _fontAsset;
					((TMP_Text)val20).fontSharedMaterial = ((TMP_Asset)_fontAsset).material;
				}
				GameObjectHelper.SafeSetActive(val19, active: true);
				((TMP_Text)val20).alignment = (TextAlignmentOptions)4097;
				((TMP_Text)val20).fontSize = 15f;
				((Graphic)val20).color = new Color(1f, 0.84f, 0f, 1f);
				((Graphic)val20).raycastTarget = false;
				_playerDropdown.itemText = (TMP_Text)(object)val20;
				_playerDropdown.template = component4;
				val13.SetActive(false);
			}
			LayoutElement orAddComponent = val5.GetOrAddComponent<LayoutElement>();
			orAddComponent.flexibleWidth = 1f;
			orAddComponent.minHeight = 28f;
			orAddComponent.preferredHeight = 28f;
			((Selectable)_playerDropdown).interactable = true;
			Navigation navigation = ((Selectable)_playerDropdown).navigation;
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)_playerDropdown).navigation = navigation;
			_playerDropdown.ClearOptions();
			((UnityEventBase)_playerDropdown.onValueChanged).RemoveAllListeners();
			((UnityEvent<int>)(object)_playerDropdown.onValueChanged).AddListener((UnityAction<int>)OnPlayerDropdownValueChanged);
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Player dropdown created, template={(Object)(object)_playerDropdown.template != (Object)null}, captionText={(Object)(object)_playerDropdown.captionText != (Object)null}");
			RefreshPlayerDropdownOptions();
			CreateSpacer("Spacer_PlayerDropdown");
		}

		private static void RefreshPlayerDropdownOptions()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			if ((Object)(object)_playerDropdown == (Object)null)
			{
				return;
			}
			_playerList.Clear();
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				_playerList.AddRange(ZNet.instance.GetPlayerList());
			}
			List<OptionData> list = new List<OptionData>
			{
				new OptionData(Localization.instance.Localize("$azu_epi_stat_self"))
			};
			long num = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.GetUID() : 0);
			foreach (PlayerInfo player in _playerList)
			{
				ZDOID characterID = player.m_characterID;
				if (((ZDOID)(ref characterID)).UserID != num)
				{
					string text = CensorShittyWords.FilterUGC(player.m_name, (UGCType)2, player.m_userInfo.m_id, 0L);
					list.Add(new OptionData(text));
				}
			}
			foreach (var item2 in _fakePlayersForTesting)
			{
				string item = item2.name;
				list.Add(new OptionData(item + " (Test)"));
			}
			int value = _playerDropdown.value;
			_playerDropdown.ClearOptions();
			_playerDropdown.AddOptions(list);
			bool flag = _fakePlayersForTesting.Count > 0;
			bool active = (byte)(1u | (flag ? 1u : 0u)) != 0;
			if ((Object)(object)_dropdownContainer != (Object)null)
			{
				((Component)_dropdownContainer).gameObject.SetActive(active);
			}
			if (value < list.Count)
			{
				_playerDropdown.SetValueWithoutNotify(value);
				return;
			}
			_playerDropdown.SetValueWithoutNotify(0);
			_isViewingRemotePlayer = false;
			_currentRemoteStats = null;
		}

		public static void OnPlayerListChanged()
		{
			if (!((Object)(object)_playerDropdown == (Object)null))
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Player list changed, refreshing dropdown");
				RefreshPlayerDropdownOptions();
			}
		}

		private static void OnPlayerDropdownValueChanged(int index)
		{
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"OnPlayerDropdownValueChanged fired with index: {index}");
			OnPlayerDropdownChanged(index);
		}

		private static void OnPlayerDropdownChanged(int index)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"OnPlayerDropdownChanged processing index: {index}");
			if (index == 0)
			{
				ResetToLocalPlayer();
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					UpdateStats(Player.m_localPlayer);
				}
				return;
			}
			long fakePlayerIdAtDropdownIndex = GetFakePlayerIdAtDropdownIndex(index);
			if (fakePlayerIdAtDropdownIndex != 0L)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Fake player selected at index {index}, ID: {fakePlayerIdAtDropdownIndex}");
				SimulateFakePlayerStats(fakePlayerIdAtDropdownIndex);
				return;
			}
			long uID = ZNet.GetUID();
			int num = 0;
			long num2 = 0L;
			foreach (PlayerInfo player in _playerList)
			{
				ZDOID characterID = player.m_characterID;
				if (((ZDOID)(ref characterID)).UserID != uID)
				{
					num++;
					if (num == index)
					{
						characterID = player.m_characterID;
						num2 = ((ZDOID)(ref characterID)).UserID;
						break;
					}
				}
			}
			if (num2 != 0L)
			{
				_isViewingRemotePlayer = true;
				_viewingPlayerId = num2;
				if (_remoteStatsCache.TryGetValue(num2, out RemotePlayerStats value) && DateTimeOffset.UtcNow.ToUnixTimeSeconds() - value.Timestamp < 30)
				{
					_currentRemoteStats = value;
					UpdateStatsFromRemoteData(value);
				}
				else
				{
					_isLoadingRemoteStats = true;
					ShowLoadingState();
					RemoteStatsRPC.RequestStats(num2);
				}
			}
		}

		public static void OnRemoteStatsReceived(RemotePlayerStats? stats)
		{
			_isLoadingRemoteStats = false;
			if (stats == null)
			{
				ShowErrorState(Localization.instance.Localize("$azu_epi_stat_unavailable"));
				return;
			}
			_remoteStatsCache[stats.PlayerId] = stats;
			if (_isViewingRemotePlayer && _viewingPlayerId == stats.PlayerId)
			{
				_currentRemoteStats = stats;
				UpdateStatsFromRemoteData(stats);
			}
		}

		public static void ForceDisplayRemoteStats(RemotePlayerStats stats)
		{
			_isViewingRemotePlayer = true;
			_viewingPlayerId = stats.PlayerId;
			_currentRemoteStats = stats;
			_remoteStatsCache[stats.PlayerId] = stats;
			if ((Object)(object)_dropdownContainer != (Object)null)
			{
				((Component)_dropdownContainer).gameObject.SetActive(true);
			}
			UpdateStatsFromRemoteData(stats);
		}

		public static void EnableTestMode(long targetPlayerId = 0L)
		{
			if ((Object)(object)_dropdownContainer != (Object)null)
			{
				((Component)_dropdownContainer).gameObject.SetActive(true);
			}
			_isViewingRemotePlayer = true;
			_viewingPlayerId = ((targetPlayerId > 0) ? targetPlayerId : ZNet.GetUID());
			_isLoadingRemoteStats = true;
			if (_visible)
			{
				ShowLoadingState();
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Test mode enabled - waiting for RPC response from player {_viewingPlayerId}");
		}

		public static void AddFakePlayerToDropdown(string playerName)
		{
			long num = -1000 - _fakePlayersForTesting.Count;
			_fakePlayersForTesting.Add((num, playerName));
			RefreshPlayerDropdownOptions();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"Added fake player '{playerName}' (ID: {num}) to dropdown");
		}

		public static void ClearFakePlayers()
		{
			_fakePlayersForTesting.Clear();
			RefreshPlayerDropdownOptions();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)"Cleared all fake players from dropdown");
		}

		private static long GetFakePlayerIdAtDropdownIndex(int index)
		{
			if (_fakePlayersForTesting.Count == 0)
			{
				return 0L;
			}
			long myUid = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.GetUID() : 0);
			int num = _playerList.Count((PlayerInfo p) => ((ZDOID)(ref p.m_characterID)).UserID != myUid);
			int num2 = 1 + num;
			if (index >= num2 && index < num2 + _fakePlayersForTesting.Count)
			{
				return _fakePlayersForTesting[index - num2].id;
			}
			return 0L;
		}

		private static void SimulateFakePlayerStats(long fakePlayerId)
		{
			string item = _fakePlayersForTesting.FirstOrDefault<(long, string)>(((long id, string name) f) => f.id == fakePlayerId).Item2;
			if (item != null)
			{
				_isViewingRemotePlayer = true;
				_viewingPlayerId = fakePlayerId;
				_isLoadingRemoteStats = true;
				if (_visible)
				{
					ShowLoadingState();
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Simulating RPC for fake player '" + item + "'..."));
				OnRemoteStatsReceived(FakePlayerStats.Generate(fakePlayerId, item));
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Fake stats delivered for '" + item + "'"));
			}
		}

		private static void ShowLoadingState()
		{
			foreach (StatElement statElement in _statElements)
			{
				((TMP_Text)statElement.ValueText).text = "...";
			}
		}

		private static void ShowErrorState(string message)
		{
			foreach (StatElement statElement in _statElements)
			{
				((TMP_Text)statElement.ValueText).text = "-";
			}
		}

		private static void UpdateStatsFromRemoteData(RemotePlayerStats stats)
		{
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			if (_statElements.Count == 0)
			{
				return;
			}
			foreach (StatElement statElement in _statElements)
			{
				if (statElement.IsLiveStat)
				{
					TextMeshProUGUI valueText = statElement.ValueText;
					string text;
					switch (statElement.Name)
					{
					case "Health":
						text = FormatCurrentMax(stats.CurrentHealth, stats.MaxHealth);
						break;
					case "Stamina":
						text = FormatCurrentMax(stats.CurrentStamina, stats.MaxStamina);
						break;
					case "Eitr":
						text = FormatCurrentMax(stats.CurrentEitr, stats.MaxEitr);
						break;
					case "Total Armor":
					case "Armor":
						text = stats.BodyArmor.ToString("F0", CultureInfo.InvariantCulture);
						break;
					case "Current Weight":
						text = stats.CurrentCarryWeight.ToString("F0", CultureInfo.InvariantCulture);
						break;
					case "Max Weight":
						text = stats.MaxCarryWeight.ToString("F0", CultureInfo.InvariantCulture);
						break;
					case "Weight Percentage":
						text = FormatPercent((stats.MaxCarryWeight > 0f) ? (stats.CurrentCarryWeight / stats.MaxCarryWeight * 100f) : 0f);
						break;
					case "Health Regen":
						text = FormatRegen(stats.HealthRegen, "/tick");
						break;
					case "Stamina Regen":
						text = FormatRegen(stats.StaminaRegen, "/s");
						break;
					case "Eitr Regen":
						text = FormatRegen(stats.EitrRegen, "/s");
						break;
					case "Attack Speed":
						text = FormatPercent(stats.AttackSpeedModifier * 100f);
						break;
					case "Damage Modifier":
						text = FormatPercentModifier((stats.DamageModifier - 1f) * 100f);
						break;
					case "Movement Speed":
					case "Speed Modifier":
						text = FormatPercentModifier((stats.MovementSpeedModifier - 1f) * 100f);
						break;
					case "Jump Height":
						text = FormatPercentModifier(stats.JumpModifier * 100f);
						break;
					case "Comfort Level":
						text = $"{stats.ComfortLevel}";
						break;
					case "FoodBuffs":
						text = FormatRemoteFoods(stats.ActiveFoods);
						break;
					case "ActiveEffects":
						text = FormatRemoteEffects(stats.ActiveEffectNames);
						break;
					default:
						text = "N/A";
						break;
					}
					((TMP_Text)valueText).text = text;
				}
				else
				{
					((TMP_Text)statElement.ValueText).text = (stats.PlayerStats.TryGetValue(statElement.StatType, out var value) ? FormatHistoricalStat(statElement.StatType, value) : "0");
				}
			}
		}

		private static string FormatRemoteFoods(List<FoodSnapshot> foods)
		{
			if (foods.Count == 0)
			{
				return Localization.instance.Localize("$azu_epi_stat_none");
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < foods.Count && i < 5; i++)
			{
				FoodSnapshot foodSnapshot = foods[i];
				float num = foodSnapshot.RemainingTime / 60f;
				stringBuilder.Append("• " + foodSnapshot.Name + " (" + num.ToString("F0", CultureInfo.InvariantCulture) + "m)");
				if (i < foods.Count - 1 && i < 4)
				{
					stringBuilder.AppendLine();
				}
			}
			if (foods.Count > 5)
			{
				stringBuilder.Append($"\n+{foods.Count - 5} more...");
			}
			return stringBuilder.ToString();
		}

		private static string FormatRemoteEffects(List<string> effects)
		{
			if (effects.Count == 0)
			{
				return Localization.instance.Localize("$azu_epi_stat_none");
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < effects.Count && i < 5; i++)
			{
				stringBuilder.Append("• " + effects[i]);
				if (i < effects.Count - 1 && i < 4)
				{
					stringBuilder.AppendLine();
				}
			}
			if (effects.Count > 5)
			{
				stringBuilder.Append($"\n+{effects.Count - 5} more...");
			}
			return stringBuilder.ToString();
		}
	}
	public enum LiveStatType
	{
		Health,
		Stamina,
		Eitr,
		Adrenaline,
		HealthRegen,
		HealthRegenMulti,
		FoodRegen,
		StaminaRegen,
		StaminaRegenMulti,
		EitrRegen,
		EitrRegenMulti,
		AttackSpeed,
		DamageModifier,
		StaggerResist,
		TimedBlockBonus,
		CritChance,
		Lifesteal,
		BluntDamage,
		SlashDamage,
		PierceDamage,
		FireDamage,
		FrostDamage,
		LightningDamage,
		PoisonDamage,
		SpiritDamage,
		CurrentWeight,
		MaxWeight,
		WeightPercentage,
		ExtraCarryWeight,
		JumpStamina,
		AttackStamina,
		BlockStamina,
		DodgeStamina,
		SwimStamina,
		RunStamina,
		SneakStamina,
		HomeItemStamina,
		TotalArmor,
		HeatResistance,
		EquipmentMovement,
		TopSkills,
		SkillBonuses,
		SkillRaiseSpeed,
		NoiseLevel,
		StealthLevel,
		CoverPercentage,
		FallDamage,
		ComfortLevel,
		MovementSpeed,
		SpeedModifier,
		RunSpeed,
		SwimSpeed,
		JumpHeight,
		Armor,
		BluntResist,
		SlashResist,
		PierceResist,
		FireResist,
		FrostResist,
		LightningResist,
		PoisonResist,
		SpiritResist,
		FoodBuffs,
		ActiveEffects,
		SetBonuses
	}
	internal static class PlayerStatsCalculator
	{
		public static float CalculateMultiplierModifierPercent(SEMan? seMan, Func<SE_Stats, float> getMultiplier)
		{
			float num = 0f;
			if (((seMan != null) ? seMan.GetStatusEffects() : null) == null)
			{
				return num;
			}
			foreach (StatusEffect statusEffect in seMan.GetStatusEffects())
			{
				SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
				if (val != null)
				{
					float num2 = getMultiplier(val);
					if (num2 != 1f)
					{
						num += (num2 - 1f) * 100f;
					}
				}
			}
			return num;
		}

		public static float CalculateMultiplierModifierRaw(SEMan? seMan, Func<SE_Stats, float> getMultiplier)
		{
			float num = 1f;
			if (((seMan != null) ? seMan.GetStatusEffects() : null) == null)
			{
				return num;
			}
			foreach (StatusEffect statusEffect in seMan.GetStatusEffects())
			{
				SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
				if (val != null)
				{
					float num2 = getMultiplier(val);
					if (num2 != 1f)
					{
						num *= num2;
					}
				}
			}
			return num;
		}

		public static float CalculateAttackSpeed(Player player)
		{
			float result = 100f;
			try
			{
				result = ((Character)player).GetAttackSpeedFactorMovement() * 100f;
			}
			catch
			{
			}
			return result;
		}

		public static float CalculateDamageModifier(Player player)
		{
			return CalculateMultiplierModifierPercent(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_damageModifier);
		}

		public static float CalculateSpeedModifier(Player player)
		{
			return CalculateMultiplierModifierPercent(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_speedModifier);
		}

		public static float CalculateJumpModifier(Player player)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
						if (val != null)
						{
							num += val.m_jumpStaminaUseModifier * 100f;
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		public static float CalculateHealthRegenMultiplier(Player player)
		{
			return CalculateMultiplierModifierPercent(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_healthRegenMultiplier);
		}

		public static float CalculateStaminaRegenMultiplier(Player player)
		{
			return CalculateMultiplierModifierPercent(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_staminaRegenMultiplier);
		}

		public static float CalculateEitrRegenMultiplier(Player player)
		{
			return CalculateMultiplierModifierPercent(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_eitrRegenMultiplier);
		}

		public static float CalculateStaggerResist(Player player)
		{
			float num = 0f;
			try
			{
				SEMan seman = ((Character)player).m_seman;
				if (((seman != null) ? seman.GetStatusEffects() : null) != null)
				{
					foreach (StatusEffect statusEffect in ((Character)player).m_seman.GetStatusEffects())
					{
						SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
						if (val != null && val.m_staggerModifier != 0f)
						{
							num -= val.m_staggerModifier * 100f;
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		public static float CalculateFoodHealthRegen(Player player)
		{
			float num = 0f;
			foreach (Food food in player.GetFoods())
			{
				if (food.m_item?.m_shared != null)
				{
					num += food.m_item.m_shared.m_foodRegen;
				}
			}
			return num;
		}

		public static float CalculateTotalHealthRegen(Player player)
		{
			float num = CalculateFoodHealthRegen(player);
			float num2 = CalculateMultiplierModifierRaw(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_healthRegenMultiplier);
			return num * num2;
		}

		public static float CalculateTotalStaminaRegen(Player player)
		{
			float staminaRegen = player.m_staminaRegen;
			float num = CalculateMultiplierModifierRaw(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_staminaRegenMultiplier);
			return staminaRegen * num;
		}

		public static float CalculateTotalEitrRegen(Player player)
		{
			float eiterRegen = player.m_eiterRegen;
			float num = CalculateMultiplierModifierRaw(((Character)player).m_seman, (SE_Stats seStats) => seStats.m_eitrRegenMultiplier);
			return eiterRegen * num;
		}

		public static string GetGuardianPowerName(Player player)
		{
			if (string.IsNullOrEmpty(player.m_guardianPower))
			{
				return "";
			}
			ObjectDB instance = ObjectDB.instance;
			StatusEffect val = ((instance != null) ? instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode(player.m_guardianPower)) : null);
			if ((Object)(object)val == (Object)null)
			{
				return player.m_guardianPower;
			}
			if (!val.m_name.StartsWith("$"))
			{
				return val.m_name;
			}
			return Localization.instance.Localize(val.m_name);
		}

		public unsafe static string GetBiomeName(Player player)
		{
			//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)
			Biome currentBiome = player.GetCurrentBiome();
			return Localization.instance.Localize("$biome_" + ((object)(*(Biome*)(&currentBiome))/*cast due to .constrained prefix*/).ToString().ToLower());
		}

		public static string GetEquipmentSlotName(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected I4, but got Unknown
			ItemType itemType = item.m_shared.m_itemType;
			return (itemType - 3) switch
			{
				3 => "Helmet", 
				4 => "Chest", 
				8 => "Legs", 
				14 => "Cape", 
				15 => "Utility", 
				0 => "Weapon", 
				11 => "Weapon", 
				19 => "Weapon", 
				1 => "Weapon", 
				2 => "Shield", 
				16 => "Tool", 
				12 => "Torch", 
				_ => "Other", 
			};
		}
	}
	public static class FakePlayerStats
	{
		private static readonly string[] FakeNames = new string[5] { "Viking Bob", "Odin's Fury", "Meadmaster", "Troll Slayer", "Greydwarf Hunter" };

		private static readonly string[] FakeEffects = new string[7] { "Rested", "Cold", "Wet", "Resting", "Burning", "Poisoned", "Frost resistance" };

		private static readonly string[] FakeFoods = new string[6] { "Cooked meat", "Honey", "Carrot soup", "Sausages", "Lox meat pie", "Serpent stew" };

		private static readonly string[] FakeBiomes = new string[7] { "Meadows", "Black Forest", "Swamp", "Mountain", "Plains", "Mistlands", "Ashlands" };

		private static readonly string[] FakeGuardianPowers = new string[6] { "Eikthyr", "The Elder", "Bonemass", "Moder", "Yagluth", "The Queen" };

		private static readonly string[] FakeEquipment = new string[6] { "Bronze Helmet", "Iron Armor", "Wolf Cape", "Padded Greaves", "Blackmetal Sword", "Silver Shield" };

		private static readonly Random _random = new Random();

		public static RemotePlayerStats Generate(long? playerId = null, string? playerName = null)
		{
			float num = 100 + _random.Next(0, 150);
			float num2 = 100 + _random.Next(0, 100);
			float num3 = ((_random.Next(0, 100) > 50) ? _random.Next(50, 150) : 0);
			float num4 = 300 + _random.Next(0, 150);
			RemotePlayerStats remotePlayerStats = new RemotePlayerStats
			{
				PlayerId = (playerId ?? _random.Next(1000, 9999999)),
				PlayerName = (playerName ?? FakeNames[_random.Next(FakeNames.Length)]),
				Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
				CurrentHealth = num * (0.3f + (float)_random.NextDouble() * 0.7f),
				CurrentStamina = num2 * (0.2f + (float)_random.NextDouble() * 0.8f),
				CurrentEitr = num3 * (float)_random.NextDouble(),
				MaxHealth = num,
				MaxStamina = num2,
				MaxEitr = num3,
				BodyArmor = _random.Next(10, 100),
				CurrentCarryWeight = num4 * (0.1f + (float)_random.NextDouble() * 0.7f),
				MaxCarryWeight = num4,
				GuardianPowerName = ((_random.Next(0, 100) > 30) ? FakeGuardianPowers[_random.Next(FakeGuardianPowers.Length)] : ""),
				GuardianPowerCooldown = ((_random.Next(0, 100) > 50) ? _random.Next(0, 1200) : 0),
				AttackSpeedModifier = 1f + (float)(_random.NextDouble() * 0.3 - 0.1),
				DamageModifier = 1f + (float)(_random.NextDouble() * 0.5),
				MovementSpeedModifier = 1f + (float)(_random.NextDouble() * 0.2 - 0.1),
				JumpModifier = 1f + (float)(_random.NextDouble() * 0.3),
				HealthRegen = 1f + (float)(_random.NextDouble() * 5.0),
				StaminaRegen = 5f + (float)(_random.NextDouble() * 10.0),
				EitrRegen = ((num3 > 0f) ? (2f + (float)(_random.NextDouble() * 5.0)) : 0f),
				IsPvPEnabled = (_random.Next(0, 100) > 80),
				CurrentBiome = FakeBiomes[_random.Next(FakeBiomes.Length)],
				ComfortLevel = _random.Next(0, 18)
			};
			GenerateSkills(remotePlayerStats);
			GeneratePlayerStats(remotePlayerStats);
			int num5 = _random.Next(0, 4);
			for (int i = 0; i < num5; i++)
			{
				string item = FakeEffects[_random.Next(FakeEffects.Length)];
				if (!remotePlayerStats.ActiveEffectNames.Contains(item))
				{
					remotePlayerStats.ActiveEffectNames.Add(item);
				}
			}
			int num6 = _random.Next(0, 4);
			for (int j = 0; j < num6; j++)
			{
				string foodName = FakeFoods[_random.Next(FakeFoods.Length)];
				if (remotePlayerStats.ActiveFoods.All((FoodSnapshot f) => f.Name != foodName))
				{
					remotePlayerStats.ActiveFoods.Add(new FoodSnapshot
					{
						Name = foodName,
						RemainingTime = _random.Next(60, 1800),
						MaxTime = 1800f
					});
				}
			}
			int num7 = _random.Next(3, 7);
			List<string> list = new List<string>();
			for (int num8 = 0; num8 < num7; num8++)
			{
				string text = num8 switch
				{
					0 => "Helmet", 
					1 => "Chest", 
					2 => "Legs", 
					3 => "Cape", 
					4 => "Weapon", 
					5 => "Shield", 
					_ => "Utility", 
				};
				if (!list.Contains(text))
				{
					list.Add(text);
					float num9 = 100 + _random.Next(0, 200);
					remotePlayerStats.EquippedItems.Add(new EquippedItemSnapshot
					{
						Name = FakeEquipment[_random.Next(FakeEquipment.Length)],
						Slot = text,
						Quality = _random.Next(1, 5),
						Durability = num9 * (0.3f + (float)_random.NextDouble() * 0.7f),
						MaxDurability = num9
					});
				}
			}
			return remotePlayerStats;
		}

		private static void GenerateSkills(RemotePlayerStats stats)
		{
			//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)
			SkillType[] array = new SkillType[10];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			SkillType[] array2 = (SkillType[])(object)array;
			foreach (SkillType key in array2)
			{
				if (_random.Next(0, 100) > 20)
				{
					stats.SkillLevels[key] = _random.Next(1, 100);
				}
			}
		}

		private static void GeneratePlayerStats(RemotePlayerStats stats)
		{
			stats.PlayerStats[(PlayerStatType)6] = _random.Next(0, 5000);
			stats.PlayerStats[(PlayerStatType)0] = _random.Next(0, 100);
			stats.PlayerStats[(PlayerStatType)5] = _random.Next(0, 20000);
			stats.PlayerStats[(PlayerStatType)10] = _random.Next(0, 10000);
			stats.PlayerStats[(PlayerStatType)85] = _random.Next(0, 20);
			stats.PlayerStats[(PlayerStatType)9] = _random.Next(0, 50);
			stats.PlayerStats[(PlayerStatType)8] = _random.Next(0, 200);
			stats.PlayerStats[(PlayerStatType)51] = _random.Next(0, 5000);
			stats.PlayerStats[(PlayerStatType)16] = _random.Next(10000, 500000);
			stats.PlayerStats[(PlayerStatType)17] = _random.Next(5000, 200000);
			stats.PlayerStats[(PlayerStatType)18] = _random.Next(5000, 200000);
			stats.PlayerStats[(PlayerStatType)19] = _random.Next(0, 100000);
			stats.PlayerStats[(PlayerStatType)20] = _random.Next(0, 10000);
			stats.PlayerStats[(PlayerStatType)15] = _random.Next(0, 500);
			stats.PlayerStats[(PlayerStatType)3] = _random.Next(0, 10000);
			stats.PlayerStats[(PlayerStatType)2] = _random.Next(0, 5000);
			stats.PlayerStats[(PlayerStatType)13] = _random.Next(0, 2000);
			stats.PlayerStats[(PlayerStatType)14] = _random.Next(0, 500);
			stats.PlayerStats[(PlayerStatType)1] = _random.Next(0, 2500);
			stats.PlayerStats[(PlayerStatType)12] = _random.Next(0, 50000);
			stats.PlayerStats[(PlayerStatType)27] = _random.Next(0, 10000);
			stats.PlayerStats[(PlayerStatType)37] = _random.Next(0, 20000);
			stats.PlayerStats[(PlayerStatType)49] = _random.Next(0, 1000);
			stats.PlayerStats[(PlayerStatType)21] = _random.Next(3600, 360000);
			stats.PlayerStats[(PlayerStatType)22] = _random.Next(3600, 360000);
			stats.PlayerStats[(PlayerStatType)23] = _random.Next(0, 36000);
			stats.PlayerStats[(PlayerStatType)26] = _random.Next(1, 500);
			stats.PlayerStats[(PlayerStatType)48] = _random.Next(0, 50);
			stats.PlayerStats[(PlayerStatType)74] = _random.Next(0, 5000);
			stats.PlayerStats[(PlayerStatType)76] = _random.Next(0, 500);
			stats.PlayerStats[(PlayerStatType)4] = _random.Next(0, 10);
		}

		public static void SimulateReceiveStats(string? playerName = null)
		{
			RemotePlayerStats remotePlayerStats = Generate(null, playerName);
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Simulating stats received from fake player: " + remotePlayerStats.PlayerName));
			StatsPanelController.ForceDisplayRemoteStats(remotePlayerStats);
		}

		public static bool TestCompression()
		{
			try
			{
				RemotePlayerStats remotePlayerStats = Generate();
				byte[] array = remotePlayerStats.ToCompressedBytes();
				RemotePlayerStats remotePlayerStats2 = RemotePlayerStats.FromCompressedBytes(array);
				if (remotePlayerStats2 == null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)"Compression test failed: decompression returned null");
					return false;
				}
				bool flag = remotePlayerStats.PlayerId == remotePlayerStats2.PlayerId && remotePlayerStats.PlayerName == remotePlayerStats2.PlayerName && remotePlayerStats.MaxHealth == remotePlayerStats2.MaxHealth && remotePlayerStats.CurrentHealth == remotePlayerStats2.CurrentHealth && remotePlayerStats.CurrentBiome == remotePlayerStats2.CurrentBiome && remotePlayerStats.GuardianPowerName == remotePlayerStats2.GuardianPowerName && remotePlayerStats.SkillLevels.Count == remotePlayerStats2.SkillLevels.Count && remotePlayerStats.PlayerStats.Count == remotePlayerStats2.PlayerStats.Count && remotePlayerStats.EquippedItems.Count == remotePlayerStats2.EquippedItems.Count && remotePlayerStats.ActiveFoods.Count == remotePlayerStats2.ActiveFoods.Count;
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Compression test: " + (flag ? "PASSED" : "FAILED")));
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"  Skills: {remotePlayerStats.SkillLevels.Count}, Stats: {remotePlayerStats.PlayerStats.Count}");
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"  Equipment: {remotePlayerStats.EquippedItems.Count}, Foods: {remotePlayerStats.ActiveFoods.Count}");
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"  Compressed size: {array.Length} bytes");
				return flag;
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)("Compression test failed with exception: " + ex.Message));
				return false;
			}
		}
	}
	public class RemotePlayerStats
	{
		public long PlayerId;

		public string PlayerName = "";

		public long Timestamp;

		public float CurrentHealth;

		public float CurrentStamina;

		public float CurrentEitr;

		public float MaxHealth;

		public float MaxStamina;

		public float MaxEitr;

		public float BodyArmor;

		public float CurrentCarryWeight;

		public float MaxCarryWeight;

		public string GuardianPowerName = "";

		public float GuardianPowerCooldown;

		public float AttackSpeedModifier;

		public float DamageModifier;

		public float MovementSpeedModifier;

		public float JumpModifier;

		public float HealthRegen;

		public float StaminaRegen;

		public float EitrRegen;

		public bool IsPvPEnabled;

		public string CurrentBiome = "";

		public int ComfortLevel;

		public Dictionary<SkillType, float> SkillLevels = new Dictionary<SkillType, float>();

		public Dictionary<PlayerStatType, float> PlayerStats = new Dictionary<PlayerStatType, float>();

		public List<string> ActiveEffectNames = new List<string>();

		public List<FoodSnapshot> ActiveFoods = new List<FoodSnapshot>();

		public List<EquippedItemSnapshot> EquippedItems = new List<EquippedItemSnapshot>();

		public void Serialize(ZPackage pkg)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected I4, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected I4, but got Unknown
			pkg.Write(PlayerId);
			pkg.Write(PlayerName);
			pkg.Write(Timestamp);
			pkg.Write(CurrentHealth);
			pkg.Write(CurrentStamina);
			pkg.Write(CurrentEitr);
			pkg.Write(MaxHealth);
			pkg.Write(MaxStamina);
			pkg.Write(MaxEitr);
			pkg.Write(BodyArmor);
			pkg.Write(CurrentCarryWeight);
			pkg.Write(MaxCarryWeight);
			pkg.Write(GuardianPowerName);
			pkg.Write(GuardianPowerCooldown);
			pkg.Write(AttackSpeedModifier);
			pkg.Write(DamageModifier);
			pkg.Write(MovementSpeedModifier);
			pkg.Write(JumpModifier);
			pkg.Write(HealthRegen);
			pkg.Write(StaminaRegen);
			pkg.Write(EitrRegen);
			pkg.Write(IsPvPEnabled);
			pkg.Write(CurrentBiome);
			pkg.Write(ComfortLevel);
			pkg.Write(SkillLevels.Count);
			foreach (KeyValuePair<SkillType, float> skillLevel in SkillLevels)
			{
				pkg.Write((int)skillLevel.Key);
				pkg.Write(skillLevel.Value);
			}
			pkg.Write(PlayerStats.Count);
			foreach (KeyValuePair<PlayerStatType, float> playerStat in PlayerStats)
			{
				pkg.Write((int)playerStat.Key);
				pkg.Write(playerStat.Value);
			}
			pkg.Write(ActiveEffectNames.Count);
			foreach (string activeEffectName in ActiveEffectNames)
			{
				pkg.Write(activeEffectName);
			}
			pkg.Write(ActiveFoods.Count);
			foreach (FoodSnapshot activeFood in ActiveFoods)
			{
				pkg.Write(activeFood.Name);
				pkg.Write(activeFood.RemainingTime);
				pkg.Write(activeFood.MaxTime);
			}
			pkg.Write(EquippedItems.Count);
			foreach (EquippedItemSnapshot equippedItem in EquippedItems)
			{
				pkg.Write(equippedItem.Name);
				pkg.Write(equippedItem.Slot);
				pkg.Write(equippedItem.Quality);
				pkg.Write(equippedItem.Durability);
				pkg.Write(equippedItem.MaxDurability);
			}
		}

		public static RemotePlayerStats Deserialize(ZPackage pkg)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			RemotePlayerStats remotePlayerStats = new RemotePlayerStats
			{
				PlayerId = pkg.ReadLong(),
				PlayerName = pkg.ReadString(),
				Timestamp = pkg.ReadLong(),
				CurrentHealth = pkg.ReadSingle(),
				CurrentStamina = pkg.ReadSingle(),
				CurrentEitr = pkg.ReadSingle(),
				MaxHealth = pkg.ReadSingle(),
				MaxStamina = pkg.ReadSingle(),
				MaxEitr = pkg.ReadSingle(),
				BodyArmor = pkg.ReadSingle(),
				CurrentCarryWeight = pkg.ReadSingle(),
				MaxCarryWeight = pkg.ReadSingle(),
				GuardianPowerName = pkg.ReadString(),
				GuardianPowerCooldown = pkg.ReadSingle(),
				AttackSpeedModifier = pkg.ReadSingle(),
				DamageModifier = pkg.ReadSingle(),
				MovementSpeedModifier = pkg.ReadSingle(),
				JumpModifier = pkg.ReadSingle(),
				HealthRegen = pkg.ReadSingle(),
				StaminaRegen = pkg.ReadSingle(),
				EitrRegen = pkg.ReadSingle(),
				IsPvPEnabled = pkg.ReadBool(),
				CurrentBiome = pkg.ReadString(),
				ComfortLevel = pkg.ReadInt()
			};
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				SkillType key = (SkillType)pkg.ReadInt();
				float value = pkg.ReadSingle();
				remotePlayerStats.SkillLevels[key] = value;
			}
			int num2 = pkg.ReadInt();
			for (int j = 0; j < num2; j++)
			{
				PlayerStatType key2 = (PlayerStatType)pkg.ReadInt();
				float value2 = pkg.ReadSingle();
				remotePlayerStats.PlayerStats[key2] = value2;
			}
			int num3 = pkg.ReadInt();
			for (int k = 0; k < num3; k++)
			{
				remotePlayerStats.ActiveEffectNames.Add(pkg.ReadString());
			}
			int num4 = pkg.ReadInt();
			for (int l = 0; l < num4; l++)
			{
				remotePlayerStats.ActiveFoods.Add(new FoodSnapshot
				{
					Name = pkg.ReadString(),
					RemainingTime = pkg.ReadSingle(),
					MaxTime = pkg.ReadSingle()
				});
			}
			int num5 = pkg.ReadInt();
			for (int m = 0; m < num5; m++)
			{
				remotePlayerStats.EquippedItems.Add(new EquippedItemSnapshot
				{
					Name = pkg.ReadString(),
					Slot = pkg.ReadString(),
					Quality = pkg.ReadInt(),
					Durability = pkg.ReadSingle(),
					MaxDurability = pkg.ReadSingle()
				});
			}
			return remotePlayerStats;
		}

		public byte[] ToCompressedBytes()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			Serialize(val);
			byte[] array = val.GetArray();
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionLevel.Optimal))
			{
				gZipStream.Write(array, 0, array.Length);
			}
			return memoryStream.ToArray();
		}

		public static RemotePlayerStats? FromCompressedBytes(byte[] data)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			try
			{
				using MemoryStream stream = new MemoryStream(data);
				using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
				using MemoryStream memoryStream = new MemoryStream();
				gZipStream.CopyTo(memoryStream);
				return Deserialize(new ZPackage(memoryStream.ToArray()));
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)("Failed to decompress remote player stats: " + ex.Message));
				return null;
			}
		}

		public static RemotePlayerStats GatherFromLocalPlayer()
		{
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Invalid comparison between Unknown and I4
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Invalid comparison between Unknown and I4
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return new RemotePlayerStats();
			}
			Game instance = Game.instance;
			PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
			SEMan sEMan = ((Character)localPlayer).GetSEMan();
			RemotePlayerStats obj = new RemotePlayerStats
			{
				PlayerId = ZNet.GetUID(),
				PlayerName = localPlayer.GetPlayerName(),
				Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
				CurrentHealth = ((Character)localPlayer).GetHealth(),
				CurrentStamina = localPlayer.GetStamina(),
				CurrentEitr = localPlayer.GetEitr(),
				MaxHealth = ((Character)localPlayer).GetMaxHealth(),
				MaxStamina = ((Character)localPlayer).GetMaxStamina(),
				MaxEitr = ((Character)localPlayer).GetMaxEitr(),
				BodyArmor = ((Character)localPlayer).GetBodyArmor()
			};
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			obj.CurrentCarryWeight = ((inventory != null) ? inventory.GetTotalWeight() : 0f);
			obj.MaxCarryWeight = localPlayer.GetMaxCarryWeight();
			obj.GuardianPowerName = PlayerStatsCalculator.GetGuardianPowerName(localPlayer);
			obj.GuardianPowerCooldown = localPlayer.m_guardianPowerCooldown;
			obj.AttackSpeedModifier = PlayerStatsCalculator.CalculateAttackSpeed(localPlayer) / 100f;
			obj.DamageModifier = 1f + PlayerStatsCalculator.CalculateDamageModifier(localPlayer) / 100f;
			obj.MovementSpeedModifier = 1f + PlayerStatsCalculator.CalculateSpeedModifier(localPlayer) / 100f;
			obj.JumpModifier = PlayerStatsCalculator.CalculateJumpModifier(localPlayer) / 100f;
			obj.HealthRegen = PlayerStatsCalculator.CalculateTotalHealthRegen(localPlayer);
			obj.StaminaRegen = PlayerStatsCalculator.CalculateTotalStaminaRegen(localPlayer);
			obj.EitrRegen = PlayerStatsCalculator.CalculateTotalEitrRegen(localPlayer);
			obj.IsPvPEnabled = ((Character)localPlayer).IsPVPEnabled();
			obj.CurrentBiome = PlayerStatsCalculator.GetBiomeName(localPlayer);
			obj.ComfortLevel = localPlayer.GetComfortLevel();
			RemotePlayerStats remotePlayerStats = obj;
			Skills skills = ((Character)localPlayer).GetSkills();
			if ((Object)(object)skills != (Object)null)
			{
				foreach (SkillType value in Enum.GetValues(typeof(SkillType)))
				{
					if ((int)value != 0 && (int)value != 999)
					{
						float skillLevel = skills.GetSkillLevel(value);
						if (skillLevel > 0f)
						{
							remotePlayerStats.SkillLevels[value] = skillLevel;
						}
					}
				}
			}
			if (val != null)
			{
				foreach (PlayerStatType value2 in Enum.GetValues(typeof(PlayerStatType)))
				{
					if ((int)value2 != 105)
					{
						try
						{
							remotePlayerStats.PlayerStats[value2] = val.m_playerStats[value2];
						}
						catch (KeyNotFoundException)
						{
						}
					}
				}
			}
			foreach (StatusEffect item in ((sEMan != null) ? sEMan.GetStatusEffects() : null) ?? new List<StatusEffect>())
			{
				if (!string.IsNullOrEmpty(item.m_name))
				{
					string text = (item.m_name.StartsWith("$") ? Localization.instance.Localize(item.m_name) : item.m_name);
					if (!string.IsNullOrEmpty(text) && !remotePlayerStats.ActiveEffectNames.Contains(text))
					{
						remotePlayerStats.ActiveEffectNames.Add(text);
					}
				}
			}
			foreach (Food food in localPlayer.GetFoods())
			{
				if (food.m_item?.m_shared != null)
				{
					remotePlayerStats.ActiveFoods.Add(new FoodSnapshot
					{
						Name = Localization.instance.Localize(food.m_item.m_shared.m_name),
						RemainingTime = food.m_time,
						MaxTime = food.m_item.m_shared.m_foodBurnTime
					});
				}
			}
			Inventory inventory2 = ((Humanoid)localPlayer).GetInventory();
			if (inventory2 != null)
			{
				foreach (ItemData equippedItem in inventory2.GetEquippedItems())
				{
					remotePlayerStats.EquippedItems.Add(new EquippedItemSnapshot
					{
						Name = Localization.instance.Localize(equippedItem.m_shared.m_name),
						Slot = PlayerStatsCalculator.GetEquipmentSlotName(equippedItem),
						Quality = equippedItem.m_quality,
						Durability = equippedItem.m_durability,
						MaxDurability = equippedItem.GetMaxDurability()
					});
				}
			}
			return remotePlayerStats;
		}
	}
	public struct FoodSnapshot
	{
		public string Name;

		public float RemainingTime;

		public float MaxTime;
	}
	public struct EquippedItemSnapshot
	{
		public string Name;

		public string Slot;

		public int Quality;

		public float Durability;

		public float MaxDurability;
	}
	public static class RemoteStatsRPC
	{
		public const string RequestRPCName = "AzuEPI_RequestStats";

		public const string ResponseRPCName = "AzuEPI_StatsResponse";

		private static ZRoutedRpc? _registeredInstance;

		public static void Register()
		{
			if (ZRoutedRpc.instance != null && _registeredInstance != ZRoutedRpc.instance)
			{
				ZRoutedRpc.instance.Register<ZPackage>("AzuEPI_RequestStats", (Action<long, ZPackage>)OnStatsRequested);
				ZRoutedRpc.instance.Register<ZPackage>("AzuEPI_StatsResponse", (Action<long, ZPackage>)OnStatsReceived);
				_registeredInstance = ZRoutedRpc.instance;
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Registered remote stats RPCs (local UID: {ZNet.GetUID()}, instance: {((object)ZRoutedRpc.instance).GetHashCode()})");
			}
		}

		public static void Reset()
		{
			_registeredInstance = null;
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Reset remote stats RPC registration");
		}

		public static void RequestStats(long targetPlayerId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				long uID = ZNet.GetUID();
				ZPackage val = new ZPackage();
				val.Write(uID);
				ZRoutedRpc.instance.InvokeRoutedRPC(targetPlayerId, "AzuEPI_RequestStats", new object[1] { val });
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Requested stats from player {targetPlayerId} (my UID: {uID})");
			}
		}

		private static void OnStatsRequested(long senderId, ZPackage pkg)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			try
			{
				if (ZRoutedRpc.instance != null && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					long num = pkg.ReadLong();
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Stats requested - auto senderId: {senderId}, explicit senderId: {num}");
					byte[] array = RemotePlayerStats.GatherFromLocalPlayer().ToCompressedBytes();
					ZPackage val = new ZPackage();
					val.Write(array);
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)string.Format("Sending compressed stats ({0} bytes) to {1} via {2}", array.Length, senderId, "AzuEPI_StatsResponse"));
					ZRoutedRpc.instance.InvokeRoutedRPC(senderId, "AzuEPI_StatsResponse", new object[1] { val });
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"InvokeRoutedRPC for response completed");
				}
			}
			catch (Exception arg)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)$"Exception in OnStatsRequested: {arg}");
			}
		}

		private static void OnStatsReceived(long senderId, ZPackage pkg)
		{
			try
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"OnStatsReceived called from senderId: {senderId}");
				byte[] array = pkg.ReadByteArray();
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Received compressed stats ({array.Length} bytes) from player {senderId}");
				RemotePlayerStats remotePlayerStats = RemotePlayerStats.FromCompressedBytes(array);
				if (remotePlayerStats == null)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"Failed to decompress remote player stats");
					StatsPanelController.OnRemoteStatsReceived(null);
				}
				else
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Decompressed stats for player: " + remotePlayerStats.PlayerName));
					StatsPanelController.OnRemoteStatsReceived(remotePlayerStats);
				}
			}
			catch (Exception arg)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)$"Exception in OnStatsReceived: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(ZRoutedRpc), "SetUID")]
	internal static class ZRoutedRpc_SetUID_RegisterRPCs
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			RemoteStatsRPC.Register();
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PlayerList")]
	internal static class ZNet_RPC_PlayerList_RefreshDropdown
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			StatsPanelController.OnPlayerListChanged();
		}
	}
	[HarmonyPatch(typeof(ZNet), "Shutdown")]
	internal static class ZNet_Shutdown_ResetRPCs
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			RemoteStatsRPC.Reset();
		}
	}
}
namespace AzuEPI.Game.Compatibility
{
	public static class ArmoireCompat
	{
		private const string ArmoireGuid = "advize.Armoire";

		public static bool IsArmoireInstalled => Chainloader.PluginInfos.ContainsKey("advize.Armoire");

		public static void CheckForArmoire()
		{
			if (IsArmoireInstalled)
			{
				AzuExtendedPlayerInventoryPlugin.VanityOption.Value = AzuExtendedPlayerInventoryPlugin.Toggle.Off;
				((BaseUnityPlugin)AzuExtendedPlayerInventoryPlugin.context).Config.Save();
			}
		}
	}
	public class BetterArchery
	{
		private const string Baguid = "ishid4.mods.betterarchery";

		public static void CheckBetterArchery()
		{
			if (!Chainloader.PluginInfos.TryGetValue("ishid4.mods.betterarchery", out var value))
			{
				return;
			}
			ConfigEntry<bool> entry = default(ConfigEntry<bool>);
			if (value.Instance.Config.TryGetEntry<bool>("Quiver", "Enable Quiver", ref entry) && entry.Value)
			{
				entry.Value = false;
				entry.SettingChanged += delegate
				{
					if (entry.Value)
					{
						entry.Value = false;
					}
				};
				value.Instance.Config.Save();
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)(Environment.NewLine + "BetterArchery's quiver feature has been forcibly disabled to prevent potential issues with your inventory. Logging into your world now may cause you to lose all arrows in your quiver. " + Environment.NewLine + "If you accept this risk, please proceed. " + Environment.NewLine + "If you prefer to avoid any potential issues, please disable/remove AzuExtendedPlayerInventory, restart the game, empty your quiver, remove the BetterArchery mod, and then reinstall AzuExtendedPlayerInventory."));
			}
			Assembly assembly = ((object)value.Instance).GetType().Assembly;
			MethodInfo methodInfo = AccessTools.Method(typeof(TombStone), "OnTakeAllSuccess", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"Could not find TombStone.OnTakeAllSuccess — skipping BetterArchery unpatch.");
				return;
			}
			Patches patchInfo = Harmony.GetPatchInfo((MethodBase)methodInfo);
			if (patchInfo == null)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"No Harmony patches found on TombStone.OnTakeAllSuccess — BetterArchery may not have applied its patch yet.");
				return;
			}
			Patch[] array = patchInfo.Postfixes.ToArray();
			foreach (Patch val in array)
			{
				if (!((val.PatchMethod.DeclaringType?.Assembly)?.FullName != assembly.FullName))
				{
					AzuExtendedPlayerInventoryPlugin.context._harmony.Unpatch((MethodBase)methodInfo, val.PatchMethod);
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("Removed BetterArchery patch on " + methodInfo.Name + " | " + val.PatchMethod.DeclaringType?.FullName + "::" + val.PatchMethod.Name);
				}
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "Start")]
	internal static class FejdStartupStartPatch
	{
		private static void Postfix(FejdStartup __instance)
		{
			BetterArchery.CheckBetterArchery();
		}
	}
	public class EAQ
	{
		internal static void CheckRandy()
		{
			if ((!AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value.isOff() || !AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff()) && Chainloader.PluginInfos.TryGetValue("randyknapp.mods.equipmentandquickslots", out var _))
			{
				AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value = AzuExtendedPlayerInventoryPlugin.Toggle.Off;
				AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value = AzuExtendedPlayerInventoryPlugin.Toggle.Off;
				((BaseUnityPlugin)AzuExtendedPlayerInventoryPlugin.context).Config.Save();
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)(Environment.NewLine + "RandyKnapp's Equipment and Quickslots mod has been detected. This mod is not fully compatible with his. As a result, the Display Equipment Row Separate and Add Equipment Row options for this mod have been disabled and the configuration saved."));
			}
		}
	}
	public class EpicLootCompat
	{
		private static readonly HashSet<string> EpicLootEquipmentItems = new HashSet<string>(StringComparer.Ordinal) { "Andvaranaut", "GoldRubyRing", "SilverRing" };

		public static void Init()
		{
			if (Chainloader.PluginInfos.TryGetValue("randyknapp.mods.epicloot", out var value) && !((Object)(object)((value != null) ? value.Instance : null) == (Object)null))
			{
				if (!AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$azuepi_fingerslot"))
				{
					API.AddSlot("$azuepi_fingerslot", new List<string>(EpicLootEquipmentItems).ToArray());
				}
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(EpicLootCompat));
			}
		}

		[HarmonyPatch("EpicLoot.PlayerExtensions, EpicLoot", "GetEquipment")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		public static void EpicLootGetEquipment(ref List<ItemData> __result)
		{
			//IL_0037: 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)
			Player localPlayer = Player.m_localPlayer;
			Inventory val = ((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null);
			if ((Object)(object)localPlayer == (Object)null || val == null)
			{
				return;
			}
			foreach (SlotSnapshot equipmentSlotSnapshot in API.GetEquipmentSlotSnapshots(val))
			{
				ItemData itemAt = val.GetItemAt(equipmentSlotSnapshot.GridPos.x, equipmentSlotSnapshot.GridPos.y);
				if (itemAt != null && !__result.Contains(itemAt))
				{
					__result.Add(itemAt);
				}
			}
		}
	}
	public class WeightBase
	{
		public static void CheckWeightBase()
		{
			if (Chainloader.PluginInfos.TryGetValue("MadBuffoon.WeightBase", out var _))
			{
				AzuExtendedPlayerInventoryPlugin.WbInstalled = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class JCBPUIUseBleedGuard
	{
		private static bool _gateActive;

		private static float _gateExpireTime;

		private static float _warpUntilTime;

		private static CursorLockMode _previousLockState;

		private static bool? _shouldActivate;

		private const float GateDurationSeconds = 0.3f;

		private const float WarpDurationSeconds = 0.15f;

		private static bool InWarpWindow => Time.unscaledTime < _warpUntilTime;

		private static bool InGateWindow
		{
			get
			{
				if (_gateActive && Time.unscaledTime <= _gateExpireTime)
				{
					return InventoryGui.IsVisible();
				}
				return false;
			}
		}

		private static bool ShouldActivate()
		{
			bool valueOrDefault = _shouldActivate == true;
			if (!_shouldActivate.HasValue)
			{
				valueOrDefault = Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.jewelcrafting") || Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.backpacks");
				_shouldActivate = valueOrDefault;
			}
			return _shouldActivate.Value;
		}

		private static bool IsUseName(string name)
		{
			if (name == "Use" || name == "JoyUse")
			{
				return true;
			}
			return false;
		}

		private static void StartWarpWindow()
		{
			if (ShouldActivate())
			{
				_warpUntilTime = Time.unscaledTime + 0.15f;
			}
		}

		private static void ArmGate()
		{
			if (ShouldActivate())
			{
				_gateActive = true;
				_gateExpireTime = Time.unscaledTime + 0.3f;
			}
		}

		private static void DisarmGate()
		{
			_gateActive = false;
		}

		private static bool GetRawButtonState(string name)
		{
			try
			{
				ZInput instance = ZInput.instance;
				bool? obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					ButtonDef buttonDef = instance.GetButtonDef(name);
					obj = ((buttonDef != null) ? new bool?(buttonDef.Held) : ((bool?)null));
				}
				bool? flag = obj;
				return flag == true;
			}
			catch
			{
				return false;
			}
		}

		private static void TryWarpCursor()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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)
			if (!ShouldActivate() || !InWarpWindow || !InventoryGui.IsVisible() || (int)Cursor.lockState != 0 || (Object)(object)UIBuilder.PreviewParent == (Object)null || !UIBuilder.PreviewParent.activeSelf)
			{
				return;
			}
			AzuEPICharacterPanel instance = AzuEPICharacterPanel.instance;
			if (!((Object)(object)instance?.render == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				instance.render.GetWorldCorners(array);
				Vector3 val = (array[0] + array[2]) * 0.5f;
				Canvas componentInParent = ((Component)instance.render).GetComponentInParent<Canvas>();
				if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0 && (Object)(object)componentInParent.worldCamera != (Object)null)
				{
					val = componentInParent.worldCamera.WorldToScreenPoint(val);
				}
				ZInput.SetMousePosition(new Vector2(val.x, val.y));
			}
		}

		[HarmonyPatch(typeof(Container), "Interact")]
		[HarmonyPrefix]
		private static void Container_Interact_Prefix(Humanoid character, bool hold)
		{
			if (!((Object)(object)character != (Object)(object)Player.m_localPlayer || hold))
			{
				bool num = GetRawButtonState("Use") || GetRawButtonState("JoyUse");
				StartWarpWindow();
				if (num)
				{
					ArmGate();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void InventoryGui_Show_Prefix()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			StartWarpWindow();
			_previousLockState = Cursor.lockState;
			if ((int)Cursor.lockState == 1)
			{
				TryWarpCursor();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		[HarmonyPostfix]
		[HarmonyPriority(800)]
		private static void InventoryGui_Show_Postfix(Container container)
		{
			TryWarpCursor();
			if ((Object)(object)container != (Object)null && (GetRawButtonState("Use") || GetRawButtonState("JoyUse")))
			{
				ArmGate();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		[HarmonyPatch(typeof(InventoryGui), "CloseContainer")]
		[HarmonyPostfix]
		private static void InventoryGui_Close_Postfix()
		{
			DisarmGate();
		}

		[HarmonyPatch(typeof(ZInput), "GetButtonDown")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "org.bepinex.plugins.jewelcrafting" })]
		private static bool ZInput_GetButtonDown_Prefix(string name, ref bool __result)
		{
			//IL_0044: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldActivate())
			{
				return true;
			}
			if (!IsUseName(name))
			{
				return true;
			}
			if (InWarpWindow)
			{
				__result = false;
				return false;
			}
			if (!InGateWindow)
			{
				return true;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance?.m_playerGrid == (Object)null)
			{
				return true;
			}
			Vector2 val = Vector2.op_Implicit(Input.mousePosition);
			if (instance.m_playerGrid.GetItem(new Vector2i(Mathf.RoundToInt(val.x), Mathf.RoundToInt(val.y))) == null)
			{
				return true;
			}
			if (!GetRawButtonState(name))
			{
				DisarmGate();
			}
			__result = false;
			return false;
		}

		[HarmonyPatch(typeof(ZInput), "GetButtonUp")]
		[HarmonyPostfix]
		private static void ZInput_GetButtonUp_Postfix(string name)
		{
			if (_gateActive && IsUseName(name) && Time.unscaledTime > _gateExpireTime)
			{
				DisarmGate();
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "GetItem", new Type[] { typeof(Vector2i) })]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool InventoryGrid_GetItem_Prefix(ref ItemData __result)
		{
			if (!ShouldActivate() || !InWarpWindow)
			{
				return true;
			}
			__result = null;
			return false;
		}

		[HarmonyPatch(typeof(Player), "Update")]
		[HarmonyPatch(typeof(InventoryGui), "Update")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Update_Prefix()
		{
			TryWarpCursor();
		}

		[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
		[HarmonyPostfix]
		private static void GameCamera_UpdateMouseCapture_Postfix()
		{
			//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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			CursorLockMode lockState = Cursor.lockState;
			TryWarpCursor();
			if (ShouldActivate() && (int)_previousLockState == 1 && (int)lockState == 0 && InventoryGui.IsVisible())
			{
				_warpUntilTime = Mathf.Max(_warpUntilTime, Time.unscaledTime + 0.15f);
				TryWarpCursor();
			}
			_previousLockState = lockState;
		}
	}
	public class JudesEquipmentCompat
	{
		public readonly HashSet<string> Backpacks = new HashSet<string> { "BackpackHeavy", "BackpackSimple" };

		public static void Init()
		{
			if (Chainloader.PluginInfos.TryGetValue("GoldenJude_JudesEquipment", out var value) && value != null && !((Object)(object)value.Instance == (Object)null))
			{
				if (!AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$bp_backpack_slot_name"))
				{
					API.AddSlot("$bp_backpack_slot_name", new JudesEquipmentCompat().Backpacks.ToArray());
				}
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(JudesEquipmentCompat));
			}
		}
	}
	public static class JewelcraftingCompat
	{
		private const string JewelcraftingGuid = "org.bepinex.plugins.jewelcrafting";

		private static ConfigEntryBase? _wisplightGemConfig;

		private static ConfigEntryBase? _wishboneGemConfig;

		private static Delegate? _wisplightHandler;

		private static Delegate? _wishboneHandler;

		public static bool IsLoaded { get; private set; }

		public static bool IsWisplightAGem()
		{
			if (!IsLoaded || _wisplightGemConfig == null)
			{
				return false;
			}
			return Convert.ToInt32(_wisplightGemConfig.BoxedValue) == 1;
		}

		public static bool IsWishboneAGem()
		{
			if (!IsLoaded || _wishboneGemConfig == null)
			{
				return false;
			}
			return Convert.ToInt32(_wishboneGemConfig.BoxedValue) == 1;
		}

		public static void Init()
		{
			if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.jewelcrafting", out var value) || (Object)(object)((value != null) ? value.Instance : null) == (Object)null)
			{
				return;
			}
			IsLoaded = true;
			ConfigFile config = value.Instance.Config;
			string text = ((value.Metadata.Version >= new System.Version("2.0.0")) ? "7 - Other" : "6 - Other");
			foreach (ConfigDefinition key in config.Keys)
			{
				if (!(key.Section != text))
				{
					if (key.Key == "Wisplight Gem")
					{
						_wisplightGemConfig = config[key];
					}
					else if (key.Key == "Wishbone Gem")
					{
						_wishboneGemConfig = config[key];
					}
				}
			}
			if (_wisplightGemConfig != null)
			{
				_wisplightHandler = SubscribeToSettingChanged(_wisplightGemConfig, HandleWisplightChange);
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"JewelcraftingCompat: Found wisplightGem config (current: {_wisplightGemConfig.BoxedValue})");
			}
			if (_wishboneGemConfig != null)
			{
				_wishboneHandler = SubscribeToSettingChanged(_wishboneGemConfig, HandleWishboneChange);
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"JewelcraftingCompat: Found wishboneGem config (current: {_wishboneGemConfig.BoxedValue})");
			}
			HandleInitialState();
		}

		private static Delegate? SubscribeToSettingChanged(ConfigEntryBase entry, Action handler)
		{
			System.Reflection.EventInfo eventInfo = ((object)entry).GetType().GetEvent("SettingChanged");
			if (eventInfo == null)
			{
				return null;
			}
			EventHandler eventHandler = delegate
			{
				handler();
			};
			eventInfo.AddEventHandler(entry, eventHandler);
			return eventHandler;
		}

		private static void UnsubscribeFromSettingChanged(ConfigEntryBase? entry, Delegate? handler)
		{
			if (entry != null && (object)handler != null)
			{
				((object)entry).GetType().GetEvent("SettingChanged")?.RemoveEventHandler(entry, handler);
			}
		}

		public static void Cleanup()
		{
			UnsubscribeFromSettingChanged(_wisplightGemConfig, _wisplightHandler);
			UnsubscribeFromSettingChanged(_wishboneGemConfig, _wishboneHandler);
			_wisplightGemConfig = null;
			_wishboneGemConfig = null;
			_wisplightHandler = null;
			_wishboneHandler = null;
			IsLoaded = false;
		}

		private static void HandleInitialState()
		{
			bool flag = false;
			if (IsWishboneAGem())
			{
				API.RemoveSlot("$item_wishbone");
				if (Localization.m_instance != null)
				{
					API.RemoveSlot(Localization.m_instance.Localize("$item_wishbone"));
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"JewelcraftingCompat: Removed Wishbone slot (Jewelcrafting has it as a gem)");
				flag = true;
			}
			if (IsWisplightAGem())
			{
				API.RemoveSlot("$item_demister");
				if (Localization.m_instance != null)
				{
					API.RemoveSlot(Localization.m_instance.Localize("$item_demister"));
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"JewelcraftingCompat: Removed Wisplight slot (Jewelcrafting has it as a gem)");
				flag = true;
			}
			if (flag)
			{
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			}
		}

		private static void HandleWisplightChange()
		{
			bool flag = IsWisplightAGem();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("JewelcraftingCompat: wisplightGem changed to " + (flag ? "On (gem)" : "Off (utility)")));
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			if (flag)
			{
				API.RemoveSlot("$item_demister");
				if (Localization.m_instance != null)
				{
					API.RemoveSlot(Localization.m_instance.Localize("$item_demister"));
				}
			}
			else if (AzuExtendedPlayerInventoryPlugin.WispLightSlot.Value.isOn() && !AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$item_demister"))
			{
				int index = ((AzuExtendedPlayerInventoryPlugin.WishboneSlot.Value.isOn() && !IsWishboneAGem()) ? 6 : 5);
				API.AddSlot("$item_demister", "Demister", index);
			}
			AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
		}

		private static void HandleWishboneChange()
		{
			bool flag = IsWishboneAGem();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("JewelcraftingCompat: wishboneGem changed to " + (flag ? "On (gem)" : "Off (utility)")));
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			if (flag)
			{
				API.RemoveSlot("$item_wishbone");
				if (Localization.instance != null)
				{
					API.RemoveSlot(Localization.instance.Localize("$item_wishbone"));
				}
			}
			else if (AzuExtendedPlayerInventoryPlugin.WishboneSlot.Value.isOn() && !AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$item_wishbone"))
			{
				API.AddSlot("$item_wishbone", "Wishbone", 5);
			}
			AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
		}
	}
	public class RustyBagsCompat
	{
		public static HashSet<string> Backpacks = new HashSet<string> { "LeatherBag_RS", "BarrelBag_RS", "UnbjornBag_RS", "DvergerBag_RS" };

		public static HashSet<string> Quivers = new HashSet<string> { "Quiver_RS", "MountainQuiver_RS" };

		public static void Init()
		{
			if (Chainloader.PluginInfos.TryGetValue("RustyMods.RustyBags", out var value) && value != null && !((Object)(object)value.Instance == (Object)null))
			{
				API.AddSlot("$bp_backpack_slot_name", Backpacks.ToArray().Concat(Quivers.ToArray()));
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(RustyBagsCompat));
			}
		}

		[HarmonyPatch("RustyBags.BagEquipment, RustyBags", "IsBagEquipped")]
		[HarmonyPostfix]
		public static void AdvBackpackIsBackpackEquipped(ref bool __result)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() != null)
			{
				List<ItemData> equippedItems = ((Humanoid)localPlayer).GetInventory().GetEquippedItems();
				if (equippedItems != null && equippedItems.Exists((ItemData item) => item != null && (Object)(object)item.m_dropPrefab != (Object)null && (Backpacks.Contains(((Object)item.m_dropPrefab).name) || Quivers.Contains(((Object)item.m_dropPrefab).name))))
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch("RustyBags.BagEquipment+Humanoid_UnequipItem_Patch, RustyBags", "Prefix")]
		[HarmonyPrefix]
		public static void RustyBagsHumanoidUnequipItemPatchPrefix(ref ItemData __state)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Humanoid)localPlayer).GetInventory() == null)
			{
				return;
			}
			__state = ((Humanoid)localPlayer).m_trinketItem;
			if (__state == null || !((Object)(object)__state.m_dropPrefab != (Object)null))
			{
				return;
			}
			List<ItemData> equippedItems = ((Humanoid)localPlayer).GetInventory().GetEquippedItems();
			if (equippedItems != null)
			{
				((Humanoid)localPlayer).m_trinketItem = equippedItems.Find((ItemData item) => item != null && (Object)(object)item.m_dropPrefab != (Object)null && Backpacks.Contains(((Object)item.m_dropPrefab).name)) ?? equippedItems.Find((ItemData item) => item != null && (Object)(object)item.m_dropPrefab != (Object)null && Quivers.Contains(((Object)item.m_dropPrefab).name));
			}
		}

		[HarmonyPatch("RustyBags.BagEquipment+Humanoid_UnequipItem_Patch, RustyBags", "Prefix")]
		[HarmonyPostfix]
		public static void RustyBagsHumanoidUnequipItemPatchPostfix(ref ItemData __state)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() != null)
			{
				((Humanoid)localPlayer).m_trinketItem = __state;
			}
		}
	}
	public static class VESCompat
	{
		private const string VESGuid = "kg.ValheimEnchantmentSystem";

		public static bool IsVesInstalled => Chainloader.PluginInfos.ContainsKey("kg.ValheimEnchantmentSystem");
	}
	public static class ZenUICompat
	{
		private const string ZenUIGuid = "ZenDragon.ZenUI";

		public static void DisableEquipmentSlots()
		{
			ConfigEntry<bool> val = default(ConfigEntry<bool>);
			if (Chainloader.PluginInfos.TryGetValue("ZenDragon.ZenUI", out var value) && value.Instance.Config.TryGetEntry<bool>("Inventory Equip", "Assigned Gear Slots", ref val) && val.Value)
			{
				val.Value = false;
				value.Instance.Config.Save();
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(ZenUICompat));
			}
		}

		[HarmonyPatch("ZenUI.Section.InventoryEquip, ZenUI", "Humanoid_EquipItem")]
		[HarmonyPrefix]
		public static bool PreventItemSort()
		{
			return false;
		}

		[HarmonyPatch("ZenUI.Section.InventoryEquip, ZenUI", "InventoryGrid_DropItem")]
		[HarmonyPrefix]
		public static bool PreventItemSort2()
		{
			return false;
		}
	}
	public static class ValheimPlusCompat
	{
		private const string GUID = "org.bepinex.plugins.valheim_plus";

		private const string VPlusHarmonyId = "mod.valheim_plus";

		private static bool? _isLoaded;

		private static bool? _isInventoryEnabled;

		private static int? _vplusConfiguredRows;

		private static Assembly _assembly;

		private static bool IsLoaded
		{
			get
			{
				bool valueOrDefault = _isLoaded == true;
				if (!_isLoaded.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.valheim_plus");
					_isLoaded = valueOrDefault;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
		}

		private static bool IsInventoryFeatureEnabled
		{
			get
			{
				if (!IsLoaded)
				{
					return false;
				}
				if (_isInventoryEnabled.HasValue)
				{
					return _isInventoryEnabled.Value;
				}
				ParseVPlusConfig();
				return _isInventoryEnabled == true;
			}
		}

		private static void ParseVPlusConfig()
		{
			_isInventoryEnabled = false;
			_vplusConfiguredRows = 4;
			try
			{
				string text = Path.Combine(Paths.ConfigPath, "valheim_plus.cfg");
				if (!File.Exists(text))
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("ValheimPlusCompat: Config file not found at: " + text));
					return;
				}
				string[] array = File.ReadAllLines(text);
				bool flag = false;
				bool flag2 = false;
				int num = 4;
				string[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					string text2 = array2[i].Trim();
					if (string.IsNullOrEmpty(text2) || text2.StartsWith(";") || text2.StartsWith("#"))
					{
						continue;
					}
					if (text2.StartsWith("["))
					{
						flag = text2.Equals("[Inventory]", StringComparison.OrdinalIgnoreCase);
					}
					else
					{
						if (!flag)
						{
							continue;
						}
						int num2 = text2.IndexOf('=');
						if (num2 > 0)
						{
							string text3 = text2.Substring(0, num2).Trim();
							string text4 = text2.Substring(num2 + 1).Trim();
							int result;
							if (text3.Equals("enabled", StringComparison.OrdinalIgnoreCase))
							{
								flag2 = text4.Equals("true", StringComparison.OrdinalIgnoreCase);
							}
							else if (text3.Equals("playerInventoryRows", StringComparison.OrdinalIgnoreCase) && int.TryParse(text4, out result))
							{
								num = Mathf.Clamp(result, 4, 20);
							}
						}
					}
				}
				_isInventoryEnabled = flag2;
				_vplusConfiguredRows = num;
				if (flag2)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"ValheimPlusCompat: V+ Inventory feature enabled with {num} rows - AzuEPI will override");
				}
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("ValheimPlusCompat: Failed to parse V+ config: " + ex.Message));
			}
		}

		public static void Initialize()
		{
			if (!IsLoaded)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("ValheimPlusCompat: ValheimPlus not detected");
				return;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)"ValheimPlusCompat: ValheimPlus detected");
			if (Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.valheim_plus", out var value))
			{
				_assembly = Assembly.GetAssembly(((object)value.Instance).GetType());
			}
			ParseVPlusConfig();
			if (IsInventoryFeatureEnabled)
			{
				RemoveConflictingPatches();
				PatchRowsGetter();
				SyncRowsToConfig();
			}
		}

		private static void PatchRowsGetter()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			if (_assembly == null)
			{
				return;
			}
			Type type = _assembly.GetType("ValheimPlus.Configurations.Sections.InventoryConfiguration");
			if (type == null)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"ValheimPlusCompat: Could not find InventoryConfiguration type");
				return;
			}
			MethodBase methodBase = AccessTools.PropertyGetter(type, "playerInventoryRows");
			if (methodBase == null)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)"ValheimPlusCompat: Could not find playerInventoryRows getter");
				return;
			}
			AzuExtendedPlayerInventoryPlugin.context._harmony.Patch(methodBase, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ValheimPlusCompat), "RowsGetterFinalizer", (Type[])null), (HarmonyMethod)null);
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)"ValheimPlusCompat: Patched V+ playerInventoryRows getter to return AzuEPI height");
		}

		private static void RowsGetterFinalizer(ref int __result)
		{
			__result = API.GetFullHeight(8);
		}

		public static void SyncRowsToConfig()
		{
			if (_assembly == null)
			{
				return;
			}
			try
			{
				Type type = _assembly.GetType("ValheimPlus.Configurations.Configuration");
				if (type == null)
				{
					return;
				}
				object obj = AccessTools.Property(type, "Current")?.GetValue(null);
				if (obj == null)
				{
					return;
				}
				object obj2 = obj.GetType().GetProperty("Inventory", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj);
				if (obj2 == null)
				{
					return;
				}
				PropertyInfo property = obj2.GetType().GetProperty("playerInventoryRows", BindingFlags.Instance | BindingFlags.Public);
				if (!(property == null))
				{
					int fullHeight = API.GetFullHeight(8);
					MethodInfo setMethod = property.GetSetMethod(nonPublic: true);
					if (setMethod != null)
					{
						setMethod.Invoke(obj2, new object[1] { fullHeight });
					}
					else if (property.CanWrite)
					{
						property.SetValue(obj2, fullHeight);
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)$"ValheimPlusCompat: Set V+ playerInventoryRows = {fullHeight}");
				}
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("ValheimPlusCompat: Failed to sync rows to V+ config: " + ex.Message));
			}
		}

		private static void RemoveConflictingPatches()
		{
			try
			{
				ConstructorInfo method = AccessTools.Constructor(typeof(Inventory), new Type[4]
				{
					typeof(string),
					typeof(Sprite),
					typeof(int),
					typeof(int)
				}, false);
				MethodInfo method2 = AccessTools.Method(typeof(InventoryGui), "Show", (Type[])null, (Type[])null);
				MethodInfo method3 = AccessTools.Method(typeof(InventoryGrid), "UpdateGui", (Type[])null, (Type[])null);
				UnpatchVPlusFrom(method, "Inventory constructor");
				UnpatchVPlusFrom(method2, "InventoryGui.Show");
				UnpatchVPlusFrom(method3, "InventoryGrid.UpdateGui");
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)"ValheimPlusCompat: Removed V+ inventory patches - AzuEPI now controls inventory layout");
			}
			catch (Exception ex)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("ValheimPlusCompat: Error removing V+ patches: " + ex.Message));
			}
		}

		private static void UnpatchVPlusFrom(MethodBase method, string methodName)
		{
			if (method == null)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("ValheimPlusCompat: Could not find " + methodName));
				return;
			}
			Patches patchInfo = Harmony.GetPatchInfo(method);
			if (patchInfo == null)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("ValheimPlusCompat: No patches found on " + methodName);
				return;
			}
			int num = 0;
			foreach (Patch prefix in patchInfo.Prefixes)
			{
				if (!(prefix.owner != "mod.valheim_plus"))
				{
					AzuExtendedPlayerInventoryPlugin.context._harmony.Unpatch(method, prefix.PatchMethod);
					num++;
				}
			}
			foreach (Patch postfix in patchInfo.Postfixes)
			{
				if (!(postfix.owner != "mod.valheim_plus"))
				{
					AzuExtendedPlayerInventoryPlugin.context._harmony.Unpatch(method, postfix.PatchMethod);
					num++;
				}
			}
			foreach (Patch transpiler in patchInfo.Transpilers)
			{
				if (!(transpiler.owner != "mod.valheim_plus"))
				{
					AzuExtendedPlayerInventoryPlugin.context._harmony.Unpatch(method, transpiler.PatchMethod);
					num++;
				}
			}
			foreach (Patch finalizer in patchInfo.Finalizers)
			{
				if (!(finalizer.owner != "mod.valheim_plus"))
				{
					AzuExtendedPlayerInventoryPlugin.context._harmony.Unpatch(method, finalizer.PatchMethod);
					num++;
				}
			}
			if (num > 0)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"ValheimPlusCompat: Removed {num} V+ patch(es) from {methodName}");
			}
		}
	}
	[HarmonyPatch(typeof(RectTransformUtility), "RectangleContainsScreenPoint", new Type[]
	{
		typeof(RectTransform),
		typeof(Vector2)
	})]
	public static class BackpacksCompatBlockInteractInput
	{
		private static void Postfix(RectTransform rect, Vector2 screenPoint, ref bool __result)
		{
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			if (__result || !Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				return;
			}
			bool num = (Object)(object)rect == (Object)(object)InventoryGui.instance.m_playerGrid.m_gridRoot;
			RectTransform val = default(RectTransform);
			bool flag = (Object)(object)InventoryGui.instance.m_crafting != (Object)null && ((Component)InventoryGui.instance.m_crafting).TryGetComponent<RectTransform>(ref val) && (Object)(object)rect == (Object)(object)val;
			if (!num && !flag)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null)
			{
				return;
			}
			int baseSlotIndex = Layout.GetBaseSlotIndex(inventory);
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			for (int i = 0; i < slots.Count; i++)
			{
				int num2 = baseSlotIndex + i;
				if (num2 >= InventoryGui.instance.m_playerGrid.m_elements.Count)
				{
					break;
				}
				Element val2 = InventoryGui.instance.m_playerGrid.m_elements[num2];
				if ((Object)(object)val2?.m_go == (Object)null)
				{
					continue;
				}
				Transform transform = val2.m_go.transform;
				RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (!((Object)(object)val3 == (Object)null))
				{
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					val3.GetWorldCorners(array);
					float num3 = Mathf.Min(new float[4]
					{
						array[0].x,
						array[1].x,
						array[2].x,
						array[3].x
					});
					float num4 = Mathf.Max(new float[4]
					{
						array[0].x,
						array[1].x,
						array[2].x,
						array[3].x
					});
					float num5 = Mathf.Min(new float[4]
					{
						array[0].y,
						array[1].y,
						array[2].y,
						array[3].y
					});
					float num6 = Mathf.Max(new float[4]
					{
						array[0].y,
						array[1].y,
						array[2].y,
						array[3].y
					});
					if (screenPoint.x >= num3 && screenPoint.x <= num4 && screenPoint.y >= num5 && screenPoint.y <= num6)
					{
						__result = true;
						break;
					}
				}
			}
		}
	}
	public class Hunter_LegacyCompat
	{
		private static readonly HashSet<string> Quivers = new HashSet<string>(StringComparer.Ordinal) { "ArmorFrostpeakHarrierCapeDO", "ArmorGoldenStriderCapeDO", "ArmorSapphireFalconCapeDO", "ArmorAshenExileCapeDO", "ArmorDemonHunterCapeDO" };

		public static void Init()
		{
			if (Chainloader.PluginInfos.TryGetValue("Dreanegade.Hunter_Legacy", out var value) && !((Object)(object)((value != null) ? value.Instance : null) == (Object)null))
			{
				API.AddSlot("$bbh_slot_quiver", new List<string>(Quivers).ToArray());
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(Hunter_LegacyCompat));
			}
		}
	}
	public class WizardryCompat
	{
		private static readonly HashSet<string> Rings = new HashSet<string>(StringComparer.Ordinal) { "RingBlackForest_TW", "RingSwamp_TW", "RingMountain_TW", "RingPlains_TW", "RingMistlands_TW" };

		public static void Init()
		{
			if (Chainloader.PluginInfos.TryGetValue("Therzie.Wizardry", out var value) && !((Object)(object)((value != null) ? value.Instance : null) == (Object)null))
			{
				API.AddSlot("$azuepi_fingerslot", new List<string>(Rings).ToArray());
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(Hunter_LegacyCompat));
			}
		}
	}
}
namespace AzuEPI.Game.Compatibility.AdvBackpacks
{
	public class AdvBackpacksCompat
	{
		internal static readonly HashSet<string> Backpacks = new HashSet<string>(StringComparer.Ordinal) { "BackpackMeadows", "BackpackBlackForest", "BackpackSwamp", "BackpackMountains", "BackpackPlains", "BackpackMistlands", "CapeSilverBackpack", "CapeIronBackpack" };

		internal static bool IsActive;

		private static Func<ItemData, bool>? _abApiIsBackpack;

		private static bool _apiResolved;

		internal static bool IsAbBackpack(ItemData? item)
		{
			if (IsActive && (Object)(object)item?.m_dropPrefab != (Object)null)
			{
				return Backpacks.Contains(((Object)item.m_dropPrefab).name);
			}
			return false;
		}

		public static void Init()
		{
			if (Chainloader.PluginInfos.TryGetValue("vapok.mods.adventurebackpacks", out var value) && !((Object)(object)((value != null) ? value.Instance : null) == (Object)null))
			{
				ResolveAbApi(((object)value.Instance).GetType().Assembly);
				if (!AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$bp_backpack_slot_name"))
				{
					API.AddSlot("$bp_backpack_slot_name", new List<string>(Backpacks).ToArray());
				}
				AzuExtendedPlayerInventoryPlugin.context._harmony.PatchAll(typeof(AdvBackpacksCompat));
				IsActive = true;
			}
		}

		private static void ResolveAbApi(Assembly abAssembly)
		{
			if (_apiResolved)
			{
				return;
			}
			_apiResolved = true;
			try
			{
				MethodInfo methodInfo = AccessTools.Method(abAssembly.GetType("AdventureBackpacks.API.ABAPI"), "IsBackpack", new Type[1] { typeof(ItemData) }, (Type[])null);
				if (methodInfo != null)
				{
					_abApiIsBackpack = (Func<ItemData, bool>)Delegate.CreateDelegate(typeof(Func<ItemData, bool>), methodInfo);
				}
			}
			catch
			{
				_abApiIsBackpack = null;
			}
		}

		private static bool IsBackpackItem(ItemData? item)
		{
			if (item == null)
			{
				return false;
			}
			if (_abApiIsBackpack == null)
			{
				if ((Object)(object)item.m_dropPrefab != (Object)null)
				{
					return Backpacks.Contains(((Object)item.m_dropPrefab).name);
				}
				return false;
			}
			try
			{
				return _abApiIsBackpack(item);
			}
			catch
			{
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return Backpacks.Contains(((Object)item.m_dropPrefab).name);
			}
			return false;
		}

		private static ItemData? FindEquippedBackpack(Player player)
		{
			Inventory obj = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			List<ItemData> list = ((obj != null) ? obj.GetEquippedItems() : null);
			if (list == null || list.Count == 0)
			{
				return null;
			}
			for (int i = 0; i < list.Count; i++)
			{
				ItemData val = list[i];
				if (val != null && IsBackpackItem(val))
				{
					return val;
				}
			}
			return null;
		}

		[HarmonyPatch(typeof(Player), "UpdateModifiers")]
		[HarmonyPostfix]
		private static void UpdateModifiers_Postfix(Player __instance)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || Player.s_equipmentModifierSourceFields == null || IsBackpackItem(((Humanoid)__instance).m_shoulderItem))
			{
				return;
			}
			ItemData val = FindEquippedBackpack(__instance);
			if (val != null)
			{
				for (int i = 0; i < __instance.m_equipmentModifierValues.Length; i++)
				{
					__instance.m_equipmentModifierValues[i] += (float)Player.s_equipmentModifierSourceFields[i].GetValue(val.m_shared);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetBodyArmor")]
		[HarmonyPostfix]
		private static void GetBodyArmor_Postfix(Player __instance, ref float __result)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !IsBackpackItem(((Humanoid)__instance).m_shoulderItem))
			{
				ItemData val = FindEquippedBackpack(__instance);
				if (val != null)
				{
					__result += val.GetArmor();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "ApplyArmorDamageMods")]
		[HarmonyPostfix]
		private static void ApplyArmorDamageMods_Postfix(Player __instance, ref DamageModifiers mods)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !IsBackpackItem(((Humanoid)__instance).m_shoulderItem))
			{
				ItemData val = FindEquippedBackpack(__instance);
				if (val != null)
				{
					((DamageModifiers)(ref mods)).Apply(val.m_shared.m_damageModifiers);
				}
			}
		}

		[HarmonyPatch("AdventureBackpacks.Extensions.PlayerExtensions, AdventureBackpacks", "IsBackpackEquipped")]
		[HarmonyPostfix]
		public static void AdvBackpackIsBackpackEquipped(ref bool __result)
		{
			if (!__result)
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() != null)
				{
					__result = FindEquippedBackpack(localPlayer) != null;
				}
			}
		}

		[HarmonyPatch("AdventureBackpacks.Extensions.PlayerExtensions, AdventureBackpacks", "IsThisBackpackEquipped")]
		[HarmonyPostfix]
		public static void AdvBackpackIsThisBackpackEquipped(ref bool __result, ref ItemData itemData)
		{
			if (__result)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() != null && IsBackpackItem(itemData))
			{
				List<ItemData> equippedItems = ((Humanoid)localPlayer).GetInventory().GetEquippedItems();
				if (equippedItems != null)
				{
					__result = equippedItems.Contains(itemData);
				}
			}
		}

		[HarmonyPatch("AdventureBackpacks.Extensions.PlayerExtensions, AdventureBackpacks", "GetEquippedBackpack")]
		[HarmonyPrefix]
		public static void AdvBackpackGetEquippedBackpackPrefix(Player player, ref ItemData __state)
		{
			if ((Object)(object)player == (Object)null || ((Humanoid)player).GetInventory() == null)
			{
				return;
			}
			__state = ((Humanoid)player).m_shoulderItem;
			if (!IsBackpackItem(((Humanoid)player).m_shoulderItem))
			{
				ItemData val = FindEquippedBackpack(player);
				if (val != null)
				{
					((Humanoid)player).m_shoulderItem = val;
				}
			}
		}

		[HarmonyPatch("AdventureBackpacks.Extensions.PlayerExtensions, AdventureBackpacks", "GetEquippedBackpack")]
		[HarmonyPostfix]
		public static void AdvBackpackGetEquippedBackpackPostfix(Player player, ItemData __state)
		{
			if (!((Object)(object)player == (Object)null))
			{
				((Humanoid)player).m_shoulderItem = __state;
			}
		}

		[HarmonyPatch("AdventureBackpacks.Patches.HumanoidPatches+HumanoidUnequipItemPatch, AdventureBackpacks", "Prefix")]
		[HarmonyPrefix]
		public static void AdventureBackpackHumanoidUnequipItemPatchPrefix(ref ItemData __state)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() != null)
			{
				__state = ((Humanoid)localPlayer).m_shoulderItem;
				ItemData val = FindEquippedBackpack(localPlayer);
				if (val != null)
				{
					((Humanoid)localPlayer).m_shoulderItem = val;
				}
			}
		}

		[HarmonyPatch("AdventureBackpacks.Patches.HumanoidPatches+HumanoidUnequipItemPatch, AdventureBackpacks", "Prefix")]
		[HarmonyPostfix]
		public static void AdventureBackpackHumanoidUnequipItemPatchPostfix(ref ItemData __state)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() != null)
			{
				((Humanoid)localPlayer).m_shoulderItem = __state;
			}
		}
	}
	internal static class BoneReorder
	{
		[SpecialName]
		public sealed class <G>$9806D19F54634073CCA3670AE93A4ABD
		{
			[SpecialName]
			public static class <M>$9EEFCF9EF40DEFB87736ECA55DA7FCD7
			{
			}

			[ExtensionMarker("<M>$9EEFCF9EF40DEFB87736ECA55DA7FCD7")]
			private void SetBones(string[] boneNames, Transform skeletonRoot)
			{
				throw null;
			}

			[ExtensionMarker("<M>$9EEFCF9EF40DEFB87736ECA55DA7FCD7")]
			private string[] GetBoneNames()
			{
				throw null;
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetLegEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_legItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_legItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetHelmetEquiped(VisEquipment __instance, int hash, int hairHash, ref bool __result)
		{
			if (__result && (Object)(object)__instance.m_helmetItemInstance != (Object)null)
			{
				ReorderBones(__instance, hash, new List<GameObject>(1) { __instance.m_helmetItemInstance });
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetChestEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_chestItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_chestItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetShoulderEquiped(VisEquipment __instance, int hash, int variant, ref bool __result)
		{
			if (__result && __instance.m_shoulderItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_shoulderItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetUtilityEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetUtilityEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_utilityItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_utilityItemInstances);
			}
		}

		internal static void ReorderBones(VisEquipment visEquipment, int itemPrefabHash, List<GameObject> instancesToFix)
		{
			if (!((Object)(object)visEquipment != (Object)null))
			{
				return;
			}
			try
			{
				Transform val = ((Component)visEquipment).transform.Find("Visual/Armature/Hips");
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(itemPrefabHash);
				if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)itemPrefab))
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)$"Prefab missing components. Skipping {itemPrefab} {val}");
					return;
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Reordering bones");
				int childCount = itemPrefab.transform.childCount;
				int num = 0;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = itemPrefab.transform.GetChild(i);
					if (((Object)child).name.StartsWith("attach_skin"))
					{
						int num2 = 0;
						SkinnedMeshRenderer[] componentsInChildren = instancesToFix[num].GetComponentsInChildren<SkinnedMeshRenderer>(true);
						SkinnedMeshRenderer[] componentsInChildren2 = ((Component)child).GetComponentsInChildren<SkinnedMeshRenderer>(true);
						foreach (SkinnedMeshRenderer skinnedMeshRenderer in componentsInChildren2)
						{
							componentsInChildren[num2].SetBones(skinnedMeshRenderer.GetBoneNames(), val);
							num2++;
						}
						num++;
					}
				}
			}
			catch (Exception arg)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"Exception caught while reordering bones: {arg}");
			}
		}

		private static void SetBones(this SkinnedMeshRenderer skinnedMeshRenderer, string[] boneNames, Transform skeletonRoot)
		{
			Transform[] array = (Transform[])(object)new Transform[skinnedMeshRenderer.bones.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = FindInChildren(skeletonRoot, boneNames[i]);
			}
			skinnedMeshRenderer.bones = array;
			skinnedMeshRenderer.rootBone = skeletonRoot;
		}

		private static string[] GetBoneNames(this SkinnedMeshRenderer skinnedMeshRenderer)
		{
			List<string> list = new List<string>();
			Transform[] bones = skinnedMeshRenderer.bones;
			foreach (Transform val in bones)
			{
				list.Add(((Object)val).name);
			}
			return list.ToArray();
		}

		private static Transform FindInChildren(Transform transform, string name)
		{
			if (((Object)transform).name == name)
			{
				return transform;
			}
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform val = FindInChildren(transform.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
}
namespace AzuEPI.Game.CLI
{
	[HarmonyPatch(typeof(Terminal), "InitTerminal")]
	internal static class TerminalInitTerminalPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Predicate<ItemData> <>9__0_7;

			public static ConsoleEvent <>9__0_0;

			public static ConsoleEvent <>9__0_1;

			public static Func<ItemData, bool> <>9__0_8;

			public static ConsoleEvent <>9__0_2;

			public static ConsoleEvent <>9__0_3;

			public static ConsoleEvent <>9__0_4;

			public static ConsoleEvent <>9__0_5;

			public static ConsoleEvent <>9__0_6;

			internal void <Postfix>b__0_0(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
					return;
				}
				((Humanoid)Player.m_localPlayer).GetInventory().m_inventory.RemoveAll((ItemData x) => x != null);
			}

			internal bool <Postfix>b__0_7(ItemData x)
			{
				return x != null;
			}

			internal void <Postfix>b__0_1(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
				}
				else
				{
					InventoryHealth.InventoryFix();
				}
			}

			internal void <Postfix>b__0_2(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
					return;
				}
				foreach (ItemData item in ((Humanoid)Player.m_localPlayer).GetInventory().m_inventory.Where((ItemData itemData) => itemData.m_equipped && itemData.m_shared.m_useDurability))
				{
					item.m_durability = 0f;
				}
			}

			internal bool <Postfix>b__0_8(ItemData itemData)
			{
				if (itemData.m_equipped)
				{
					return itemData.m_shared.m_useDurability;
				}
				return false;
			}

			internal void <Postfix>b__0_3(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
					return;
				}
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				for (int num = inventory.m_inventory.Count - 1; num >= 0; num--)
				{
					ItemData val = inventory.m_inventory[num];
					((Humanoid)Player.m_localPlayer).DropItem(inventory, val, val.m_stack);
				}
			}

			internal void <Postfix>b__0_4(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
					return;
				}
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"inv: {inventory.m_name}, ({inventory.m_width}, {inventory.m_height})");
				args.Context.AddString($"inv: {inventory.m_name}, ({inventory.m_width}, {inventory.m_height})");
				foreach (ItemData item in inventory.m_inventory)
				{
					string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : "");
					args.Context.AddString($"{text} [{item.m_shared.m_name}] ({item.m_gridPos.x}, {item.m_gridPos.y})");
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"- {text} [{item.m_shared.m_name}] ({item.m_gridPos.x}, {item.m_gridPos.y})");
				}
			}

			internal void <Postfix>b__0_5(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
				}
				else if (!<Postfix>g__HaveRepairableItems|0_9())
				{
					args.Context.AddString("No items to repair");
					((Character)Player.m_localPlayer).Message((MessageType)2, "No items to repair", 0, (Sprite)null);
				}
				else
				{
					while (<Postfix>g__HaveRepairableItems|0_9())
					{
						<Postfix>g__RepairItems|0_11();
					}
				}
			}

			internal void <Postfix>b__0_6(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player found, please make sure you're in-game");
					return;
				}
				if (API.GetAddedRows(((Humanoid)Player.m_localPlayer).GetInventory().GetWidth()) == 0)
				{
					args.Context.AddString("You don't have any extra rows added");
					return;
				}
				if (((Humanoid)Player.m_localPlayer).GetInventory().IsEquipmentSlotFree(out var which))
				{
					args.Context.AddString($"You have a free equipment slot at index {which}");
				}
				else
				{
					args.Context.AddString("You don't have any free equipment slots");
				}
				if (((Humanoid)Player.m_localPlayer).GetInventory().IsQuickSlotFree(out var which2))
				{
					args.Context.AddString($"You have a free quickslot at index {which2}");
				}
				else
				{
					args.Context.AddString("You don't have any free quickslots");
				}
			}
		}

		private static void Postfix(Terminal __instance)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
					}
					else
					{
						((Humanoid)Player.m_localPlayer).GetInventory().m_inventory.RemoveAll((ItemData x) => x != null);
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("azuepi.removeall", "Removes all items from your inventory", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				ConsoleEvent val2 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
					}
					else
					{
						InventoryHealth.InventoryFix();
					}
				};
				<>c.<>9__0_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("azuepi.quickfix", "Fixes the inventory if something is wrong with it", (ConsoleEvent)obj2, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj3 = <>c.<>9__0_2;
			if (obj3 == null)
			{
				ConsoleEvent val3 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
						return;
					}
					foreach (ItemData item in ((Humanoid)Player.m_localPlayer).GetInventory().m_inventory.Where((ItemData itemData) => itemData.m_equipped && itemData.m_shared.m_useDurability))
					{
						item.m_durability = 0f;
					}
				};
				<>c.<>9__0_2 = val3;
				obj3 = (object)val3;
			}
			new ConsoleCommand("azuepi.breakall", "Break all the equipment in your inventory", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj4 = <>c.<>9__0_3;
			if (obj4 == null)
			{
				ConsoleEvent val4 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
					}
					else
					{
						Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
						for (int num = inventory.m_inventory.Count - 1; num >= 0; num--)
						{
							ItemData val8 = inventory.m_inventory[num];
							((Humanoid)Player.m_localPlayer).DropItem(inventory, val8, val8.m_stack);
						}
					}
				};
				<>c.<>9__0_3 = val4;
				obj4 = (object)val4;
			}
			new ConsoleCommand("azuepi.dropall", "Drop every item in your inventory to the ground", (ConsoleEvent)obj4, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj5 = <>c.<>9__0_4;
			if (obj5 == null)
			{
				ConsoleEvent val5 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
						return;
					}
					Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"inv: {inventory.m_name}, ({inventory.m_width}, {inventory.m_height})");
					args.Context.AddString($"inv: {inventory.m_name}, ({inventory.m_width}, {inventory.m_height})");
					foreach (ItemData item2 in inventory.m_inventory)
					{
						string text = (((Object)(object)item2.m_dropPrefab != (Object)null) ? ((Object)item2.m_dropPrefab).name : "");
						args.Context.AddString($"{text} [{item2.m_shared.m_name}] ({item2.m_gridPos.x}, {item2.m_gridPos.y})");
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"- {text} [{item2.m_shared.m_name}] ({item2.m_gridPos.x}, {item2.m_gridPos.y})");
					}
				};
				<>c.<>9__0_4 = val5;
				obj5 = (object)val5;
			}
			new ConsoleCommand("azuepi.invlistall", "List every item in your inventory (will be printed to the console)", (ConsoleEvent)obj5, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj6 = <>c.<>9__0_5;
			if (obj6 == null)
			{
				ConsoleEvent val6 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
					}
					else if (!HaveRepairableItems())
					{
						args.Context.AddString("No items to repair");
						((Character)Player.m_localPlayer).Message((MessageType)2, "No items to repair", 0, (Sprite)null);
					}
					else
					{
						while (HaveRepairableItems())
						{
							RepairItems();
						}
					}
				};
				<>c.<>9__0_5 = val6;
				obj6 = (object)val6;
			}
			new ConsoleCommand("azuepi.repairall", "Repair all items in your inventory", (ConsoleEvent)obj6, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj7 = <>c.<>9__0_6;
			if (obj7 == null)
			{
				ConsoleEvent val7 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player found, please make sure you're in-game");
					}
					else if (API.GetAddedRows(((Humanoid)Player.m_localPlayer).GetInventory().GetWidth()) == 0)
					{
						args.Context.AddString("You don't have any extra rows added");
					}
					else
					{
						if (((Humanoid)Player.m_localPlayer).GetInventory().IsEquipmentSlotFree(out var which))
						{
							args.Context.AddString($"You have a free equipment slot at index {which}");
						}
						else
						{
							args.Context.AddString("You don't have any free equipment slots");
						}
						if (((Humanoid)Player.m_localPlayer).GetInventory().IsQuickSlotFree(out var which2))
						{
							args.Context.AddString($"You have a free quickslot at index {which2}");
						}
						else
						{
							args.Context.AddString("You don't have any free quickslots");
						}
					}
				};
				<>c.<>9__0_6 = val7;
				obj7 = (object)val7;
			}
			new ConsoleCommand("azuepi.slotsfree", "List", (ConsoleEvent)obj7, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			static bool CanRepairItems(ItemData item)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null || !item.m_shared.m_canBeReparied)
				{
					return false;
				}
				if (!Player.m_localPlayer.NoCostCheat())
				{
					return true;
				}
				return true;
			}
			static bool HaveRepairableItems()
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return false;
				}
				InventoryGui.instance.m_tempWornItems.Clear();
				((Humanoid)Player.m_localPlayer).GetInventory().GetWornItems(InventoryGui.instance.m_tempWornItems);
				foreach (ItemData tempWornItem in InventoryGui.instance.m_tempWornItems)
				{
					if (CanRepairItems(tempWornItem))
					{
						return true;
					}
				}
				return false;
			}
			static void RepairItems()
			{
				InventoryGui.instance.m_tempWornItems.Clear();
				((Humanoid)Player.m_localPlayer).GetInventory().GetWornItems(InventoryGui.instance.m_tempWornItems);
				for (int i = 0; i < InventoryGui.instance.m_tempWornItems.Count; i++)
				{
					ItemData val8 = InventoryGui.instance.m_tempWornItems[i];
					if (CanRepairItems(val8))
					{
						val8.m_durability = val8.GetMaxDurability();
						((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$msg_repaired", new string[1] { val8.m_shared.m_name }), 0, (Sprite)null);
						return;
					}
				}
				((Character)Player.m_localPlayer).Message((MessageType)2, "No more items to repair", 0, (Sprite)null);
			}
		}

		[CompilerGenerated]
		internal static bool <Postfix>g__HaveRepairableItems|0_9()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			InventoryGui.instance.m_tempWornItems.Clear();
			((Humanoid)Player.m_localPlayer).GetInventory().GetWornItems(InventoryGui.instance.m_tempWornItems);
			foreach (ItemData tempWornItem in InventoryGui.instance.m_tempWornItems)
			{
				if (<Postfix>g__CanRepairItems|0_10(tempWornItem))
				{
					return true;
				}
			}
			return false;
		}

		[CompilerGenerated]
		internal static bool <Postfix>g__CanRepairItems|0_10(ItemData item)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || !item.m_shared.m_canBeReparied)
			{
				return false;
			}
			if (!Player.m_localPlayer.NoCostCheat())
			{
				return true;
			}
			return true;
		}

		[CompilerGenerated]
		internal static void <Postfix>g__RepairItems|0_11()
		{
			InventoryGui.instance.m_tempWornItems.Clear();
			((Humanoid)Player.m_localPlayer).GetInventory().GetWornItems(InventoryGui.instance.m_tempWornItems);
			for (int i = 0; i < InventoryGui.instance.m_tempWornItems.Count; i++)
			{
				ItemData val = InventoryGui.instance.m_tempWornItems[i];
				if (<Postfix>g__CanRepairItems|0_10(val))
				{
					val.m_durability = val.GetMaxDurability();
					((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$msg_repaired", new string[1] { val.m_shared.m_name }), 0, (Sprite)null);
					return;
				}
			}
			((Character)Player.m_localPlayer).Message((MessageType)2, "No more items to repair", 0, (Sprite)null);
		}
	}
}
namespace AzuEPI.Core.Utilities
{
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("AzuExtendedPlayerInventory_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_AzuEPI_Version);
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("2.4.2");
			peer.m_rpc.Invoke("AzuExtendedPlayerInventory_VersionCheck", new object[1] { val });
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent version or couldn't due to previous disconnect, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}

		private static void Postfix(ZNet __instance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "AzuExtendedPlayerInventoryRequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf)
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + AzuExtendedPlayerInventoryPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_AzuEPI_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Version check, local: 2.4.2,  remote: " + text));
			if (text != "2.4.2")
			{
				AzuExtendedPlayerInventoryPlugin.ConnectionError = "AzuExtendedPlayerInventory Installed: 2.4.2\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)"Received same version from server!");
			}
			else
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
}
namespace AzuEPI.Core.Utilities.Extensions
{
	public static class GameObjectHelper
	{
		[SpecialName]
		public sealed class <G>$5E80EE1F91F68F4C0C8D9D82C38C5E67
		{
			[SpecialName]
			public static class <M>$DA8EECEBA43A0DEF5767F437FCA1FFA2
			{
			}

			[SpecialName]
			public static class <M>$B19F2D72F932C27F9E5DA9870E91F098
			{
			}

			[ExtensionMarker("<M>$DA8EECEBA43A0DEF5767F437FCA1FFA2")]
			public GameObject WithActive(bool active)
			{
				throw null;
			}

			[ExtensionMarker("<M>$DA8EECEBA43A0DEF5767F437FCA1FFA2")]
			public GameObject WithParent(Transform parent, bool worldPositionStays = true)
			{
				throw null;
			}

			[ExtensionMarker("<M>$DA8EECEBA43A0DEF5767F437FCA1FFA2")]
			public GameObject WithSiblingIndex(int index)
			{
				throw null;
			}

			[ExtensionMarker("<M>$DA8EECEBA43A0DEF5767F437FCA1FFA2")]
			public void SafeSetActive(bool active)
			{
				throw null;
			}

			[ExtensionMarker("<M>$B19F2D72F932C27F9E5DA9870E91F098")]
			public void SetLayerForEntireHierarchy(int layer, int depth = 0)
			{
				throw null;
			}

			[ExtensionMarker("<M>$B19F2D72F932C27F9E5DA9870E91F098")]
			public bool HasChildWithNameThatContains(string name)
			{
				throw null;
			}

			[ExtensionMarker("<M>$B19F2D72F932C27F9E5DA9870E91F098")]
			public List<Transform> GetAllChildTransforms()
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static GameObject CreateWithComponents(string name, params Type[] components)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			return new GameObject(name, components);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static GameObject CreateUIObject(string name, params Type[] additionalComponents)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Type[] array = new Type[additionalComponents.Length + 1];
			array[0] = typeof(RectTransform);
			Array.Copy(additionalComponents, 0, array, 1, additionalComponents.Length);
			return new GameObject(name, array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static GameObject WithActive(this GameObject go, bool active)
		{
			go.SetActive(active);
			return go;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static GameObject WithParent(this GameObject go, Transform parent, bool worldPositionStays = true)
		{
			go.transform.SetParent(parent, worldPositionStays);
			return go;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static GameObject WithSiblingIndex(this GameObject go, int index)
		{
			go.transform.SetSiblingIndex(index);
			return go;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void SafeSetActive(this GameObject go, bool active)
		{
			if (Object.op_Implicit((Object)(object)go))
			{
				go.SetActive(active);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void SafeSetActive(this Transform transform, bool active)
		{
			if (Object.op_Implicit((Object)(object)transform))
			{
				((Component)transform).gameObject.SetActive(active);
			}
		}

		public static void SetLayerForEntireHierarchy(this GameObject gameObject, int layer, int depth = 0)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (depth >= 50)
			{
				return;
			}
			gameObject.layer = layer;
			foreach (Transform item in gameObject.transform)
			{
				((Component)item).gameObject.SetLayerForEntireHierarchy(layer, depth + 1);
			}
		}

		public static bool HasChildWithNameThatContains(this GameObject gameObject, string name)
		{
			return gameObject.GetAllChildTransforms().Any((Transform child) => ((Object)child).name.Contains(name));
		}

		public static List<Transform> GetAllChildTransforms(this GameObject gameObject)
		{
			return _GetAllChildTransforms(gameObject, isRoot: true);
		}

		private static List<Transform> _GetAllChildTransforms(GameObject gameObject, bool isRoot = false, List<Transform>? transforms = null)
		{
			transforms = transforms ?? new List<Transform>();
			if (!isRoot)
			{
				transforms.Add(gameObject.transform);
			}
			for (int i = 0; i < gameObject.transform.childCount; i++)
			{
				_GetAllChildTransforms(((Component)gameObject.transform.GetChild(i)).gameObject, isRoot: false, transforms);
			}
			return transforms;
		}
	}
	public static class LoggerExtensions
	{
		public static void LogInfoDebug(this ManualLogSource logger, string message)
		{
		}

		public static void LogWarningDebug(this ManualLogSource logger, string message)
		{
		}

		public static void LogErrorDebug(this ManualLogSource logger, string message)
		{
		}

		public static void LogDebugDebug(this ManualLogSource logger, string message)
		{
		}
	}
	public static class RectTransformExtensions
	{
		[SpecialName]
		public sealed class <G>$D50C47355EFA71DA0F6DB3230FE5D4AD
		{
			[SpecialName]
			public static class <M>$D21D881CC545AA59CF6F25908DA2C4D5
			{
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithAnchoredPosition(Vector2 position)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithAnchors(Vector2 min, Vector2 max)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithAnchorMin(Vector2 min)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithAnchorMax(Vector2 max)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithPivot(Vector2 pivot)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithSizeDelta(Vector2 sizeDelta)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithOffsetMin(Vector2 offsetMin)
			{
				throw null;
			}

			[ExtensionMarker("<M>$D21D881CC545AA59CF6F25908DA2C4D5")]
			public RectTransform WithOffsetMax(Vector2 offsetMax)
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithAnchoredPosition(this RectTransform rt, Vector2 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.anchoredPosition = position;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithAnchors(this RectTransform rt, Vector2 min, Vector2 max)
		{
			//IL_0001: 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)
			rt.anchorMin = min;
			rt.anchorMax = max;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithAnchorMin(this RectTransform rt, Vector2 min)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = min;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithAnchorMax(this RectTransform rt, Vector2 max)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMax = max;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithPivot(this RectTransform rt, Vector2 pivot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.pivot = pivot;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithSizeDelta(this RectTransform rt, Vector2 sizeDelta)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.sizeDelta = sizeDelta;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithOffsetMin(this RectTransform rt, Vector2 offsetMin)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.offsetMin = offsetMin;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RectTransform WithOffsetMax(this RectTransform rt, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rt.offsetMax = offsetMax;
			return rt;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T GetOrAddComponent<T>(this GameObject go) where T : Component
		{
			return go.GetComponent<T>() ?? go.AddComponent<T>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T GetOrAddComponent<T>(this Component component) where T : Component
		{
			return component.gameObject.GetOrAddComponent<T>();
		}
	}
}
namespace AzuEPI.Core.Text
{
	public static class Formatting
	{
		private static readonly string[] wbSuffixes = new string[4] { "", "k", "m", "b" };

		internal static string FormatNumberSimpleNoDecimal(float number)
		{
			CalculateShortNumberAndSuffix(number, out double shortNumber, out string suffix);
			return shortNumber.ToString("N0", CultureInfo.InvariantCulture) + suffix;
		}

		private static void CalculateShortNumberAndSuffix(float number, out double shortNumber, out string suffix)
		{
			int val = (int)(Math.Log10(number) / 3.0);
			val = Math.Min(wbSuffixes.Length - 1, val);
			double num = Math.Pow(10.0, val * 3);
			shortNumber = (double)number / num;
			suffix = wbSuffixes[val];
		}
	}
	public class SlotText
	{
		public static void Set(string value, Transform transform)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			Transform val = transform.Find("binding");
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = Object.Instantiate<Transform>(ExtendedPlayerInventory._elementPrefab.transform.Find("binding"), transform);
			}
			RectTransform rt = default(RectTransform);
			if (((Component)val).TryGetComponent<RectTransform>(ref rt))
			{
				rt.WithAnchorMin(Vector2.zero).WithAnchorMax(Vector2.one).WithOffsetMin(Vector2.zero)
					.WithOffsetMax(Vector2.zero)
					.WithSizeDelta(Vector2.zero)
					.WithAnchoredPosition(Vector2.zero);
				TMP_Text component = ((Component)val).GetComponent<TMP_Text>();
				((Behaviour)component).enabled = true;
				component.overflowMode = (TextOverflowModes)0;
				component.textWrappingMode = (TextWrappingModes)1;
				component.fontSizeMin = 10f;
				component.fontSizeMax = 14f;
				component.enableAutoSizing = true;
				component.text = value;
				component.horizontalAlignment = (HorizontalAlignmentOptions)2;
				component.verticalAlignment = (VerticalAlignmentOptions)256;
			}
		}
	}
}
namespace AzuEPI.Core.Slots
{
	internal static class EpiDropRouter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool ValidatePlannedDrop(InventoryGrid grid, Inventory fromInventory, ItemData dragged, int draggedAmount, Vector2i destPos)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || dragged == null || fromInventory == null || !Object.op_Implicit((Object)(object)grid))
				{
					return true;
				}
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (inventory == null)
				{
					return true;
				}
				bool flag = inventory == fromInventory;
				bool flag2 = inventory == grid.m_inventory;
				if (flag && !flag2)
				{
					if (!TryResolveSlot(inventory, dragged.m_gridPos, out var slotIndex, out var desc))
					{
						return true;
					}
					ItemData itemAt = grid.m_inventory.GetItemAt(destPos.x, destPos.y);
					if (itemAt == null)
					{
						return true;
					}
					if (!WillVanillaSwap(dragged, draggedAmount, itemAt))
					{
						return true;
					}
					if (API.SlotValidates(slotIndex, itemAt))
					{
						return true;
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Blocked drop to container: '" + itemAt.m_shared.m_name + "' cannot swap back to EPI slot '" + desc.OriginalName + "'."));
					return false;
				}
				if (!flag || !flag2)
				{
					return true;
				}
				if (dragged.m_gridPos == destPos)
				{
					return true;
				}
				int slotIndex2;
				SlotDescriptor desc2;
				bool flag3 = TryResolveSlot(inventory, dragged.m_gridPos, out slotIndex2, out desc2);
				int slotIndex3;
				SlotDescriptor desc3;
				bool flag4 = TryResolveSlot(inventory, destPos, out slotIndex3, out desc3);
				if (!flag3 && !flag4)
				{
					return true;
				}
				ItemData itemAt2 = inventory.GetItemAt(destPos.x, destPos.y);
				if (flag4 && !API.SlotValidates(slotIndex3, dragged))
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Blocked drop of '" + dragged.m_shared.m_name + "' into slot '" + desc3.OriginalName + "' (invalid for slot)."));
					return false;
				}
				if (itemAt2 == null || !WillVanillaSwap(dragged, draggedAmount, itemAt2))
				{
					return true;
				}
				if (flag4 && flag3)
				{
					if (API.SlotValidates(slotIndex2, itemAt2))
					{
						return true;
					}
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Blocked swap: '" + itemAt2.m_shared.m_name + "' in slot '" + desc3.OriginalName + "' cannot relocate to source slot '" + desc2.OriginalName + "'."));
					return false;
				}
				if (flag4 || !flag3)
				{
					return true;
				}
				if (API.SlotValidates(slotIndex2, itemAt2))
				{
					return true;
				}
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("Blocked swap: '" + itemAt2.m_shared.m_name + "' at " + DescribeSlotOrPos(in desc3, destPos, flag4) + " cannot swap into source slot '" + desc2.OriginalName + "'."));
				return false;
			}
			catch (Exception arg)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)$"EpiDropRouter.ValidatePlannedDrop: {arg}");
				return true;
			}
		}

		private static bool TryResolveSlot(Inventory playerInv, Vector2i gridPos, out int slotIndex, out SlotDescriptor desc)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			slotIndex = -1;
			desc = default(SlotDescriptor);
			if (API.TryGetSlotIndexAtGridPos(playerInv, gridPos, out slotIndex))
			{
				return API.TryGetSlotDescriptor(slotIndex, out desc);
			}
			return false;
		}

		private static bool WillVanillaSwap(ItemData dragged, int amount, ItemData dest)
		{
			if (dest == null)
			{
				return false;
			}
			if (amount > 0 && dragged.m_stack != amount)
			{
				return false;
			}
			bool num = dest.m_shared.m_name == dragged.m_shared.m_name;
			bool flag = dragged.m_shared.m_maxQuality <= 1 || dest.m_quality == dragged.m_quality;
			bool flag2 = dest.m_shared.m_maxStackSize != 1;
			return !(num && flag && flag2);
		}

		private static string DescribeSlotOrPos(in SlotDescriptor desc, Vector2i pos, bool hasSlot)
		{
			//IL_0008: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!hasSlot)
			{
				return $"grid({pos.x},{pos.y})";
			}
			if (desc.IsEquipmentSlot)
			{
				return "equipment '" + desc.OriginalName + "'";
			}
			if (!desc.IsQuickSlot)
			{
				return $"{desc.OriginalName} @ ({pos.x},{pos.y})";
			}
			return "quickslot '" + desc.OriginalName + "'";
		}
	}
	public static class Initializers
	{
		private const int MaxQuickSlots = 8;

		private static bool _hotkeysInitialized;

		public static void InitSlotsAndKeys()
		{
			InitializeBuiltInSlots();
			InitializeHotkeys();
			InitializeQuickslots();
		}

		public static void InitializeBuiltInSlots()
		{
			ExtendedPlayerInventory.slots.Add(new Model.EquipmentSlot
			{
				Name = AzuExtendedPlayerInventoryPlugin.HelmetText.Value,
				OriginalName = "$azu_epi_helmet",
				IsQuickSlot = false,
				Get = (Player player) => ((Humanoid)player).m_helmetItem,
				Valid = (ItemData item) => item != null && (int)item.m_shared.m_itemType == 6 && !SlotAcceptRules.HasDedicatedAPISlot(item)
			});
			ExtendedPlayerInventory.slots.Add(new Model.EquipmentSlot
			{
				Name = AzuExtendedPlayerInventoryPlugin.ChestText.Value,
				OriginalName = "$azu_epi_chest",
				IsQuickSlot = false,
				Get = (Player player) => ((Humanoid)player).m_chestItem,
				Valid = (ItemData item) => item != null && (int)item.m_shared.m_itemType == 7 && !SlotAcceptRules.HasDedicatedAPISlot(item)
			});
			ExtendedPlayerInventory.slots.Add(new Model.EquipmentSlot
			{
				Name = AzuExtendedPlayerInventoryPlugin.LegsText.Value,
				OriginalName = "$azu_epi_legs",
				IsQuickSlot = false,
				Get = (Player player) => ((Humanoid)player).m_legItem,
				Valid = (ItemData item) => item != null && (int)item.m_shared.m_itemType == 11 && !SlotAcceptRules.HasDedicatedAPISlot(item)
			});
			ExtendedPlayerInventory.slots.Add(new Model.EquipmentSlot
			{
				Name = AzuExtendedPlayerInventoryPlugin.BackText.Value,
				OriginalName = "$azu_epi_shoulder",
				IsQuickSlot = false,
				Get = delegate(Player player)
				{
					ItemData shoulderItem = ((Humanoid)player).m_shoulderItem;
					if (shoulderItem != null && SlotAcceptRules.HasDedicatedAPISlot(shoulderItem))
					{
						Inventory inventory = ((Humanoid)player).GetInventory();
						if (inventory == null)
						{
							return (ItemData?)null;
						}
						return inventory.GetEquippedItems()?.FirstOrDefault((Func<ItemData, bool>)((ItemData i) => i != null && i != shoulderItem && (int)i.m_shared.m_itemType == 17 && !SlotAcceptRules.HasDedicatedAPISlot(i)));
					}
					return shoulderItem;
				},
				Valid = (ItemData item) => item != null && (int)item.m_shared.m_itemType == 17 && !SlotAcceptRules.HasDedicatedAPISlot(item)
			});
			ExtendedPlayerInventory.slots.Add(new Model.EquipmentSlot
			{
				Name = AzuExtendedPlayerInventoryPlugin.UtilityText.Value,
				OriginalName = "$azu_epi_utility",
				IsQuickSlot = false,
				Get = delegate(Player player)
				{
					ItemData utilityItem = ((Humanoid)player).m_utilityItem;
					if (utilityItem != null && SlotAcceptRules.HasDedicatedAPISlot(utilityItem))
					{
						Inventory inventory = ((Humanoid)player).GetInventory();
						if (inventory == null)
						{
							return (ItemData?)null;
						}
						return inventory.GetEquippedItems()?.FirstOrDefault((Func<ItemData, bool>)((ItemData i) => i != null && i != utilityItem && (int)i.m_shared.m_itemType == 18 && !SlotAcceptRules.HasDedicatedAPISlot(i)));
					}
					return utilityItem;
				},
				Valid = (ItemData item) => item != null && (int)item.m_shared.m_itemType == 18 && !SlotAcceptRules.HasDedicatedAPISlot(item)
			});
		}

		public static void InitializeQuickslots()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			API.BeforeQuickSlotsAdded();
			int value = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			for (int i = 0; i < value; i++)
			{
				ExtendedPlayerInventory.slots.Add(new Model.Slot
				{
					Name = (Utility.IsNullOrWhiteSpace(AzuExtendedPlayerInventoryPlugin.HotkeyTexts[i].Value) ? ((object)AzuExtendedPlayerInventoryPlugin.Hotkeys[i].Value/*cast due to .constrained prefix*/).ToString() : AzuExtendedPlayerInventoryPlugin.HotkeyTexts[i].Value),
					IsQuickSlot = true
				});
			}
			API.QuickSlotsAdded();
		}

		internal static void InitializeHotkeys()
		{
			//IL_0026: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			if (_hotkeysInitialized)
			{
				return;
			}
			_hotkeysInitialized = true;
			KeyboardShortcut[] array = (KeyboardShortcut[])(object)new KeyboardShortcut[8]
			{
				new KeyboardShortcut((KeyCode)122, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)120, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)99, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)118, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)98, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)110, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)49, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }),
				new KeyboardShortcut((KeyCode)50, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 })
			};
			AzuExtendedPlayerInventoryPlugin.Hotkeys = new ConfigEntry<KeyboardShortcut>[8];
			AzuExtendedPlayerInventoryPlugin.HotkeyTexts = new ConfigEntry<string>[8];
			for (int i = 0; i < 8; i++)
			{
				KeyboardShortcut value = array[i];
				AzuExtendedPlayerInventoryPlugin.Hotkeys[i] = AzuExtendedPlayerInventoryPlugin.context.config<KeyboardShortcut>("8 - Quick Slot Hotkeys", $"Hotkey {i + 1}", value, $"Keyboard shortcut for quick slot {i + 1}. See https://docs.unity3d.com/Manual/ConventionalGameInput.html for valid key names.", synchronizedSetting: false);
				AzuExtendedPlayerInventoryPlugin.HotkeyTexts[i] = AzuExtendedPlayerInventoryPlugin.context.config("8 - Quick Slot Hotkeys", $"Hotkey {i + 1} Display Text", "Alt + " + ((object)((KeyboardShortcut)(ref value)).MainKey/*cast due to .constrained prefix*/).ToString().Replace("Alpha", string.Empty), $"Custom text to display for quick slot {i + 1} hotkey on the HUD. Leave blank to auto-generate from the hotkey itself.", synchronizedSetting: false);
				AzuExtendedPlayerInventoryPlugin.HotkeyTexts[i].SettingChanged += delegate
				{
					if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)InventoryGui.instance != (Object)null)
					{
						AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
					}
				};
			}
		}

		internal static void SetupEventHandlers()
		{
			AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			};
			AzuExtendedPlayerInventoryPlugin.ExtraRows.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			};
			AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.SettingChanged += delegate
			{
				EAQ.CheckRandy();
			};
			AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.SettingChanged += delegate
			{
				EAQ.CheckRandy();
				if (Object.op_Implicit((Object)(object)UIBuilder.GlgGo))
				{
					UIBuilder.GlgGo.SetActive(AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value.isOn());
				}
			};
			AzuExtendedPlayerInventoryPlugin.ShowQuickSlots.SettingChanged += delegate
			{
				HotkeyBarController.Hud_Update_Patch.DeselectHotkeyBar();
			};
			AzuExtendedPlayerInventoryPlugin.SelectedPlayerStats.SettingChanged += StatsPanelController.OnStatsConfigChanged;
			AzuExtendedPlayerInventoryPlugin.SelectedLiveStats.SettingChanged += StatsPanelController.OnStatsConfigChanged;
			AzuExtendedPlayerInventoryPlugin.HelmetText.SettingChanged += delegate
			{
				API.RelocalizeSlots();
			};
			AzuExtendedPlayerInventoryPlugin.ChestText.SettingChanged += delegate
			{
				API.RelocalizeSlots();
			};
			AzuExtendedPlayerInventoryPlugin.BackText.SettingChanged += delegate
			{
				API.RelocalizeSlots();
			};
			AzuExtendedPlayerInventoryPlugin.LegsText.SettingChanged += delegate
			{
				API.RelocalizeSlots();
			};
			AzuExtendedPlayerInventoryPlugin.TrinketText.SettingChanged += delegate
			{
				API.RelocalizeSlots();
			};
			AzuExtendedPlayerInventoryPlugin.UtilityText.SettingChanged += delegate
			{
				API.RelocalizeSlots();
			};
			AzuExtendedPlayerInventoryPlugin.QuickSlotsPerRow.SettingChanged += delegate
			{
				if (Object.op_Implicit((Object)(object)Hud.instance))
				{
					Transform val = ((Component)Hud.instance).transform.Find("hudroot");
					if (Object.op_Implicit((Object)(object)val))
					{
						Transform val2 = val.Find("AzuEPI_QuickAccessBar");
						HotkeyBar val3 = default(HotkeyBar);
						if (Object.op_Implicit((Object)(object)val2) && ((Component)val2).TryGetComponent<HotkeyBar>(ref val3))
						{
							foreach (ElementData element in val3.m_elements)
							{
								if (Object.op_Implicit((Object)(object)element.m_go))
								{
									Object.Destroy((Object)(object)element.m_go);
								}
							}
							val3.m_elements.Clear();
							AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
						}
					}
				}
			};
			AzuExtendedPlayerInventoryPlugin.RemovedEquipmentSlots.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.ApplySlotChanges();
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			};
			AzuExtendedPlayerInventoryPlugin.UserAddedSlots.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.ApplySlotChanges();
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			};
			AzuExtendedPlayerInventoryPlugin.WishboneSlot.SettingChanged += delegate
			{
				if (AzuExtendedPlayerInventoryPlugin.WishboneSlot.Value.isOn())
				{
					if (!AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$item_wishbone") && !JewelcraftingCompat.IsWishboneAGem())
					{
						API.AddSlot("$item_wishbone", "Wishbone", 5);
					}
				}
				else
				{
					API.RemoveSlot("$item_wishbone");
					if (Localization.m_instance != null)
					{
						API.RemoveSlot(Localization.m_instance.Localize("$item_wishbone"));
					}
					InventoryHealth.FixHiddenItems();
				}
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			};
			AzuExtendedPlayerInventoryPlugin.WispLightSlot.SettingChanged += delegate
			{
				if (AzuExtendedPlayerInventoryPlugin.WispLightSlot.Value.isOn())
				{
					if (!AzuExtendedPlayerInventoryPlugin.IsSlotMarkedForRemoval("$item_demister") && !JewelcraftingCompat.IsWisplightAGem())
					{
						int index = ((AzuExtendedPlayerInventoryPlugin.WishboneSlot.Value.isOn() && !JewelcraftingCompat.IsWishboneAGem()) ? 6 : 5);
						API.AddSlot("$item_demister", "Demister", index);
					}
				}
				else
				{
					API.RemoveSlot("$item_demister");
					if (Localization.m_instance != null)
					{
						API.RemoveSlot(Localization.m_instance.Localize("$item_demister"));
					}
					InventoryHealth.FixHiddenItems();
				}
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
			};
			AzuExtendedPlayerInventoryPlugin.VanityOption.SettingChanged += delegate
			{
				if (Object.op_Implicit((Object)(object)VanityPanelController.VanityButtonGo))
				{
					((Component)VanityPanelController.VanityButtonGo).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.VanityOption.Value.isOn());
				}
				SlotHelpers.UpdateEquipmentBackgroundAnchors();
			};
			AzuExtendedPlayerInventoryPlugin.LoadoutOption.SettingChanged += delegate
			{
				if (Object.op_Implicit((Object)(object)PersonalLoadoutGui.LoadoutsToggleButton))
				{
					((Component)PersonalLoadoutGui.LoadoutsToggleButton).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.LoadoutOption.Value.isOn());
				}
				SlotHelpers.UpdateEquipmentBackgroundAnchors();
			};
			AzuExtendedPlayerInventoryPlugin.VanityToggleGamepadKey.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.RefreshPanelButtonBindings();
			};
			AzuExtendedPlayerInventoryPlugin.LoadoutToggleGamepadKey.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.RefreshPanelButtonBindings();
			};
			AzuExtendedPlayerInventoryPlugin.StatsToggleGamepadKey.SettingChanged += delegate
			{
				AzuExtendedPlayerInventoryPlugin.RefreshPanelButtonBindings();
			};
			AzuExtendedPlayerInventoryPlugin.OldLayout.SettingChanged += delegate
			{
				SlotHelpers.ResizeSlots();
				Layout.UpdateInventorySize();
				Layout.ApplyLayoutCorrections();
				UIBuilder.RebuildUI();
				AzuExtendedPlayerInventoryPlugin.context.FullRebuild();
				SlotHelpers.UpdateEquipmentBackgroundAnchors();
			};
		}
	}
	internal static class SlotAcceptRules
	{
		public static bool QuickslotAccepts(ItemData item)
		{
			return true;
		}

		public static bool HasDedicatedAPISlot(ItemData item)
		{
			if (item == null)
			{
				return false;
			}
			try
			{
				return ExtendedPlayerInventory.slots.Any((Model.Slot s) => s is Model.EquipmentSlot equipmentSlot && s.IsAPIAdded && !s.IsQuickSlot && equipmentSlot.Valid != null && equipmentSlot.Valid(item));
			}
			catch
			{
				return false;
			}
		}

		public static bool CanItemGoToSlot(Model.Slot slot, ItemData? item)
		{
			if (item == null)
			{
				return true;
			}
			if (slot is Model.EquipmentSlot equipmentSlot && slot.IsAPIAdded && !slot.IsQuickSlot)
			{
				if (equipmentSlot.Valid != null)
				{
					return equipmentSlot.Valid(item);
				}
				return false;
			}
			if (slot is Model.EquipmentSlot equipmentSlot2 && !slot.IsQuickSlot)
			{
				if (equipmentSlot2.Valid != null)
				{
					return equipmentSlot2.Valid(item);
				}
				return false;
			}
			if (slot.IsQuickSlot)
			{
				return QuickslotAccepts(item);
			}
			return true;
		}
	}
	public class SlotHelpers
	{
		internal const int EquipRowsPerColumn = 8;

		private const float LeftOffset = -625f;

		private const float LeftOffsetOld = 650f;

		private const float VerticalOffset = 160f;

		internal static void UpdateEquipmentBackgroundAnchors()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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)
			if (!Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				return;
			}
			Transform val = ((Transform)InventoryGui.instance.m_player).Find("AzuEPI_EquipmentBkg");
			if (Object.op_Implicit((Object)(object)val))
			{
				Vector2 equipmentBackAnchorMax = Layout.GetEquipmentBackAnchorMax();
				if (Chainloader.PluginInfos.TryGetValue("Azumatt.MinimalUI", out var value) && value != null)
				{
					equipmentBackAnchorMax.x += 0.03f;
				}
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				component.anchorMax = equipmentBackAnchorMax;
				if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn() && AzuExtendedPlayerInventoryPlugin.VanityOption.Value.isOff() && AzuExtendedPlayerInventoryPlugin.LoadoutOption.Value.isOff())
				{
					component.offsetMin = new Vector2(0f, 60f);
				}
				else
				{
					component.offsetMin = new Vector2(-10f, -10f);
				}
				if (Object.op_Implicit((Object)(object)InventoryGui.instance.m_playerGrid?.m_gridRoot))
				{
					((Component)InventoryGui.instance.m_playerGrid.m_gridRoot).GetComponent<RectTransform>().anchorMax = equipmentBackAnchorMax;
					((Graphic)((Component)InventoryGui.instance.m_playerGrid.m_gridRoot).GetComponent<Image>()).raycastTarget = false;
				}
			}
		}

		internal static void ResizeSlots()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn())
			{
				int count = ExtendedPlayerInventory.slots.Count;
				int num = count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
				for (int i = 0; i < num; i++)
				{
					int num2 = i % 3;
					int num3 = i / 3;
					float num4 = (float)num2 * -70f;
					float num5 = 650f + (float)num3 * 70f;
					int num6 = (num - 1) % 3;
					bool num7 = num2 > num6;
					int num8 = Math.Max(9 + AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value - count - 1, 0) / 3;
					float num9 = (float)((num7 ? 1 : 0) + num8) * 70f / 2f;
					ExtendedPlayerInventory.slots[i].Position = new Vector2(num5 + num9, num4);
				}
				int num10 = (num + 3 - 1) / 3;
				float num11 = 650f + ((float)num10 + 0.5f) * 70f;
				for (int j = 0; j < AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value; j++)
				{
					int index = num + j;
					int num12 = j / 3;
					int num13 = j % 3;
					float num14 = num11 + (float)num12 * 70f;
					float num15 = (float)num13 * -70f;
					ExtendedPlayerInventory.slots[index].Position = new Vector2(num14, num15);
				}
				return;
			}
			float equipOriginX = Layout.equipOriginX;
			float num16 = Layout.equipOriginX + 70f * (1f + Layout.columnGapTiles);
			float equipOriginY = Layout.equipOriginY;
			int k;
			for (k = 0; k < ExtendedPlayerInventory.slots.Count && ExtendedPlayerInventory.slots[k] is Model.EquipmentSlot; k++)
			{
			}
			Math.Min(8, k);
			Math.Max(0, Math.Min(8, k - 8));
			for (int l = 0; l < k; l++)
			{
				bool num17 = l < 8;
				int num18 = (num17 ? l : (l - 8));
				float num19 = (num17 ? equipOriginX : num16);
				float num20 = equipOriginY - (float)num18 * 70f;
				ExtendedPlayerInventory.slots[l].Position = new Vector2(num19, num20);
			}
			int value = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			int num21 = k;
			if (num21 + value > ExtendedPlayerInventory.slots.Count)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"ResizeSlots: Not enough slots in list. Expected {num21 + value}, but have {ExtendedPlayerInventory.slots.Count}. Skipping quickslot positioning.");
			}
			else
			{
				if (value <= 0)
				{
					return;
				}
				float num22 = num16 - equipOriginX + 70f;
				float num23 = equipOriginY - 420f;
				if (value <= 4)
				{
					float num24 = (float)value * 70f;
					float num25 = equipOriginX + (num22 - num24) * 0.5f;
					float num26 = num23 - 70f;
					for (int m = 0; m < value; m++)
					{
						ExtendedPlayerInventory.slots[num21 + m].Position = new Vector2(num25 + (float)m * 70f, num26);
					}
					return;
				}
				int num27 = Math.Min(value, 4);
				int num28 = value - num27;
				float num29 = (float)num27 * 70f;
				float num30 = (float)num28 * 70f;
				float num31 = equipOriginX + (num22 - num29) * 0.5f;
				float num32 = equipOriginX + (num22 - num30) * 0.5f;
				float num33 = num23 - 70f;
				float num34 = num23;
				for (int n = 0; n < num27; n++)
				{
					ExtendedPlayerInventory.slots[num21 + n].Position = new Vector2(num31 + (float)n * 70f, num34);
				}
				for (int num35 = 0; num35 < num28; num35++)
				{
					ExtendedPlayerInventory.slots[num21 + num27 + num35].Position = new Vector2(num32 + (float)num35 * 70f, num33);
				}
			}
		}
	}
	internal static class SlotOverlays
	{
		private static readonly Dictionary<GameObject, GameObject> InvalidByGo = new Dictionary<GameObject, GameObject>();

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

		private static Sprite? checkSprite;

		private static Sprite? hiddenSprite;

		private static Sprite? hasVanitySprite;

		private const string InvalidRootName = "EPI_InvalidOverlay";

		private const string InvalidSpriteObjectName = "EPI_InvalidOverlayCheck";

		private const string VanityRootName = "EPI_VanityStateOverlay";

		private const string HiddenIconName = "EPI_VanityHidden";

		private const string HasIconName = "EPI_VanityHasVanity";

		private static Sprite? FindSpriteByName(string name)
		{
			return ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite x) => ((Object)x).name == name));
		}

		private static void EnsureSharedSpritesLoaded()
		{
			if (!Object.op_Implicit((Object)(object)checkSprite))
			{
				checkSprite = FindSpriteByName("mapicon_checked");
			}
			if (!Object.op_Implicit((Object)(object)hiddenSprite))
			{
				hiddenSprite = (Object.op_Implicit((Object)(object)checkSprite) ? checkSprite : FindSpriteByName("sneak_hidden"));
			}
			if (!Object.op_Implicit((Object)(object)hasVanitySprite))
			{
				hasVanitySprite = FindSpriteByName("staminaupgrade");
			}
		}

		public static GameObject EnsureInvalidOverlay(GameObject slotGo)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			if (InvalidByGo.TryGetValue(slotGo, out GameObject value) && Object.op_Implicit((Object)(object)value))
			{
				return value;
			}
			EnsureSharedSpritesLoaded();
			RectTransform component = slotGo.GetComponent<RectTransform>();
			GameObject val = new GameObject("EPI_InvalidOverlay", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)component, false);
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			val2.pivot = new Vector2(0.5f, 0.5f);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).raycastTarget = false;
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.95f);
			GameObject val3 = new GameObject("EPI_InvalidOverlayCheck", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			RectTransform val4 = (RectTransform)val3.transform;
			((Transform)val4).SetParent((Transform)(object)val2, false);
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			val4.pivot = new Vector2(0.5f, 0.5f);
			Image component3 = val3.GetComponent<Image>();
			((Graphic)component3).raycastTarget = false;
			component3.sprite = checkSprite;
			val.SetActive(false);
			InvalidByGo[slotGo] = val;
			return val;
		}

		public static void SetInvalidVisible(GameObject slotGo, bool visible)
		{
			if (!InvalidByGo.TryGetValue(slotGo, out GameObject value) || !Object.op_Implicit((Object)(object)value))
			{
				value = EnsureInvalidOverlay(slotGo);
			}
			if (value.activeSelf != visible)
			{
				value.SetActive(visible);
			}
		}

		public static GameObject EnsureVanityStateOverlay(GameObject slotGo)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0127: 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_013c: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_015d: 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_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			if (VanityStateByGo.TryGetValue(slotGo, out GameObject value) && Object.op_Implicit((Object)(object)value))
			{
				return value;
			}
			EnsureSharedSpritesLoaded();
			RectTransform component = slotGo.GetComponent<RectTransform>();
			GameObject val = new GameObject("EPI_VanityStateOverlay", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)component, false);
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			val2.pivot = new Vector2(0.5f, 0.5f);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).raycastTarget = false;
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.7f);
			GameObject val3 = new GameObject("EPI_VanityHidden", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			RectTransform val4 = (RectTransform)val3.transform;
			((Transform)val4).SetParent((Transform)(object)val2, false);
			val4.anchorMin = new Vector2(0.6f, 0f);
			val4.anchorMax = new Vector2(1f, 0.4f);
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			val4.pivot = new Vector2(0.5f, 0.5f);
			Image component3 = val3.GetComponent<Image>();
			((Graphic)component3).raycastTarget = false;
			component3.sprite = hiddenSprite;
			((Behaviour)component3).enabled = false;
			component3.preserveAspect = true;
			GameObject val5 = new GameObject("EPI_VanityHasVanity", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			RectTransform val6 = (RectTransform)val5.transform;
			((Transform)val6).SetParent((Transform)(object)val2, false);
			val6.anchorMin = new Vector2(0.6f, 0f);
			val6.anchorMax = new Vector2(1f, 0.4f);
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			val6.pivot = new Vector2(0.5f, 0.5f);
			Image component4 = val5.GetComponent<Image>();
			((Graphic)component4).raycastTarget = false;
			component4.sprite = hasVanitySprite;
			((Behaviour)component4).enabled = false;
			component4.preserveAspect = true;
			val.SetActive(false);
			VanityStateByGo[slotGo] = val;
			return val;
		}

		public static void SetVanityOverlayVisible(GameObject slotGo, VanityState vs)
		{
			if (Object.op_Implicit((Object)(object)slotGo))
			{
				if (!VanityStateByGo.TryGetValue(slotGo, out GameObject value) || !Object.op_Implicit((Object)(object)value))
				{
					value = EnsureVanityStateOverlay(slotGo);
				}
				Image component = value.GetComponent<Image>();
				Transform val = value.transform.Find("EPI_VanityHidden");
				Transform val2 = value.transform.Find("EPI_VanityHasVanity");
				Image val3 = (Object.op_Implicit((Object)(object)val) ? ((Component)val).GetComponent<Image>() : null);
				Image val4 = (Object.op_Implicit((Object)(object)val2) ? ((Component)val2).GetComponent<Image>() : null);
				bool flag = vs.IsHidden && Object.op_Implicit((Object)(object)val3) && (Object)(object)val3.sprite != (Object)null;
				bool flag2 = vs.HasVanity && Object.op_Implicit((Object)(object)val4) && (Object)(object)val4.sprite != (Object)null;
				if (Object.op_Implicit((Object)(object)val3))
				{
					((Behaviour)val3).enabled = flag;
				}
				if (Object.op_Implicit((Object)(object)val4))
				{
					((Behaviour)val4).enabled = flag2;
				}
				bool flag3 = flag || flag2;
				if (value.activeSelf != flag3)
				{
					value.SetActive(flag3);
				}
				if (Object.op_Implicit((Object)(object)component))
				{
					((Behaviour)component).enabled = flag;
				}
			}
		}

		public static void HideAllVanityOverlays()
		{
			foreach (KeyValuePair<GameObject, GameObject> item in VanityStateByGo)
			{
				if (Object.op_Implicit((Object)(object)item.Value) && item.Value.activeSelf)
				{
					item.Value.SetActive(false);
				}
			}
		}
	}
	public class Model
	{
		internal class Slot
		{
			public string Name;

			public string OriginalName;

			public Vector2 Position;

			public bool IsQuickSlot;

			public bool IsAPIAdded;

			public bool Occupied;

			public EquipmentSlot? EquipmentSlot => this as EquipmentSlot;
		}

		internal class EquipmentSlot : Slot
		{
			public Func<Player, ItemData?>? Get;

			public Func<ItemData, bool>? Valid;
		}
	}
}
namespace AzuEPI.Core.InventoryHandlers
{
	public class Capacity
	{
		public static int FreeStackSpace(Inventory inv, ItemData item)
		{
			int num = 0;
			foreach (ItemData item2 in inv.m_inventory)
			{
				if (!(item2.m_shared.m_name != item.m_shared.m_name) && item2.m_worldLevel == item.m_worldLevel && (item.m_shared.m_maxQuality <= 1 || item2.m_quality == item.m_quality) && item2.m_stack < item2.m_shared.m_maxStackSize)
				{
					num += item2.m_shared.m_maxStackSize - item2.m_stack;
				}
			}
			return num;
		}

		public static int FreeNormalCells(Inventory inv)
		{
			int normalRows = Layout.NormalRows(inv);
			int num = inv.m_inventory.Count((ItemData i) => i.m_gridPos.y < normalRows);
			return normalRows * inv.GetWidth() - num;
		}

		public static int FreeQuickCells(Inventory inv)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			int num = 0;
			foreach (Vector2i item in inv.EnumerateQuickCells())
			{
				if (inv.GetItemAt(item.x, item.y) == null)
				{
					num++;
				}
			}
			return num;
		}

		public static int FreeValidEquipmentCells(Inventory inv, ItemData item)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int count = ExtendedPlayerInventory.slots.Count;
			int value = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			int num2 = count - value;
			for (int i = 0; i < num2; i++)
			{
				if (ExtendedPlayerInventory.slots[i] is Model.EquipmentSlot { Valid: not null } equipmentSlot && equipmentSlot.Valid(item))
				{
					Vector2i val = inv.EpiIndexToGridPos(i);
					if (inv.GetItemAt(val.x, val.y) == null)
					{
						num++;
					}
				}
			}
			return num;
		}

		public static int FreeEquipmentCells(Inventory inv)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			int num = 0;
			foreach (Vector2i item in inv.EnumerateEquipmentCells())
			{
				if (inv.GetItemAt(item.x, item.y) == null)
				{
					num++;
				}
			}
			return num;
		}
	}
	public class InventoryHealth
	{
		public static void InventoryFix()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
			List<ItemData> list = new List<ItemData>();
			if (inventory == null)
			{
				return;
			}
			int num = 4 + AzuExtendedPlayerInventoryPlugin.ExtraRows.Value;
			if (inventory?.m_inventory != null)
			{
				for (int i = 0; i < inventory.m_inventory.Count; i++)
				{
					ItemData val = inventory.m_inventory[i];
					bool flag = hashSet.Contains(val.m_gridPos);
					bool flag2 = val.m_gridPos.y >= num;
					bool flag3 = val.m_gridPos.x < 0 || val.m_gridPos.x >= inventory.m_width || (!flag2 && (val.m_gridPos.y < 0 || val.m_gridPos.y >= num));
					if (flag || flag3 || val.m_stack < 1)
					{
						if (val.m_stack < 1)
						{
							inventory.RemoveItem(val);
						}
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)(flag ? ("Item " + Localization.instance.Localize(val.m_shared.m_name) + " was overlapping another item in the player inventory grid, moving to first available slot or dropping if no slots are available.") : ("Item " + Localization.instance.Localize(val.m_shared.m_name) + " was outside player inventory grid, moving to first available slot or dropping if no slots are available.")));
						list.Add(val);
					}
					hashSet.Add(val.m_gridPos);
				}
			}
			foreach (ItemData item in list)
			{
				inventory.TryAddItemToInventory(item);
			}
		}

		public static void FixHiddenItems()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			if (inventory == null)
			{
				return;
			}
			inventory.GetWidth();
			int num = Layout.NormalRows(inventory);
			bool flag = AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOn() && ExtendedPlayerInventory.slots.Count > 0;
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem.m_gridPos.y >= num && (!flag || inventory.IsHiddenCell(allItem.m_gridPos.x, allItem.m_gridPos.y) || (API.TryGetSlotIndexAtGridPos(inventory, allItem.m_gridPos, out var slotIndex) && !API.SlotValidates(slotIndex, allItem))))
				{
					list.Add(allItem);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarning((object)$"Found {list.Count} items in hidden/orphaned cells after slot configuration change. Relocating...");
			foreach (ItemData item in list)
			{
				try
				{
					inventory.TryAddItemToInventory(item);
				}
				catch (Exception arg)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogError((object)$"Error relocating item {item.m_shared?.m_name}: {arg}");
				}
			}
			inventory.Changed();
		}

		public static bool IgnoreKeyPresses(bool extra = false)
		{
			if (!extra)
			{
				if (Object.op_Implicit((Object)(object)ZNetScene.instance) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && !Minimap.IsOpen() && !Console.IsVisible() && !TextInput.IsVisible() && !ZNet.instance.InPasswordDialog())
				{
					Chat instance = Chat.instance;
					if (instance == null)
					{
						return false;
					}
					return instance.HasFocus();
				}
				return true;
			}
			if (Object.op_Implicit((Object)(object)ZNetScene.instance) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && !Minimap.IsOpen() && !Console.IsVisible() && !TextInput.IsVisible() && !ZNet.instance.InPasswordDialog())
			{
				Chat instance2 = Chat.instance;
				if ((instance2 == null || !instance2.HasFocus()) && !StoreGui.IsVisible() && !InventoryGui.IsVisible() && !Menu.IsVisible())
				{
					TextViewer instance3 = TextViewer.instance;
					if (instance3 == null)
					{
						return false;
					}
					return instance3.IsVisible();
				}
			}
			return true;
		}
	}
	public class Layout
	{
		public const int BaseInventoryHeight = 4;

		public const int BaseInventoryWidth = 8;

		internal const float tileSize = 70f;

		public const int MaxQuickSlots = 8;

		public const int OldLayoutQuickslotsPerColumn = 3;

		public const int OldLayoutRegularSlotsPerColumn = 3;

		public const int NewLayoutQuickslotsFirstRow = 4;

		internal static float equipOriginX = -430f;

		internal static float equipOriginY = -75f;

		internal static float columnGapTiles = 4f;

		internal static Transform AzuPlayerBkg = null;

		internal static readonly Vector2 PlayerBkgAnchorMin = new Vector2(-0.8f, 0f);

		internal static readonly Vector2 RepairMovement = new Vector2(-460f, 0f);

		internal static Vector2 PreviewAnchorMin = new Vector2(0f, 0.14f);

		internal static readonly Vector2 PreviewAnchorMax = new Vector2(1f, 0.885f);

		internal static readonly Vector2 PreviewSizeDelta = new Vector2(-297f, 0f);

		internal static readonly Vector2 PreviewAnchoredPos = new Vector2(-507f, 0f);

		internal static readonly Vector2 PlayerPreviewImageSize = new Vector2(500f, 630f);

		internal static readonly Vector2 ToggleButtonsGlgAnchoredPos = new Vector2(-222.5f, -5f);

		internal static readonly Vector2 ToggleButtonsHlgAnchoredPosOld = new Vector2(-552.5f, -145f);

		internal static readonly Vector2 ToggleButtonsGlgAnchoredPosOldVert = new Vector2(810f, -221f);

		internal static readonly Vector2 DropAllSize = new Vector2(100f, 30f);

		internal static readonly Vector2 DropAllAnchorMin = new Vector2(0f, 1f);

		internal static readonly Vector2 DropAllAnchorMax = new Vector2(0f, 1f);

		internal static readonly Vector2 DropAllPivot = new Vector2(0f, 1f);

		public static Vector2 SelectedFrameOrigAnchMin;

		public static Vector2 RepairSimpleOrigAnchoredPos;

		public static Vector2 RepairButtonOrigAnchoredPos;

		public static Vector2 EnchantmentMenuOrigAnchoredPos;

		public static Vector2 EnchantmentMenuBkgOrigAnchoredPos;

		public static Vector2 ContainerOrigPivot;

		private static ItemData?[] _projectedItems = Array.Empty<ItemData>();

		private static readonly Dictionary<ItemData, Vector2i> _plannedMoves = new Dictionary<ItemData, Vector2i>();

		private static readonly HashSet<Vector2i> _targetPositions = new HashSet<Vector2i>();

		public static void UpdateInventorySize()
		{
			if (!((Object)(object)InventoryGui.instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				ValheimPlusCompat.SyncRowsToConfig();
				int fullHeight = API.GetFullHeight(((Humanoid)Player.m_localPlayer).m_inventory.GetWidth());
				((Humanoid)Player.m_localPlayer).m_inventory.m_height = fullHeight;
				Player.m_localPlayer.m_tombstone.GetComponent<Container>().m_height = fullHeight;
				((Humanoid)Player.m_localPlayer).m_inventory.Changed();
				InventoryHealth.InventoryFix();
			}
		}

		public static void UpdateContainerPosition(bool addAPIRows = false)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.m_playerGrid))
			{
				float num = (addAPIRows ? (AzuExtendedPlayerInventoryPlugin.ExtraRows.Value + API.GetAddedRows(instance.m_playerGrid.m_width)) : AzuExtendedPlayerInventoryPlugin.ExtraRows.Value);
				instance.m_container.pivot = (Vector2)((AzuExtendedPlayerInventoryPlugin.ExtraRows.Value > 0) ? new Vector2(ContainerOrigPivot.x, ContainerOrigPivot.y + num * 0.2f) : ContainerOrigPivot);
			}
		}

		public static int NormalRows(Inventory inv)
		{
			int height = inv.GetHeight();
			if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff())
			{
				return height;
			}
			int addedRows = API.GetAddedRows(inv.GetWidth());
			return height - addedRows;
		}

		public static int GetBaseSlotIndex(Inventory inv)
		{
			return inv.GetWidth() * NormalRows(inv);
		}

		public static Vector2i ClampToVisible(Inventory inv, Vector2i p)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(Mathf.Clamp(p.x, 0, inv.GetWidth() - 1), Mathf.Clamp(p.y, 0, inv.GetHeight() - 1));
		}

		public static Vector2 GetEquipmentBackAnchorMax()
		{
			//IL_009b: 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)
			if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff())
			{
				return new Vector2(1.13f + (float)Math.Max(AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value, (ExtendedPlayerInventory.slots.Count - 1) / 4) * 70f / 570f, 1f);
			}
			int num = (ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value + 3 - 1) / 3;
			int num2 = (AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value + 3 - 1) / 3;
			float num3 = ((float)num + 0.5f + (float)num2) * 70f / 570f;
			return new Vector2(1.15f + num3, 1f);
		}

		public static void ApplyLayoutCorrections()
		{
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			RectTransform component = ((Component)((Transform)instance.m_crafting).Find("selected_frame")).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)((Transform)instance.m_crafting).Find("RepairSimple")).GetComponent<RectTransform>();
			RectTransform component3 = ((Component)((Transform)instance.m_crafting).Find("RepairButton")).GetComponent<RectTransform>();
			RectTransform val = (VESCompat.IsVesInstalled ? ((Component)((Transform)instance.m_crafting).Find("enchantment_menu")).GetComponent<RectTransform>() : null);
			RectTransform val2 = (VESCompat.IsVesInstalled ? ((Component)((Transform)instance.m_crafting).Find("RepairSimple(Clone)")).GetComponent<RectTransform>() : null);
			Image component4 = ((Component)((Transform)instance.m_crafting).Find("Bkg")).GetComponent<Image>();
			if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn())
			{
				component.anchorMin = SelectedFrameOrigAnchMin;
				component2.anchoredPosition = RepairSimpleOrigAnchoredPos;
				component3.anchoredPosition = RepairButtonOrigAnchoredPos;
				if (Object.op_Implicit((Object)(object)val))
				{
					val.anchoredPosition = EnchantmentMenuOrigAnchoredPos;
				}
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.anchoredPosition = EnchantmentMenuBkgOrigAnchoredPos;
				}
				if (!((Behaviour)component4).isActiveAndEnabled)
				{
					((Behaviour)component4).enabled = true;
				}
				if (Object.op_Implicit((Object)(object)UIBuilder.GlgGo))
				{
					if (Object.op_Implicit((Object)(object)InventoryGui.instance))
					{
						UIBuilder.GlgGo.WithParent(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? ((Component)InventoryGui.instance.m_crafting).transform : ((Component)InventoryGui.instance.m_player).transform, worldPositionStays: false);
					}
					UIBuilder.GlgRt.anchoredPosition = ToggleButtonsGlgAnchoredPosOldVert;
					GUICache.ButtonGridLayoutGroup.constraintCount = ((AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value < 1 && ExtendedPlayerInventory.slots.Count < 10) ? 2 : 3);
				}
				return;
			}
			component.anchorMin = PlayerBkgAnchorMin;
			component2.anchoredPosition += RepairMovement;
			component3.anchoredPosition += RepairMovement;
			if (Object.op_Implicit((Object)(object)val))
			{
				val.anchoredPosition += RepairMovement;
			}
			if (Object.op_Implicit((Object)(object)val2))
			{
				val2.anchoredPosition += RepairMovement;
			}
			if (((Behaviour)component4).isActiveAndEnabled)
			{
				((Behaviour)component4).enabled = false;
			}
			if (Object.op_Implicit((Object)(object)UIBuilder.GlgGo))
			{
				if (Object.op_Implicit((Object)(object)InventoryGui.instance))
				{
					UIBuilder.GlgGo.WithParent(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? ((Component)InventoryGui.instance.m_crafting).transform : ((Component)InventoryGui.instance.m_player).transform, worldPositionStays: false);
				}
				UIBuilder.GlgRt.anchoredPosition = ToggleButtonsGlgAnchoredPos;
			}
		}

		public static void FixPlayerPreview()
		{
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)UIBuilder.PreviewParent))
			{
				PreviewAnchorMin = (Vector2)((AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value > 4) ? new Vector2(0f, 0.24f) : ((AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value != 0) ? new Vector2(0f, 0.14f) : Vector2.zero));
				((RectTransform)UIBuilder.PreviewParent.transform).anchorMin = PreviewAnchorMin;
			}
		}

		public static void ProjectEquippedIntoGridTail(Player player, InventoryGrid playerGrid)
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = ((Humanoid)player).GetInventory();
			int width = inventory.GetWidth();
			int height = inventory.GetHeight();
			int addedRows = API.GetAddedRows(width);
			int num = height - addedRows;
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			int num2 = GetBaseSlotIndex(inventory);
			if (_projectedItems.Length != slots.Count)
			{
				_projectedItems = (ItemData?[])(object)new ItemData[slots.Count];
			}
			else
			{
				Array.Clear(_projectedItems, 0, _projectedItems.Length);
			}
			ItemData[] projectedItems = _projectedItems;
			_plannedMoves.Clear();
			_targetPositions.Clear();
			Dictionary<ItemData, Vector2i> plannedMoves = _plannedMoves;
			HashSet<Vector2i> targetPositions = _targetPositions;
			Vector2i val = default(Vector2i);
			for (int i = 0; i < slots.Count; i++)
			{
				if (!(slots[i] is Model.EquipmentSlot equipmentSlot))
				{
					continue;
				}
				((Vector2i)(ref val))..ctor(num2 % width, num2 / width);
				ItemData val2 = equipmentSlot.Get?.Invoke(player);
				if (val2 != null)
				{
					projectedItems[i] = val2;
					if (val2.m_gridPos != val)
					{
						plannedMoves[val2] = val;
						targetPositions.Add(val);
					}
				}
				num2++;
			}
			foreach (KeyValuePair<ItemData, Vector2i> item in plannedMoves)
			{
				ItemData key = item.Key;
				Vector2i value = item.Value;
				Vector2i gridPos = key.m_gridPos;
				ItemData itemAt = inventory.GetItemAt(value.x, value.y);
				if (itemAt != null && itemAt != key)
				{
					if (plannedMoves.ContainsKey(itemAt))
					{
						continue;
					}
					if (gridPos.y < num)
					{
						itemAt.m_gridPos = gridPos;
					}
					else
					{
						ItemData itemAt2 = inventory.GetItemAt(gridPos.x, gridPos.y);
						bool num3 = itemAt2 == null || itemAt2 == itemAt || itemAt2 == key;
						bool flag = itemAt2 != null && plannedMoves.ContainsKey(itemAt2);
						if (num3 || flag)
						{
							itemAt.m_gridPos = gridPos;
						}
						else
						{
							Vector2i val3 = FindFirstFreeNonSlotCell(inventory, width, num);
							if (val3.x >= 0)
							{
								itemAt.m_gridPos = val3;
							}
							else
							{
								AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebug((object)("ProjectEquippedIntoGridTail: no free non-slot cell for '" + itemAt.m_shared.m_name + "', leaving it in tail."));
							}
						}
					}
				}
				key.m_gridPos = value;
			}
			ExtendedPlayerInventory.equipItems = projectedItems;
			if (Object.op_Implicit((Object)(object)AzuEPICharacterPanel.playerPreviewComp) && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				VECloneSync.MirrorFrom(Player.m_localPlayer, AzuEPICharacterPanel.playerPreviewComp);
			}
		}

		private static Vector2i FindFirstFreeNonSlotCell(Inventory inv, int width, int firstTailRow)
		{
			//IL_003a: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector2i val = default(Vector2i);
			for (int i = 0; i < firstTailRow; i++)
			{
				for (int j = 0; j < width; j++)
				{
					((Vector2i)(ref val))..ctor(j, i);
					if (!API.TryGetSlotIndexAtGridPos(inv, val, out var _) && inv.GetItemAt(j, i) == null)
					{
						return val;
					}
				}
			}
			return new Vector2i(-1, -1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ApplyRepairShift()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)GUICache._selectedFrameRT))
			{
				GUICache._selectedFrameRT.anchorMin = PlayerBkgAnchorMin;
			}
			if (Object.op_Implicit((Object)(object)GUICache._repairSimpleRT))
			{
				RectTransform repairSimpleRT = GUICache._repairSimpleRT;
				repairSimpleRT.anchoredPosition += RepairMovement;
			}
			if (Object.op_Implicit((Object)(object)GUICache._repairButtonRT))
			{
				RectTransform repairButtonRT = GUICache._repairButtonRT;
				repairButtonRT.anchoredPosition += RepairMovement;
			}
			if (Object.op_Implicit((Object)(object)GUICache._enchantmentMenuButtonRT))
			{
				RectTransform? enchantmentMenuButtonRT = GUICache._enchantmentMenuButtonRT;
				enchantmentMenuButtonRT.anchoredPosition += RepairMovement;
			}
			if (Object.op_Implicit((Object)(object)GUICache._enchantmentMenuBkgButtonRT))
			{
				RectTransform? enchantmentMenuBkgButtonRT = GUICache._enchantmentMenuBkgButtonRT;
				enchantmentMenuBkgButtonRT.anchoredPosition += RepairMovement;
			}
		}
	}
	public class UIBuilder
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__46_0;

			internal void <BuildDropAllButton>b__46_0()
			{
				((Terminal)Console.instance).TryRunCommand("azuepi.dropall", false, false);
			}
		}

		public const string Prefix = "AzuEPI_";

		public const string QabName = "AzuEPI_QuickAccessBar";

		public const string AzuEquipmentBkgName = "AzuEPI_EquipmentBkg";

		public const string AzuPlayerBkgName = "AzuEPI_PlayerBkg";

		public const string DropAllButtonName = "AzuEPI_DropAllButton";

		public const string ToggleButtonsGlgName = "AzuEPI_ToggleButtonsGlg";

		public const string RuntimePanelName = "AzuEPI_RuntimePanel";

		public const string CraftingToggleButtonName = "AzuEPI_CraftingToggleButton";

		public const string PlayerPreviewName = "AzuEPI_PlayerPreview";

		public const string PlayerPreviewImageName = "AzuEPI_PlayerPreviewImg";

		public const string CharacterName = "AzuEPI_CharacterName";

		public const string MinimalUiguid = "Azumatt.MinimalUI";

		internal static RectTransform _epiPreviewRect;

		public static GameObject PreviewParent = null;

		public static GameObject PlayerPreviewImage = null;

		public static Transform CharName = null;

		public static GameObject GlgGo = null;

		public static RectTransform GlgRt = null;

		public static Transform CraftingButtonGo = null;

		private static Button _craftingToggleBtn = null;

		public const int columns = 2;

		public const int gapTiles = 4;

		public const float padding = 0.6f;

		public const float extraTiles = 6.6f;

		public const float totalWidth = 570f;

		public const int ToggleButtonColumns = 4;

		public const float ToggleButtonCellSize = 50f;

		public static float ToggleButtonSpacing = (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? 18f : 25f);

		public const float ToggleButtonFontSize = 36f;

		public static readonly Vector2 ToggleButtonContainerSize = new Vector2(320f, 75f);

		public const float ToggleButtonCellSizeOld = 40f;

		public static void RebuildUI()
		{
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				((Transform)InventoryGui.instance.m_player).Find("AzuEPI_EquipmentBkg").SafeSetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn());
				Layout.AzuPlayerBkg.SafeSetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
				PreviewParent.SafeSetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
				PlayerPreviewImage.SafeSetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
				CharName.SafeSetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
				GUICache.ButtonGridLayoutGroup.constraintCount = (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? 4 : ((AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value < 1 && ExtendedPlayerInventory.slots.Count < 10) ? 3 : 4));
				((LayoutGroup)GUICache.ButtonGridLayoutGroup).childAlignment = (TextAnchor)(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? 4 : 3);
				GUICache.ButtonGridLayoutGroup.cellSize = (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? new Vector2(50f, 50f) : new Vector2(40f, 40f));
				GlgGo.transform.SafeSetActive(AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value.isOn());
			}
		}

		public static void BuildEquipmentBkg(InventoryGui invGui, RectTransform bkgRect)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_00df: 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)
			Transform obj = Object.Instantiate<Transform>(((Component)bkgRect).transform, (Transform)(object)invGui.m_player);
			obj.SetAsFirstSibling();
			((Object)obj).name = "AzuEPI_EquipmentBkg";
			Vector2 equipmentBackAnchorMax = Layout.GetEquipmentBackAnchorMax();
			if (Chainloader.PluginInfos.TryGetValue("Azumatt.MinimalUI", out var value) && value != null)
			{
				equipmentBackAnchorMax.x += 0.03f;
			}
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			component.WithAnchors(new Vector2(1f, 0f), equipmentBackAnchorMax);
			if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn() && AzuExtendedPlayerInventoryPlugin.VanityOption.Value.isOff() && AzuExtendedPlayerInventoryPlugin.LoadoutOption.Value.isOff())
			{
				component.offsetMin = new Vector2(0f, 60f);
			}
			else
			{
				component.offsetMin = new Vector2(-10f, -10f);
			}
			((Component)InventoryGui.instance.m_playerGrid.m_gridRoot).GetComponent<RectTransform>().WithAnchorMax(equipmentBackAnchorMax);
			((Graphic)((Component)InventoryGui.instance.m_playerGrid.m_gridRoot).GetComponent<Image>()).raycastTarget = false;
			((Component)obj).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn());
		}

		public static void BuildToggleButtonGlg(InventoryGui invGui)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0074: 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_0097: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			GlgGo = GameObjectHelper.CreateUIObject("AzuEPI_ToggleButtonsGlg", typeof(GridLayoutGroup)).WithParent(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? ((Component)invGui.m_crafting).transform : ((Component)invGui.m_player).transform, worldPositionStays: false);
			GlgRt = (RectTransform)GlgGo.transform;
			GlgRt.WithAnchors(new Vector2(0f, 1f), new Vector2(0f, 1f)).WithPivot(new Vector2(0.5f, 1f)).WithAnchoredPosition(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff() ? Layout.ToggleButtonsGlgAnchoredPos : Layout.ToggleButtonsGlgAnchoredPosOldVert)
				.WithSizeDelta(ToggleButtonContainerSize);
			GridLayoutGroup component = GlgGo.GetComponent<GridLayoutGroup>();
			((LayoutGroup)component).childAlignment = (TextAnchor)4;
			component.constraint = (Constraint)1;
			component.constraintCount = 4;
			component.spacing = new Vector2(ToggleButtonSpacing, 5f);
			component.cellSize = new Vector2(50f, 50f);
			GUICache.ButtonGridLayoutGroup = component;
			VanityPanelController.ToggleButtonParentGlg = GlgRt;
			PersonalLoadoutGui.ToggleButtonParentGlg = GlgRt;
			StatsPanelController.ToggleButtonParentGlg = GlgRt;
			GlgGo.SetActive(AzuExtendedPlayerInventoryPlugin.DisplayEquipmentRowSeparate.Value.isOn());
		}

		public static void BuildCraftingToggleButton(InventoryGui gui)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_craftingToggleBtn))
			{
				return;
			}
			PanelUtilities.ButtonConfig config = new PanelUtilities.ButtonConfig("AzuEPI_CraftingToggleButton", new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f), Vector2.zero, new Vector2(70f, 70f), "", (KeyCode)0, "\ud83d\udd28", 36f, ReturnToCrafting);
			(CraftingButtonGo, _craftingToggleBtn) = PanelUtilities.BuildToggleButton(gui, (Transform)(object)GlgRt, config);
			UIGamePad val = default(UIGamePad);
			if (((Component)CraftingButtonGo).TryGetComponent<UIGamePad>(ref val))
			{
				if (Object.op_Implicit((Object)(object)val.m_hint))
				{
					val.m_hint.gameObject.SetActive(false);
				}
				Object.Destroy((Object)(object)val);
			}
			CraftingButtonGo.SetAsFirstSibling();
		}

		public static void ReturnToCrafting()
		{
			if (VanityPanelController.IsVisible())
			{
				VanityPanelController.SetVisible(visible: false);
			}
			if (PersonalLoadoutGui.IsVisible())
			{
				PersonalLoadoutGui.Hide();
			}
			if (StatsPanelController.IsVisible())
			{
				StatsPanelController.SetVisible(visible: false);
			}
			PanelUtilities.HideCraftingElements(hide: false);
		}

		public static void EnsureVanityPanelBuilt(InventoryGui invGui)
		{
			VanityPanelController.EnsureBuilt(invGui);
		}

		public static void BuildLoadoutToggles(InventoryGui invGui)
		{
			PersonalLoadoutGui.BuildLoadoutToggleButton(invGui);
		}

		public static void BuildStatsToggleButton(InventoryGui invGui)
		{
			StatsPanelController.BuildToggleButton(invGui);
		}

		public static void EnsureStatsPanelBuilt(InventoryGui invGui)
		{
			StatsPanelController.EnsureBuilt(invGui);
		}

		public static void CreateExtendedCraftingPanel(InventoryGui invGui, RectTransform selectedFrame)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Layout.AzuPlayerBkg = Object.Instantiate<Transform>(((Transform)invGui.m_crafting).Find("Bkg"), (Transform)(object)invGui.m_crafting);
			Layout.AzuPlayerBkg.SetSiblingIndex(((Transform)selectedFrame).GetSiblingIndex() + 2);
			((Object)Layout.AzuPlayerBkg).name = "AzuEPI_PlayerBkg";
			((Component)Layout.AzuPlayerBkg).GetComponent<RectTransform>().WithAnchorMin(Layout.PlayerBkgAnchorMin);
			((Component)Layout.AzuPlayerBkg).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
		}

		public static void CreateRuntimePanel()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)AzuEPICharacterPanel.instance == (Object)null)
			{
				new GameObject("AzuEPI_RuntimePanel").AddComponent<AzuEPICharacterPanel>();
			}
		}

		public static void CreateAzuEpiPreview(InventoryGui invGui, out RectTransform previewParentRT)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			PreviewParent = GameObjectHelper.CreateUIObject("AzuEPI_PlayerPreview", typeof(CanvasRenderer), typeof(Image), typeof(RectMask2D), typeof(PlayerRotationController)).WithParent((Transform)(object)invGui.m_crafting, worldPositionStays: false).WithActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
			previewParentRT = (RectTransform)PreviewParent.transform;
			previewParentRT.WithAnchors(Layout.PreviewAnchorMin, Layout.PreviewAnchorMax).WithSizeDelta(Layout.PreviewSizeDelta).WithAnchoredPosition(Layout.PreviewAnchoredPos);
			((Graphic)PreviewParent.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.565f);
		}

		public static void CreatePlayerPreviewImage(RectTransform previewParentRT)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			PlayerPreviewImage = GameObjectHelper.CreateUIObject("AzuEPI_PlayerPreviewImg", typeof(CanvasRenderer), typeof(RawImage)).WithParent((Transform)(object)previewParentRT, worldPositionStays: false).WithActive(AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOff());
			RectTransform val = (RectTransform)PlayerPreviewImage.transform;
			val.WithSizeDelta(Layout.PlayerPreviewImageSize).WithAnchoredPosition(Vector2.zero);
			RawImage component = PlayerPreviewImage.GetComponent<RawImage>();
			((Graphic)component).raycastTarget = false;
			((Graphic)component).color = Color.white;
			AzuEPICharacterPanel.instance.render = val;
			AzuEPICharacterPanel.instance.renderRawImage = component;
			_epiPreviewRect = val;
		}

		public static void SetupPreviewPanel()
		{
			PlayerPreviewManager.Initialize();
			PlayerPreviewManager.Instance.CreatePreviewCamera();
			PlayerPreviewManager.Instance.CreatePreviewLights();
			PlayerPreviewManager.Instance.UpdateRenderTexture();
		}

		public static void CreateCharacterName(InventoryGui invGui, RectTransform previewParentRT)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			CharName = Object.Instantiate<Transform>(((Component)invGui.m_info).transform.Find("TitlePanel"), (Transform)(object)previewParentRT);
			((Object)CharName).name = "AzuEPI_CharacterName";
			((TMP_Text)((Component)CharName).GetComponentsInChildren<TextMeshProUGUI>().FirstOrDefault()).text = Game.instance.GetPlayerProfile().GetName();
			foreach (Transform item in CharName)
			{
				Transform val = item;
				if (((Object)val).name.Contains("BraidLine"))
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		public static void BuildDropAllButton(InventoryGui invGui)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_00bc: 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_00c7: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)((Transform)invGui.m_player).Find("AzuEPI_DropAllButton")))
			{
				return;
			}
			Transform obj = Object.Instantiate<Transform>(((Component)invGui.m_takeAllButton).transform, (Transform)(object)invGui.m_player);
			((Object)obj).name = "AzuEPI_DropAllButton";
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			((Transform)component).SetAsFirstSibling();
			component.WithAnchors(Layout.DropAllAnchorMin, Layout.DropAllAnchorMax).WithPivot(Layout.DropAllPivot).WithAnchoredPosition(AzuExtendedPlayerInventoryPlugin.DropAllButtonPosition.Value)
				.WithSizeDelta(Layout.DropAllSize);
			((Component)component).GetComponentInChildren<TMP_Text>().text = Localization.instance.Localize("$azuepi_dropall");
			Button component2 = ((Component)obj).GetComponent<Button>();
			((UnityEventBase)component2.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = component2.onClick;
			object obj2 = <>c.<>9__46_0;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					((Terminal)Console.instance).TryRunCommand("azuepi.dropall", false, false);
				};
				<>c.<>9__46_0 = val;
				obj2 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
			((Component)obj).gameObject.SetActive(AzuExtendedPlayerInventoryPlugin.MakeDropAllButton.Value.isOn());
		}
	}
	public class GUICache
	{
		public static RectTransform _craftingBkgRT;

		public static RectTransform _selectedFrameRT;

		public static RectTransform _repairSimpleRT;

		public static RectTransform _repairButtonRT;

		public static RectTransform? _enchantmentMenuButtonRT;

		public static RectTransform? _enchantmentMenuBkgButtonRT;

		public static RectTransform _playerBkgRT;

		public static RectTransform _playerGridRootRT;

		public static Image? _playerGridRootImage;

		public static GridLayoutGroup ButtonGridLayoutGroup;

		private static bool? _isMinimalUi;

		public static bool IsMinimalUiInstalled
		{
			get
			{
				bool valueOrDefault = _isMinimalUi == true;
				if (!_isMinimalUi.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("Azumatt.MinimalUI");
					_isMinimalUi = valueOrDefault;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
		}
	}
	public static class InventoryExtensions
	{
		[SpecialName]
		public sealed class <G>$A2F21FF1B57963088663AD1A3397D3DE
		{
			[SpecialName]
			public static class <M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D
			{
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			public bool IsPlayerInventory()
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			public List<ItemData> GetEquippedItemsFiltered()
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			public void TryAddItemToInventory(ItemData itemData)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal Vector2i EpiIndexToGridPos(int slotIndex)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool IsEquipmentSlotFreeAndItemValid(ItemData item, out int which)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool IsEquipmentSlotFree(out int which)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool IsQuickSlotFree(out int which)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool IsAtEquipmentSlot(ItemData item, out int which)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool IsAtQuickSlot(ItemData item, out int which)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool IsHiddenCell(int x, int y)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			private int LinearIndexIntoEpiBlock(int x, int y)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal IEnumerable<Vector2i> EnumerateQuickCells()
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal IEnumerable<Vector2i> EnumerateEquipmentCells()
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool TryFindEmptyQuickCell(out Vector2i pos)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			internal bool ShouldProtectInventorySlots()
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			public Vector2i FindEmptyQuickAware(bool topFirst)
			{
				throw null;
			}

			[ExtensionMarker("<M>$A79EDED0FE6EFA830C8CF8BD6A0D2B7D")]
			public Vector2i FindEmptyQuickAware(ItemData item, bool topFirst)
			{
				throw null;
			}
		}

		public static bool IsPlayerInventory(this Inventory inv)
		{
			if (inv != null && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return inv == ((Humanoid)Player.m_localPlayer).GetInventory();
			}
			return false;
		}

		public static List<ItemData> GetEquippedItemsFiltered(this Inventory inv)
		{
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData item in inv.m_inventory)
			{
				if (item.m_equipped && item.m_shared.m_teleportable && Object.op_Implicit((Object)(object)item.m_dropPrefab) && !AdvBackpacksCompat.Backpacks.Contains(((Object)item.m_dropPrefab).name) && !RustyBagsCompat.Backpacks.Contains(((Object)item.m_dropPrefab).name) && ((Object)item.m_dropPrefab).name != "bp_explorer" && ((Object)item.m_dropPrefab).name != "JC_Gem_Bag")
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static void TryAddItemToInventory(this Inventory inv, ItemData itemData)
		{
			//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)
			//IL_0009: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			Vector2i val = inv.FindEmptyQuickAware(itemData, topFirst: true);
			if (val.x >= 0 && val.y >= 0)
			{
				if (!inv.m_inventory.Contains(itemData))
				{
					ManualLogSource azuExtendedPlayerInventoryLogger = AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger;
					Localization instance = Localization.instance;
					azuExtendedPlayerInventoryLogger.LogWarning((object)("TryAddItemToInventory: " + (((instance != null) ? instance.Localize(itemData.m_shared.m_name) : null) ?? itemData.m_shared.m_name) + " is not in this inventory, skipping relocation."));
					return;
				}
				int stack = itemData.m_stack;
				inv.RemoveItem(itemData);
				if (!inv.AddItem(itemData, stack, val.x, val.y))
				{
					ManualLogSource azuExtendedPlayerInventoryLogger2 = AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger;
					Localization instance2 = Localization.instance;
					azuExtendedPlayerInventoryLogger2.LogWarning((object)$"Failed to relocate {((instance2 != null) ? instance2.Localize(itemData.m_shared.m_name) : null) ?? itemData.m_shared.m_name} to ({val.x},{val.y}), dropping item.");
					((Humanoid)Player.m_localPlayer).DropItem(inv, itemData, stack);
				}
			}
			else
			{
				ManualLogSource azuExtendedPlayerInventoryLogger3 = AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger;
				Localization instance3 = Localization.instance;
				azuExtendedPlayerInventoryLogger3.LogInfo((object)("No empty slot for " + (((instance3 != null) ? instance3.Localize(itemData.m_shared.m_name) : null) ?? itemData.m_shared.m_name) + ", dropping item."));
				((Humanoid)Player.m_localPlayer).DropItem(inv, itemData, itemData.m_stack);
			}
		}

		internal static Vector2i EpiIndexToGridPos(this Inventory inv, int slotIndex)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			int num2 = slotIndex % width;
			int num3 = num + slotIndex / width;
			return new Vector2i(num2, num3);
		}

		internal static bool IsEquipmentSlotFreeAndItemValid(this Inventory inv, ItemData item, out int which)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: 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_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			which = -1;
			if (ExtendedPlayerInventory.slots == null || ExtendedPlayerInventory.slots.Count == 0)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("IsEquipmentSlotFreeAndItemValid: Slots not initialized yet");
				return false;
			}
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"IsEquipmentSlotFreeAndItemValid: Checking item '{item.m_shared.m_name}' (Type: {item.m_shared.m_itemType})");
			which = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s is Model.EquipmentSlot { Valid: not null } equipmentSlot3 && s.IsAPIAdded && equipmentSlot3.Valid(item) && !equipmentSlot3.Occupied);
			if (which >= 0)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"IsEquipmentSlotFreeAndItemValid: Found API-added slot {which} ({ExtendedPlayerInventory.slots[which]?.Name})");
			}
			else
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("IsEquipmentSlotFreeAndItemValid: No free API-added slot found, checking built-in slots");
				for (int num = 0; num < ExtendedPlayerInventory.slots.Count; num++)
				{
					Model.Slot slot = ExtendedPlayerInventory.slots[num];
					if (slot is Model.EquipmentSlot { Valid: not null } equipmentSlot && slot.IsAPIAdded)
					{
						bool flag = equipmentSlot.Valid(item);
						bool occupied = equipmentSlot.Occupied;
						AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"  API Slot {num} ({slot.Name}): Validates={flag}, Occupied={occupied}");
					}
				}
			}
			if (which < 0)
			{
				which = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s is Model.EquipmentSlot { Valid: not null } equipmentSlot3 && !s.IsAPIAdded && equipmentSlot3.Valid(item) && !equipmentSlot3.Occupied);
				if (which >= 0)
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"IsEquipmentSlotFreeAndItemValid: Found built-in slot {which} ({ExtendedPlayerInventory.slots[which]?.Name})");
				}
				else
				{
					AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("IsEquipmentSlotFreeAndItemValid: No free built-in slot found either");
					for (int num2 = 0; num2 < ExtendedPlayerInventory.slots.Count; num2++)
					{
						Model.Slot slot2 = ExtendedPlayerInventory.slots[num2];
						if (slot2 is Model.EquipmentSlot { Valid: not null } equipmentSlot2 && !slot2.IsAPIAdded)
						{
							bool flag2 = equipmentSlot2.Valid(item);
							bool occupied2 = equipmentSlot2.Occupied;
							AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug($"  Built-in Slot {num2} ({slot2.Name}): Validates={flag2}, Occupied={occupied2}");
						}
					}
				}
			}
			if (which < 0)
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug("IsEquipmentSlotFreeAndItemValid: No valid free slot found for '" + item.m_shared.m_name + "'");
				return false;
			}
			Vector2i val = inv.EpiIndexToGridPos(which);
			if (val.x < 0 || val.x >= inv.GetWidth() || val.y < 0 || val.y >= inv.GetHeight())
			{
				AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogWarningDebug($"Calculated equipment slot position ({val.x}, {val.y}) is out of inventory bounds ({inv.GetWidth()}x{inv.GetHeight()}). Skipping auto-equip.");
				which = -1;
				return false;
			}
			bool flag3 = inv.GetItemAt(val.x, val.y) == null;
			AzuExtendedPlayerInventoryPlugin.AzuExtendedPlayerInventoryLogger.LogDebugDebug(string.Format("IsEquipmentSlotFreeAndItemValid: Slot {0} at ({1}, {2}) is {3}", which, val.x, val.y, flag3 ? "empty" : "occupied"));
			return flag3;
		}

		internal static bool IsEquipmentSlotFree(this Inventory inv, out int which)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			which = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s is Model.EquipmentSlot && !s.IsQuickSlot && s.EquipmentSlot != null && !s.Occupied);
			if (which < 0)
			{
				return false;
			}
			Vector2i val = inv.EpiIndexToGridPos(which);
			return inv.GetItemAt(val.x, val.y) == null;
		}

		internal static bool IsQuickSlotFree(this Inventory inv, out int which)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			which = ExtendedPlayerInventory.slots.FindIndex((Model.Slot? s) => s != null && s.IsQuickSlot && s.EquipmentSlot == null && !s.Occupied);
			if (which < 0)
			{
				return false;
			}
			Vector2i val = inv.EpiIndexToGridPos(which);
			return inv.GetItemAt(val.x, val.y) == null;
		}

		internal static bool IsAtEquipmentSlot(this Inventory inv, ItemData item, out int which)
		{
			int num = Layout.NormalRows(inv);
			if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() || item.m_gridPos.y < num || (item.m_gridPos.y - num) * inv.GetWidth() + item.m_gridPos.x >= ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value)
			{
				which = -1;
				return false;
			}
			which = (item.m_gridPos.y - num) * inv.GetWidth() + item.m_gridPos.x;
			return true;
		}

		internal static bool IsAtQuickSlot(this Inventory inv, ItemData item, out int which)
		{
			int num = Layout.NormalRows(inv);
			if (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOff() || item.m_gridPos.y < num || (item.m_gridPos.y - num) * inv.GetWidth() + item.m_gridPos.x < ExtendedPlayerInventory.slots.Count - AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value)
			{
				which = -1;
				return false;
			}
			which = (item.m_gridPos.y - num) * inv.GetWidth() + item.m_gridPos.x;
			return true;
		}

		internal static bool IsHiddenCell(this Inventory inv, int x, int y)
		{
			int num = inv.LinearIndexIntoEpiBlock(x, y);
			if (num >= 0)
			{
				return num >= ExtendedPlayerInventory.slots.Count;
			}
			return false;
		}

		private static int LinearIndexIntoEpiBlock(this Inventory inv, int x, int y)
		{
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			if (y < num)
			{
				return -1;
			}
			int num2 = num * width;
			return y * width + x - num2;
		}

		internal static IEnumerable<Vector2i> EnumerateQuickCells(this Inventory inv)
		{
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			int firstLinear = num * width;
			int total = ExtendedPlayerInventory.slots.Count;
			int value = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			int num2 = total - value;
			int i = num2;
			while (i < total)
			{
				int num3 = firstLinear + i;
				yield return new Vector2i(num3 % width, num3 / width);
				int num4 = i + 1;
				i = num4;
			}
		}

		internal static IEnumerable<Vector2i> EnumerateEquipmentCells(this Inventory inv)
		{
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			int firstLinear = num * width;
			int count = ExtendedPlayerInventory.slots.Count;
			int value = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			int equipmentCount = count - value;
			int i = 0;
			while (i < equipmentCount)
			{
				int num2 = firstLinear + i;
				yield return new Vector2i(num2 % width, num2 / width);
				int num3 = i + 1;
				i = num3;
			}
		}

		internal static bool TryFindEmptyQuickCell(this Inventory inv, out Vector2i pos)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			foreach (Vector2i item in inv.EnumerateQuickCells())
			{
				if (inv.GetItemAt(item.x, item.y) == null)
				{
					pos = item;
					return true;
				}
			}
			pos = new Vector2i(-1, -1);
			return false;
		}

		internal static bool ShouldProtectInventorySlots(this Inventory inv)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && inv == ((Humanoid)Player.m_localPlayer).GetInventory())
			{
				return AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOn();
			}
			return false;
		}

		public static Vector2i FindEmptyQuickAware(this Inventory inv, bool topFirst)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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)
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			if (topFirst)
			{
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < width; j++)
					{
						if (inv.GetItemAt(j, i) == null)
						{
							return new Vector2i(j, i);
						}
					}
				}
			}
			else
			{
				for (int num2 = num - 1; num2 >= 0; num2--)
				{
					for (int k = 0; k < width; k++)
					{
						if (inv.GetItemAt(k, num2) == null)
						{
							return new Vector2i(k, num2);
						}
					}
				}
			}
			if (inv.TryFindEmptyQuickCell(out var pos))
			{
				return pos;
			}
			return new Vector2i(-1, -1);
		}

		public static Vector2i FindEmptyQuickAware(this Inventory inv, ItemData item, bool topFirst)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00b6: 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)
			int width = inv.GetWidth();
			int num = Layout.NormalRows(inv);
			if (topFirst)
			{
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < width; j++)
					{
						if (inv.GetItemAt(j, i) == null)
						{
							return new Vector2i(j, i);
						}
					}
				}
			}
			else
			{
				for (int num2 = num - 1; num2 >= 0; num2--)
				{
					for (int k = 0; k < width; k++)
					{
						if (inv.GetItemAt(k, num2) == null)
						{
							return new Vector2i(k, num2);
						}
					}
				}
			}
			if (inv.TryFindEmptyQuickCell(out var pos))
			{
				return pos;
			}
			int height = inv.GetHeight();
			Vector2i val = default(Vector2i);
			for (int l = num; l < height; l++)
			{
				for (int m = 0; m < width; m++)
				{
					if (inv.GetItemAt(m, l) == null)
					{
						((Vector2i)(ref val))..ctor(m, l);
						if (API.TryGetSlotIndexAtGridPos(inv, val, out var slotIndex) && API.SlotValidates(slotIndex, item))
						{
							return val;
						}
					}
				}
			}
			return new Vector2i(-1, -1);
		}
	}
}
namespace AzuEPI.Core.Input
{
	internal static class GamepadCompatibility
	{
		[HarmonyPatch(typeof(InventoryGrid), "UpdateGamepad")]
		private static class InventoryGrid_UpdateGamepad_GamepadSupport
		{
			private static bool Prefix(InventoryGrid __instance)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0681: Unknown result type (might be due to invalid IL or missing references)
				//IL_069d: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_055c: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_0577: Unknown result type (might be due to invalid IL or missing references)
				//IL_0567: Unknown result type (might be due to invalid IL or missing references)
				//IL_0625: Unknown result type (might be due to invalid IL or missing references)
				//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_058a: 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_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0646: Unknown result type (might be due to invalid IL or missing references)
				//IL_063d: Unknown result type (might be due to invalid IL or missing references)
				//IL_063e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0630: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03db: Unknown result type (might be due to invalid IL or missing references)
				//IL_034d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0342: Unknown result type (might be due to invalid IL or missing references)
				//IL_031a: Unknown result type (might be due to invalid IL or missing references)
				//IL_031f: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0658: Unknown result type (might be due to invalid IL or missing references)
				//IL_061c: Unknown result type (might be due to invalid IL or missing references)
				//IL_061d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0613: Unknown result type (might be due to invalid IL or missing references)
				//IL_0618: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: 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_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_045f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0464: Unknown result type (might be due to invalid IL or missing references)
				//IL_043b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0440: Unknown result type (might be due to invalid IL or missing references)
				//IL_0377: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_036a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0352: Unknown result type (might be due to invalid IL or missing references)
				//IL_030a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0603: Unknown result type (might be due to invalid IL or missing references)
				//IL_0288: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0293: Unknown result type (might be due to invalid IL or missing references)
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0263: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0503: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_04de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0425: Unknown result type (might be due to invalid IL or missing references)
				//IL_041a: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_037c: Unknown result type (might be due to invalid IL or missing references)
				//IL_030f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0679: Unknown result type (might be due to invalid IL or missing references)
				//IL_027a: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0528: Unknown result type (might be due to invalid IL or missing references)
				//IL_052d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0508: Unknown result type (might be due to invalid IL or missing references)
				//IL_042a: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_054e: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
				if (!ZInput.IsGamepadActive() || (Object)(object)__instance != (Object)(object)InventoryGui.instance?.m_playerGrid || !__instance.m_uiGroup.IsActive || Console.IsVisible())
				{
					return true;
				}
				EpiGridMap.Snapshot s = EpiGridMap.BuildForPlayer();
				Vector2i selected = __instance.m_selected;
				bool flag = ZInput.GetButtonDown("JoyDPadLeft") || ZInput.GetButtonDown("JoyLStickLeft");
				bool flag2 = ZInput.GetButtonDown("JoyDPadRight") || ZInput.GetButtonDown("JoyLStickRight");
				bool flag3 = ZInput.GetButtonDown("JoyDPadUp") || ZInput.GetButtonDown("JoyLStickUp");
				bool flag4 = ZInput.GetButtonDown("JoyDPadDown") || ZInput.GetButtonDown("JoyLStickDown");
				if (!(flag || flag2 || flag3 || flag4))
				{
					return true;
				}
				Vector2i to = selected;
				bool flag5 = AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn();
				int equipIdx;
				int quickIdx;
				switch (EpiGridMap.Classify(in s, selected, out equipIdx, out quickIdx))
				{
				case EpiGridMap.CellKind.Equipment:
				{
					EpiGridMap.EquipIndexToRowCol(in s, equipIdx, out var row3, out var col);
					if (flag)
					{
						int num6 = col - 1;
						to = ((num6 >= 0 && EpiGridMap.TryEquipIndexFromRowCol(in s, row3, num6, out var equipIndex5)) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex5) : ((flag5 || col <= 0 || s.QuickCount <= 0) ? EpiGridMap.LeftInventoryEdge(in s, row3) : EpiGridMap.QuickIndexToGrid(in s, 0)));
					}
					else if (flag2)
					{
						to = ((++col < s.EquipCols && EpiGridMap.TryEquipIndexFromRowCol(in s, row3, col, out var equipIndex6)) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex6) : ((s.QuickCount > 0 && row3 < s.EquipRowsPerColumn) ? EpiGridMap.QuickIndexToGrid(in s, Mathf.Clamp(row3, 0, s.QuickCount - 1)) : ((flag5 || s.QuickCount <= 0) ? EpiGridMap.RightInventoryEdge(in s, row3) : EpiGridMap.QuickIndexToGrid(in s, 0))));
					}
					else if (flag3)
					{
						to = ((--row3 < 0 || !EpiGridMap.TryEquipIndexFromRowCol(in s, row3, col, out var equipIndex7)) ? EpiGridMap.TopInventoryEdge(in s, selected.x) : EpiGridMap.EquipIndexToGrid(in s, equipIndex7));
					}
					else if (flag4)
					{
						to = ((++row3 < s.EquipRowsPerColumn && EpiGridMap.TryEquipIndexFromRowCol(in s, row3, col, out var equipIndex8)) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex8) : ((flag5 || s.QuickCount <= 0) ? EpiGridMap.BottomInventoryEdge(in s, selected.x) : EpiGridMap.QuickIndexToGrid(in s, 0)));
					}
					break;
				}
				case EpiGridMap.CellKind.Quick:
					if (flag5)
					{
						int num = quickIdx / 3;
						int num2 = quickIdx % 3;
						if (flag)
						{
							if (num > 0)
							{
								int num3 = (num - 1) * 3 + num2;
								to = ((num3 < s.QuickCount) ? EpiGridMap.QuickIndexToGrid(in s, num3) : selected);
							}
							else
							{
								to = ((s.EquipCount <= 0) ? EpiGridMap.LeftInventoryEdge(in s, num2) : (EpiGridMap.TryFindValidEquipmentSlot(in s, num2, s.EquipCols - 1, out var equipIndex2) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex2) : EpiGridMap.LeftInventoryEdge(in s, num2)));
							}
						}
						else if (flag2)
						{
							int num4 = (num + 1) * 3 + num2;
							to = ((num4 < s.QuickCount) ? EpiGridMap.QuickIndexToGrid(in s, num4) : EpiGridMap.RightInventoryEdge(in s, num2));
						}
						else if (flag3)
						{
							to = ((num2 > 0) ? EpiGridMap.QuickIndexToGrid(in s, quickIdx - 1) : EpiGridMap.TopInventoryEdge(in s, selected.x));
						}
						else if (flag4)
						{
							int num5 = quickIdx + 1;
							to = ((num5 < s.QuickCount && num5 / 3 == num) ? EpiGridMap.QuickIndexToGrid(in s, num5) : EpiGridMap.BottomInventoryEdge(in s, selected.x));
						}
					}
					else
					{
						if (flag5)
						{
							break;
						}
						if (flag)
						{
							if (quickIdx > 0)
							{
								to = EpiGridMap.QuickIndexToGrid(in s, quickIdx - 1);
							}
							else if (s.EquipCount > 0)
							{
								int row = Math.Min(s.EquipRowsPerColumn - 1, s.EquipCount - 1);
								to = (EpiGridMap.TryEquipIndexFromRowCol(in s, row, 0, out var equipIndex3) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex3) : EpiGridMap.LeftInventoryEdge(in s, s.NormalInventoryHeight - 1));
							}
							else
							{
								to = EpiGridMap.LeftInventoryEdge(in s, s.NormalInventoryHeight - 1);
							}
						}
						else if (flag2)
						{
							if (quickIdx + 1 < s.QuickCount)
							{
								to = EpiGridMap.QuickIndexToGrid(in s, quickIdx + 1);
							}
							else if (s.EquipCols > 1 && s.EquipCount > s.EquipRowsPerColumn)
							{
								int row2 = Math.Min(s.EquipRowsPerColumn - 1, s.EquipCount - s.EquipRowsPerColumn - 1);
								to = (EpiGridMap.TryEquipIndexFromRowCol(in s, row2, 1, out var equipIndex4) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex4) : EpiGridMap.RightInventoryEdge(in s, s.NormalInventoryHeight - 1));
							}
							else
							{
								to = EpiGridMap.RightInventoryEdge(in s, s.NormalInventoryHeight - 1);
							}
						}
						else if (flag3)
						{
							to = ((quickIdx > 0) ? EpiGridMap.QuickIndexToGrid(in s, quickIdx - 1) : EpiGridMap.BottomInventoryEdge(in s, selected.x));
						}
						else if (flag4)
						{
							if (quickIdx + 1 < s.QuickCount)
							{
								to = EpiGridMap.QuickIndexToGrid(in s, quickIdx + 1);
							}
							else if (__instance.jumpToNextContainer)
							{
								__instance.OnMoveToLowerInventoryGrid?.Invoke(selected);
							}
						}
					}
					break;
				case EpiGridMap.CellKind.Inventory:
					if (flag)
					{
						if (selected.x > 0)
						{
							EpiGridMap.TryMoveInInventory(in s, selected, -1, 0, out to);
						}
						else if (selected.y > 0)
						{
							((Vector2i)(ref to))..ctor(s.Width - 1, selected.y - 1);
						}
						else
						{
							((Vector2i)(ref to))..ctor(0, 0);
						}
					}
					else if (flag2)
					{
						if (selected.x < s.Width - 1)
						{
							EpiGridMap.TryMoveInInventory(in s, selected, 1, 0, out to);
						}
						else
						{
							to = ((selected.y <= s.EquipRowsPerColumn - 1 && s.EquipCount > 0 && EpiGridMap.TryEquipIndexFromRowCol(in s, selected.y, 0, out var equipIndex)) ? EpiGridMap.EquipIndexToGrid(in s, equipIndex) : ((s.QuickCount <= 0) ? selected : EpiGridMap.QuickIndexToGrid(in s, 0)));
						}
					}
					else if (flag3)
					{
						if (selected.y > 0)
						{
							EpiGridMap.TryMoveInInventory(in s, selected, 0, -1, out to);
						}
						else
						{
							to = selected;
						}
					}
					else if (flag4)
					{
						if (selected.y < s.NormalInventoryHeight - 1)
						{
							EpiGridMap.TryMoveInInventory(in s, selected, 0, 1, out to);
						}
						else if (__instance.jumpToNextContainer)
						{
							__instance.OnMoveToLowerInventoryGrid?.Invoke(selected);
						}
					}
					break;
				}
				to.x = Mathf.Clamp(to.x, 0, s.Width - 1);
				to.y = Mathf.Clamp(to.y, 0, s.PlayerHeight - 1);
				__instance.m_selected = to;
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "SetSelection")]
		private static class InventoryGrid_SetSelection_GamepadSupport
		{
			private static void Postfix(InventoryGrid __instance, Vector2i pos)
			{
				//IL_0022: 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_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance != (Object)(object)InventoryGui.instance?.m_playerGrid))
				{
					EpiGridMap.Snapshot snapshot = EpiGridMap.BuildForPlayer();
					Vector2i val = default(Vector2i);
					((Vector2i)(ref val))..ctor(Mathf.Clamp(pos.x, 0, snapshot.Width - 1), Mathf.Clamp(pos.y, 0, snapshot.PlayerHeight - 1));
					if (!(val == pos))
					{
						__instance.m_selected = val;
					}
				}
			}
		}
	}
	internal static class EpiGridMap
	{
		internal readonly struct Snapshot
		{
			public readonly int Width;

			public readonly int PlayerHeight;

			public readonly int BaseIndex;

			public readonly int EquipCount;

			public readonly int QuickCount;

			public readonly int EquipCols;

			public readonly int EquipRowsPerColumn;

			public readonly int NormalInventoryHeight;

			public Snapshot(int width, int playerHeight, int baseIndex, int equipCount, int quickCount, int equipCols, int equipRowsPerColumn, int normalInventoryHeight)
			{
				Width = width;
				PlayerHeight = playerHeight;
				BaseIndex = baseIndex;
				EquipCount = equipCount;
				QuickCount = quickCount;
				EquipCols = equipCols;
				EquipRowsPerColumn = equipRowsPerColumn;
				NormalInventoryHeight = normalInventoryHeight;
			}
		}

		internal enum CellKind
		{
			Inventory,
			Equipment,
			Quick,
			Unknown
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int CountEquipmentSlots()
		{
			List<Model.Slot> slots = ExtendedPlayerInventory.slots;
			int i;
			for (i = 0; i < slots.Count && slots[i] is Model.EquipmentSlot; i++)
			{
			}
			return i;
		}

		internal static Snapshot BuildForPlayer()
		{
			Player localPlayer = Player.m_localPlayer;
			Inventory val = ((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null);
			int num = ((val != null) ? val.GetWidth() : 8);
			int num2 = 4;
			int value = AzuExtendedPlayerInventoryPlugin.ExtraRows.Value;
			int num3 = CountEquipmentSlots();
			int value2 = AzuExtendedPlayerInventoryPlugin.QuickSlotsAmount.Value;
			if (AzuExtendedPlayerInventoryPlugin.OldLayout.Value.isOn())
			{
				int equipCols = Mathf.CeilToInt((float)num3 / 3f);
				int num4 = Math.Min(3, Math.Max(1, num3));
				int num5 = ((num3 > 0) ? num4 : 0);
				int num6 = num2 + value + num5;
				int normalInventoryHeight = num2 + value;
				int baseIndex = num * (num6 - num5);
				return new Snapshot(num, num6, baseIndex, num3, value2, equipCols, 3, normalInventoryHeight);
			}
			int num7 = (AzuExtendedPlayerInventoryPlugin.AddEquipmentRow.Value.isOn() ? API.GetAddedRows(num) : 0);
			int playerHeight = num2 + value + num7;
			int normalInventoryHeight2 = num2 + value;
			int num8 = 8;
			int equipCols2 = (num3 + num8 - 1) / num8;
			int baseSlotIndex = Layout.GetBaseSlotIndex(val);
			return new Snapshot(num, playerHeight, baseSlotIndex, num3, value2, equipCols2, num8, normalInventoryHeight2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryEquipIndexFromRowCol(in Snapshot s, int row, int col, out int equipIndex)
		{
			equipIndex = col * s.EquipRowsPerColumn + row;
			if (equipIndex >= 0)
			{
				return equipIndex < s.EquipCount;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2i EquipIndexToGrid(in Snapshot s, int equipIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			int num = s.BaseIndex + equipIndex;
			return new Vector2i(num % s.Width, num / s.Width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryGridToEquipIndex(in Snapshot s, Vector2i pos, out int equipIndex)
		{
			//IL_0003: 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)
			equipIndex = -1;
			int num = pos.y * s.Width + pos.x - s.BaseIndex;
			if (num < 0 || num >= s.EquipCount)
			{
				return false;
			}
			equipIndex = num;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EquipIndexToRowCol(in Snapshot s, int equipIndex, out int row, out int col)
		{
			row = equipIndex % s.EquipRowsPerColumn;
			col = equipIndex / s.EquipRowsPerColumn;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryGridToQuickIndex(in Snapshot s, Vector2i pos, out int quickIndex)
		{
			//IL_0003: 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)
			quickIndex = -1;
			int num = pos.y * s.Width + pos.x - s.BaseIndex - s.EquipCount;
			if (num < 0 || num >= s.QuickCount)
			{
				return false;
			}
			quickIndex = num;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2i QuickIndexToGrid(in Snapshot s, int quickIndex)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			int num = s.BaseIndex + s.EquipCount + quickIndex;
			return new Vector2i(num % s.Width, num / s.Width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static CellKind Classify(in Snapshot s, Vector2i pos, out int equipIdx, out int quickIdx)
		{
			//IL_0007: 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_001e: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			equipIdx = -1;
			quickIdx = -1;
			if (TryGridToEquipIndex(in s, pos, out equipIdx))
			{
				return CellKind.Equipment;
			}
			if (TryGridToQuickIndex(in s, pos, out quickIdx))
			{
				return CellKind.Quick;
			}
			if (pos.y >= 0 && pos.y < s.PlayerHeight && pos.x >= 0 && pos.x < s.Width)
			{
				return CellKind.Inventory;
			}
			return CellKind.Unknown;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsValidInventoryCell(in Snapshot s, Vector2i pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			int equipIdx;
			int quickIdx;
			return Classify(in s, pos, out equipIdx, out quickIdx) == CellKind.Inventory;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2i LeftInventoryEdge(in Snapshot s, int y)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(s.Width - 1, Math.Min(y, s.NormalInventoryHeight - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2i RightInventoryEdge(in Snapshot s, int y)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(0, Math.Min(y, s.NormalInventoryHeight - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2i TopInventoryEdge(in Snapshot s, int x)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(Mathf.Clamp(x, 0, s.Width - 1), 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2i BottomInventoryEdge(in Snapshot s, int x)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(Mathf.Clamp(x, 0, s.Width - 1), s.NormalInventoryHeight - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryMoveInInventory(in Snapshot s, Vector2i from, int dx, int dy, out Vector2i to)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			to = new Vector2i(from.x + dx, from.y + dy);
			if (!IsValidInventoryCell(in s, to))
			{
				to = from;
				return false;
			}
			return true;
		}

		internal static bool TryFindValidEquipmentSlot(in Snapshot s, int preferredRow, int preferredCol, out int equipIndex)
		{
			int num = Mathf.Clamp(preferredRow, 0, s.EquipRowsPerColumn - 1);
			int num2 = preferredCol;
			int equipIndex2;
			while (num2 >= 0 && !TryEquipIndexFromRowCol(in s, num, num2, out equipIndex2))
			{
				num2--;
				if (num2 < 0 && num > 0)
				{
					num--;
					num2 = s.EquipCols - 1;
				}
			}
			bool flag = TryEquipIndexFromRowCol(in s, num, num2, out equipIndex);
			return num2 >= 0 && flag;
		}
	}
	public static class KeyboardExtensions
	{
		[SpecialName]
		public sealed class <G>$8D1D3E80A18AA9715780B6CB7003B2F1
		{
			[SpecialName]
			public static class <M>$895AB635D4D087636CF1C26BA650BA11
			{
			}

			[ExtensionMarker("<M>$895AB635D4D087636CF1C26BA650BA11")]
			public bool IsKeyDown()
			{
				throw null;
			}

			[ExtensionMarker("<M>$895AB635D4D087636CF1C26BA650BA11")]
			public bool IsKeyHeld()
			{
				throw null;
			}
		}

		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}
	}
}
namespace AzuEPI.EPI
{
	internal class ExtendedPlayerInventory
	{
		internal static readonly List<Model.Slot?> slots = new List<Model.Slot>();

		internal static readonly GameObject _elementPrefab = null;

		internal static ItemData?[] equipItems = (ItemData?[])(object)new ItemData[15];

		public static Vector3 lastMousePos;

		public static string currentlyDragging = null;

		public static List<HotkeyBar> HotkeyBars { get; set; } = null;

		public static int SelectedHotkeyBarIndex { get; set; } = -1;

		public static Vector2 LastSlotPosition { get; set; }
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

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

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

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

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

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

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

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

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

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

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

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

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

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

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

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

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

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

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

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

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

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

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

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

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

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

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

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

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

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

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

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

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

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

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

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

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

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

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

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

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

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

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

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

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

		public override object? GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class Polyfills
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Contains(this string source, char c)
		{
			return source.IndexOf(c) != -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly Func<PropertyInfo, bool> IsInstance = (PropertyInfo property) => !(property.GetMethod ?? property.SetMethod).IsStatic;

		private static readonly Func<PropertyInfo, bool> IsInstancePublic = (PropertyInfo property) => IsInstance(property) && (property.GetMethod ?? property.SetMethod).IsPublic;

		public static Type? BaseType(this Type type)
		{
			return type.GetTypeInfo().BaseType;
		}

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

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

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

		public static Type? GetImplementationOfOpenGenericInterface(this Type type, Type openGenericType)
		{
			if (!openGenericType.IsGenericType || !openGenericType.IsInterface)
			{
				throw new ArgumentException("The type must be a generic type definition and an interface", "openGenericType");
			}
			if (IsGenericDefinitionOfType(type, openGenericType))
			{
				return type;
			}
			return type.FindInterfaces((Type t, object context) => IsGenericDefinitionOfType(t, context), openGenericType).FirstOrDefault();
			static bool IsGenericDefinitionOfType(Type t, object? context)
			{
				if (t.IsGenericType)
				{
					return t.GetGenericTypeDefinition() == (Type)context;
				}
				return false;
			}
		}

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

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

		public static bool IsRequired(this MemberInfo member)
		{
			return member.GetCustomAttributes(inherit: true).Any((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.RequiredMemberAttribute");
		}

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

		public static bool IsAssignableFrom(this Type type, Type source)
		{
			return type.IsAssignableFrom(source.GetTypeInfo());
		}

		public static bool IsAssignableFrom(this Type type, TypeInfo source)
		{
			return type.GetTypeInfo().IsAssignableFrom(source);
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			if (type.IsEnum())
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (type == typeof(bool))
			{
				return TypeCode.Boolean;
			}
			if (type == typeof(char))
			{
				return TypeCode.Char;
			}
			if (type == typeof(sbyte))
			{
				return TypeCode.SByte;
			}
			if (type == typeof(byte))
			{
				return TypeCode.Byte;
			}
			if (type == typeof(short))
			{
				return TypeCode.Int16;
			}
			if (type == typeof(ushort))
			{
				return TypeCode.UInt16;
			}
			if (type == typeof(int))
			{
				return TypeCode.Int32;
			}
			if (type == typeof(uint))
			{
				return TypeCode.UInt32;
			}
			if (type == typeof(long))
			{
				return TypeCode.Int64;
			}
			if (type == typeof(ulong))
			{
				return TypeCode.UInt64;
			}
			if (type == typeof(float))
			{
				return TypeCode.Single;
			}
			if (type == typeof(double))
			{
				return TypeCode.Double;
			}
			if (type == typeof(decimal))
			{
				return TypeCode.Decimal;
			}
			if (type == typeof(DateTime))
			{
				return TypeCode.DateTime;
			}
			if (type == typeof(string))
			{
				return TypeCode.String;
			}
			return TypeCode.Object;
		}

		public static bool IsDbNull(this object value)
		{
			return value?.GetType()?.FullName == "System.DBNull";
		}

		public static Type[] GetGenericArguments(this Type type)
		{
			return type.GetTypeInfo().GenericTypeArguments;
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetRuntimeField(name);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			Func<PropertyInfo, bool> predicate = (includeNonPublic ? IsInstance : IsInstancePublic);
			if (!type.IsInterface())
			{
				return type.GetRuntimeProperties().Where(predicate);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetRuntimeProperties().Where(predicate));
		}

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

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return from f in type.GetRuntimeFields()
				where !f.IsStatic && f.IsPublic
				select f;
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return from m in type.GetRuntimeMethods()
				where m.IsPublic && m.IsStatic
				select m;
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name)) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes.Length)
					{
						return parameters.Zip(parameterTypes, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name));
		}

		public static MethodInfo? GetGetMethod(this PropertyInfo property, bool nonPublic)
		{
			MethodInfo methodInfo = property.GetMethod;
			if (!nonPublic && !methodInfo.IsPublic)
			{
				methodInfo = null;
			}
			return methodInfo;
		}

		public static MethodInfo? GetSetMethod(this PropertyInfo property)
		{
			return property.SetMethod;
		}

		public static IEnumerable<Type> GetInterfaces(this Type type)
		{
			return type.GetTypeInfo().ImplementedInterfaces;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			if (!(o.GetType() == type))
			{
				return o.GetType().GetTypeInfo().IsSubclassOf(type);
			}
			return true;
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo member)
		{
			return Attribute.GetCustomAttributes(member, typeof(TAttribute), inherit: true);
		}

		public static bool AcceptsNull(this MemberInfo member)
		{
			object[] customAttributes = member.DeclaringType.GetCustomAttributes(inherit: true);
			object obj = customAttributes.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
			int num = 0;
			if (obj != null)
			{
				Type type = obj.GetType();
				PropertyInfo property = type.GetProperty("Flag");
				num = (byte)property.GetValue(obj);
			}
			object[] customAttributes2 = member.GetCustomAttributes(inherit: true);
			object obj2 = customAttributes2.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
			PropertyInfo propertyInfo = (obj2?.GetType())?.GetProperty("NullableFlags");
			byte[] source = (byte[])propertyInfo.GetValue(obj2);
			return source.Any((byte x) => x == 2) || num == 2;
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	internal abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

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

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

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

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

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

		public TBuilder WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			return Self;
		}

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

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

		public TBuilder WithAttributeOverride<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

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

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

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

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

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

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

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

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	internal sealed class Deserializer : IDeserializer
	{
		private readonly IValueDeserializer valueDeserializer;

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

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

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

		public T Deserialize<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize<object>(parser);
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public object? Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
	{
		private Lazy<IObjectFactory> objectFactory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		protected override DeserializerBuilder Self => this;

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

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

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

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

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

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

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

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

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

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

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

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

		public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public DeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

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

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

		public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (!DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			return this;
		}

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

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

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

		public IDeserializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;

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

		public IEventEmitter EventEmitter { get; private set; }

		public ObjectSerializer NestedObjectSerializer { get; private set; }

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

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

		public T GetPreProcessingPhaseObjectGraphVisitor<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

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

		public bool NeedsExpansion { get; set; }

		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

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

		public MappingStyle Style { get; set; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	internal interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(IParser parser, Type type);
	}
	internal interface IEventEmitter
	{
		void Emit(AliasEventInfo eventInfo, IEmitter emitter);

		void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
	}
	internal interface INamingConvention
	{
		string Apply(string value);

		string Reverse(string value);
	}
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer);
	}
	internal interface INodeTypeResolver
	{
		bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
	}
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		object? Read(string name, object target);
	}
	internal interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		public static object NonNullValue(this IObjectDescriptor objectDescriptor)
		{
			return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
		}
	}
	internal interface IObjectFactory
	{
		object Create(Type type);

		object? CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer);
	}
	internal interface IObjectGraphVisitor<TContext>
	{
		bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

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

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

		void VisitScalar(IObjectDescriptor scalar, TContext context, ObjectSerializer serializer);

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

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context, ObjectSerializer serializer);

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

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context, ObjectSerializer serializer);
	}
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

		T? GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	internal interface ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

		void Serialize(TextWriter writer, object? graph, Type type);

		void Serialize(IEmitter emitter, object? graph);

		void Serialize(IEmitter emitter, object? graph, Type type);
	}
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching);

		string GetEnumName(Type enumType, string name);

		string GetEnumValue(object enumValue);
	}
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	internal interface IValueDeserializer
	{
		object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	internal interface IValueSerializer
	{
		void SerializeValue(IEmitter emitter, object? value, Type? type);
	}
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	internal delegate object? ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer);

		void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

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

		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

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

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

		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

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

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

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

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

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

		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
				registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

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

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

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

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

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

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

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

		public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
		{
			return entries.Select((LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

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

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

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

		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public Type? ConverterType => baseDescriptor.ConverterType;

		public int Order { get; set; }

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

		public bool CanWrite => baseDescriptor.CanWrite;

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

		public void Write(object target, object? value)
		{
			baseDescriptor.Write(target, value);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	internal sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

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

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

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

		public string Serialize(object? graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public string Serialize(object? graph, Type type)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph, type);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, object? graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, object? graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, object? graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, object? graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		private void EmitDocument(IEmitter emitter, object? graph, Type? type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

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

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

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

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				traversalStrategy.Traverse(graph, visitor, emitter, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

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

		private readonly IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private ScalarStyle defaultScalarStyle;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override SerializerBuilder Self => this;

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

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

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

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

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory(e), where);
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner, BuildTypeInspector())));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

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

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

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

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

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

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

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

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(typeConverters)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(wrapped, typeConverters)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

		public ISerializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

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

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

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

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

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

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

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

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

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

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

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

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

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

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

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

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

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		protected override StaticDeserializerBuilder Self => this;

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

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

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

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

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

		public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public StaticDeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

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

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

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

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

		public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

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

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

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			typeMappings[typeFromHandle] = typeFromHandle2;
			return this;
		}

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

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

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

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

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

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

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

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

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

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

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private ScalarStyle defaultScalarStyle;

		protected override StaticSerializerBuilder Self => this;

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

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

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

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

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

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory(e), where);
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner, BuildTypeInspector())));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

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

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

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

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, ScalarStyle.Plain, YamlFormatter.Default, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

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

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

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

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(wrapped, typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

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

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

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal sealed class StreamFragment : IYamlConvertible
	{
		private readonly List<ParsingEvent> events = new List<ParsingEvent>();

		public IList<ParsingEvent> Events => events;

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

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			foreach (ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	internal sealed class TagMappings
	{
		private readonly Dictionary<string, Type> mappings;

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

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

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

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

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

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

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

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

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

		[return: MaybeNull]
		public T GetAttribute<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

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

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

		public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	internal sealed class YamlAttributeOverridesInspector : ReflectionTypeInspector
	{
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public Type? ConverterType => GetCustomAttribute<YamlConverterAttribute>()?.ConverterType ?? baseDescriptor.ConverterType;

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

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

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

			public void Write(object target, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				T attribute = overrides.GetAttribute<T>(classType, Name);
				return attribute ?? baseDescriptor.GetCustomAttribute<T>();
			}

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

		private readonly ITypeInspector innerTypeDescriptor;

		private readonly YamlAttributeOverrides overrides;

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

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

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(IPropertyDescriptor p)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
					YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
						}
						propertyDescriptor.Order = customAttribute.Order;
						propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							propertyDescriptor.Name = customAttribute.Alias;
						}
					}
					return propertyDescriptor;
				})
				orderby p.Order
				select p;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	internal sealed class YamlConverterAttribute : Attribute
	{
		public Type ConverterType { get; }

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	internal class YamlFormatter
	{
		public static YamlFormatter Default { get; } = new YamlFormatter();

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

		public virtual Func<object, ITypeInspector, INamingConvention, string> FormatEnum { get; set; } = delegate(object value, ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			string empty = string.Empty;
			empty = ((value != null) ? typeInspector.GetEnumValue(value) : string.Empty);
			return enumNamingConvention.Apply(empty);
		};

		public virtual Func<object, bool> PotentiallyQuoteEnums { get; set; } = (object _) => true;

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

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

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

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

		public string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan/*cast due to .constrained prefix*/).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlMemberAttribute : Attribute
	{
		private DefaultValuesHandling? defaultValuesHandling;

		public string? Description { get; set; }

		public Type? SerializeAs { get; set; }

		public int Order { get; set; }

		public string? Alias { get; set; }

		public bool ApplyNamingConventions { get; set; }

		public ScalarStyle ScalarStyle { get; set; }

		public DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public YamlMemberAttribute()
		{
			ScalarStyle = ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						throw new AnchorNotFoundException(alias.Start, alias.End, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		private sealed class ValuePromise : IValuePromise
		{
			private object? value;

			public readonly YamlDotNet.Core.Events.AnchorAlias? Alias;

			public bool HasValue { get; private set; }

			public object? Value
			{
				get
				{
					if (!HasValue)
					{
						throw new InvalidOperationException("Value not set");
					}
					return value;
				}
				set
				{
					if (HasValue)
					{
						throw new InvalidOperationException("Value already set");
					}
					HasValue = true;
					this.value = value;
					this.ValueAvailable?.Invoke(value);
				}
			}

			public event Action<object?>? ValueAvailable;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object? value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		private readonly IValueDeserializer innerDeserializer;

		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise value))
				{
					throw new AnchorNotFoundException(@event.Start, @event.End, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(anchorName))
				{
					aliasState2[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(anchorName, out ValuePromise value2))
				{
					aliasState3.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.typeInspector = typeInspector;
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			parser.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser, x, state, nestedObjectDeserializer);
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "Exception during deserialization", innerException);
			}
			throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
		{
			foreach (INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	internal interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly Dictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out object value))
				{
					return value;
				}
				throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
			}
		}

		public void Add(string anchor, object @object)
		{
			objectsByAnchor.Add(anchor, @object);
			if (@object != null)
			{
				anchorsByObject.Add(@object, anchor);
			}
		}

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class TypeConverter
	{
		public static T ChangeType<T>(object? value, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture, enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			if (value == null || value.IsDbNull())
			{
				if (!destinationType.IsValueType())
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (destinationType.IsGenericType())
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (destinationType.IsEnum())
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods())
				{
					if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
					{
						continue;
					}
					ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
					{
						try
						{
							return publicStaticMethod2.Invoke(null, new object[1] { value });
						}
						catch (TargetInvocationException ex)
						{
							throw ex.InnerException;
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ex2.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [NotNullWhen(true)] out IYamlTypeConverter? typeConverter)
		{
			(bool, IYamlTypeConverter) orAdd = DictionaryExtensions.GetOrAdd(cache, type, (Type t, IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public IYamlTypeConverter GetConverterByType(Type converter)
		{
			IYamlTypeConverter[] array = typeConverters;
			foreach (IYamlTypeConverter yamlTypeConverter in array)
			{
				if (yamlTypeConverter.GetType() == converter)
				{
					return yamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, IYamlTypeConverter[] typeConverters)
		{
			foreach (IYamlTypeConverter yamlTypeConverter in typeConverters)
			{
				if (yamlTypeConverter.Accepts(type))
				{
					return (HasMatch: true, TypeConverter: yamlTypeConverter);
				}
			}
			return (HasMatch: false, TypeConverter: null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class StaticTypeResolver : ITypeResolver
	{
		public virtual Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (actualValue.GetType().GetTypeCode())
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	internal class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return DictionaryExtensions.GetOrAdd(orAdd, name, delegate(string n, (Type enumType, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumType2, typeInspector) = context;
				return typeInspector.GetEnumName(enumType2, n);
			}, (enumType, innerTypeDescriptor));
		}

		public override string GetEnumValue(object enumValue)
		{
			return DictionaryExtensions.GetOrAdd(enumValueCache, enumValue, delegate(object _, (object enumValue, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumValue2, typeInspector) = context;
				return typeInspector.GetEnumValue(enumValue2);
			}, (enumValue, innerTypeDescriptor));
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return DictionaryExtensions.GetOrAdd(cache, type, delegate(Type t, (object container, ITypeInspector innerTypeDescriptor) context)
			{
				var (container2, typeInspector) = context;
				return typeInspector.GetProperties(t, container2).ToList();
			}, (container, innerTypeDescriptor));
		}
	}
	internal class CompositeTypeInspector : TypeInspectorSkeleton
	{
		private readonly IEnumerable<ITypeInspector> typeInspectors;

		public CompositeTypeInspector(params ITypeInspector[] typeInspectors)
			: this((IEnumerable<ITypeInspector>)typeInspectors)
		{
		}

		public CompositeTypeInspector(IEnumerable<ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumName(enumType, name);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumType,name", "Name not found on enum type");
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				throw new ArgumentNullException("enumValue");
			}
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumValue(enumValue);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumValue", $"Value not found for ({enumValue})");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	internal class NamingConventionTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly INamingConvention namingConvention;

		public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	internal class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal class ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(T), inherit: true);
				return (T)customAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		public ReadableFieldsTypeInspector(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal class ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanRead)
			{
				return property.GetGetMethod(nonPublic: true).GetParameters().Length == 0;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class ReflectionTypeInspector : TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching)
		{
			IEnumerable<IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	internal class WritablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanWrite)
			{
				return property.GetSetMethod(nonPublic: true).GetParameters().Length == 1;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class FailsafeSchema
	{
		public static class Tags
		{
			public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

			public static readonly TagName Seq = new TagName("tag:yaml.org,2002:seq");

			public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class JsonSchema
	{
		public static class Tags
		{
			public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

			public static readonly TagName Bool = new TagName("tag:yaml.org,2002:bool");

			public static readonly TagName Int = new TagName("tag:yaml.org,2002:int");

			public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly Dictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value, ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer)
		{
		}

		private void VisitObject(IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		AnchorName IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	internal sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEventEmitter eventEmitter;

		private readonly IAliasProvider aliasProvider;

		private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

		public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (value.Value != null)
			{
				AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					AliasEventInfo aliasEventInfo = new AliasEventInfo(value, alias);
					eventEmitter.Emit(aliasEventInfo, context);
					return aliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (value.Value is IYamlConvertible yamlConvertible)
			{
				yamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is IYamlSerializable yamlSerializable)
			{
				yamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}
	}
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		private static object? GetDefault(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}
	}
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		private readonly IObjectFactory factory;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValuesHandling defaultValuesHandling = handling;
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitNull) != DefaultValuesHandling.Preserve && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != DefaultValuesHandling.Preserve && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != DefaultValuesHandling.Preserve)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>()));
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context, ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer);

		protected abstract void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		protected readonly struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly IObjectDescriptor Value;

			public ObjectPathSegment(object name, IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly ITypeInspector typeDescriptor;

		private readonly ITypeResolver typeResolver;

		private readonly INamingConvention namingConvention;

		private readonly IObjectFactory objectFactory;

		public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, IObjectFactory objectFactory)
		{
			if (maxRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
			}
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.maxRecursion = maxRecursion;
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		void IObjectGraphTraversalStrategy.Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(IPropertyDescriptor? propertyDescriptor, object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(propertyDescriptor, value, context, serializer))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = value.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
				case TypeCode.Char:
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
				case TypeCode.DateTime:
				case TypeCode.String:
					visitor.VisitScalar(value, context, serializer);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (value.IsDbNull())
				{
					visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(IPropertyDescriptor propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache converters;

		private readonly Settings settings;

		public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, Settings settings, IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	internal class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			}
		};

		private readonly Dictionary<Type, Type> defaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> defaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				defaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (type.IsInterface())
			{
				Type value2;
				if (type.IsGenericType())
				{
					if (defaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out Type value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (defaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType, inherit: true).Length != 0).ToArray();
			});
		}
	}
	internal sealed class LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	internal abstract class StaticObjectFactory : IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	internal class MappingNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> mappings;

		public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				throw new YamlException(nodeEvent.Start, nodeEvent.End, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	internal sealed class TagNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<TagName, Type> tagMappings;

		public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public ArrayNodeDeserializer(INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value2)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value2, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	internal abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public CollectionNodeDeserializer(IObjectFactory objectFactory, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != null;
					list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, INamingConvention enumNamingConvention, ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
					if (promiseResolvedHandler != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem, enumNamingConvention, typeInspector);
						};
					}
				}
				else
				{
					result.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem, enumNamingConvention, typeInspector));
				}
			}
		}
	}
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += delegate(object? v)
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result[key] = v;
				};
			}
		}
	}
	internal class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary, rootDeserializer);
			return true;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class FsharpListNodeDeserializer : INodeDeserializer
	{
		private readonly ITypeInspector typeInspector;

		private readonly INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static bool NodeIsNull(NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.Scalar { Style: ScalarStyle.Plain, IsKey: false } scalar)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Mark start = Mark.Empty;
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					throw new YamlException(propertyName.Start, propertyName.End, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
				}
				catch (SerializationException ex)
				{
					throw new YamlException(propertyName.Start, propertyName.End, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					throw new YamlException(propertyName.Start, propertyName.End, "Exception during deserialization", innerException);
				}
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, IPropertyDescriptor property, YamlDotNet.Core.Events.Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				throw new YamlException(propertyName.Start, propertyName.End, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	internal sealed class ScalarNodeDeserializer : INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		private readonly ITypeInspector typeInspector;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, ITypeInspector typeInspector, YamlFormatter formatter, INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				value = DeserializeBooleanHelper(@event.Value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				value = DeserializeIntegerHelper(typeCode, @event.Value);
				break;
			case TypeCode.Single:
				value = float.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""), CultureInfo.InvariantCulture);
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		private object? AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.Scalar value)
		{
			if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal sealed class StaticCollectionNodeDeserializer : INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					int index = result.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (objectFactory.IsDictionary(expectedType))
			{
				if (!(objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = objectFactory.GetKeyType(expectedType);
				Type valueType = objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser, expectedType, (Type type) => nestedObjectDeserializer(parser, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToPascalCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	internal abstract class ChainedEventEmitter : IEventEmitter
	{
		protected readonly IEventEmitter nextEmitter;

		protected ChainedEventEmitter(IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum())
					{
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? ScalarStyle.Plain : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		private readonly Regex? isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN|\\s.*)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		private readonly ScalarStyle defaultScalarStyle;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			ScalarStyle style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	internal sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	internal class DateTime8601Converter : IYamlTypeConverter
	{
		private readonly ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, doubleQuotes ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}

		private static DateTime EnsureDateTimeKind(DateTime dt, DateTimeKind kind)
		{
			if (dt.Kind == DateTimeKind.Local && kind == DateTimeKind.Utc)
			{
				return dt.ToUniversalTime();
			}
			if (dt.Kind == DateTimeKind.Utc && kind == DateTimeKind.Local)
			{
				return dt.ToLocalTime();
			}
			return dt;
		}
	}
	internal class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(IFormatProvider? provider = null, ScalarStyle style = ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTimeOffset);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class GuidConverter : IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		private readonly LinkedList<ParsingEvent> buffer;

		private LinkedListNode<ParsingEvent>? current;

		public ParsingEvent? Current => current?.Value;

		public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<MappingStart>());
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
				buffer.AddLast(parsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	internal class TypeDiscriminatingNodeDeserializer : INodeDeserializer
	{
		private readonly IList<INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType2 = expectedType;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				throw new YamlException(in start, reader.Current.End, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType2 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				throw new YamlException(in start, reader.Current.End, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType2, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, out Type? suggestedType);
	}
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar2) => targetKey == scalar2.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar && typeMapping.TryGetValue(scalar.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.Scalar key, out ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class DocumentLoadingState
	{
		private readonly Dictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly List<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();

		public void AddAnchor(YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			anchors[node.Anchor] = node;
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();
	}
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	internal class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private static void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class YamlDocument
	{
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			AnchorAssigningVisitor anchorAssigningVisitor = new AnchorAssigningVisitor();
			anchorAssigningVisitor.AssignAnchors(this);
		}

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly OrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();

		public IOrderedDictionary<YamlNode, YamlNode> Children => children;

		public MappingStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Mapping;

		internal YamlMappingNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			MappingStart mappingStart = parser.Consume<MappingStart>();
			Load(mappingStart, state);
			Style = mappingStart.Style;
			bool flag = false;
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
				if (!children.TryAdd(yamlNode, yamlNode2))
				{
					throw new YamlException(yamlNode.Start, yamlNode.End, $"Duplicate key {yamlNode}");
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = (child.Value.Anchor.IsEmpty ? YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value) : YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			return num;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				foreach (YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<YamlNode, YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}

		public static YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			YamlMappingNode yamlMappingNode = new YamlMappingNode();
			foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						yamlNode = text ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	internal abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;

		public Mark End { get; private set; } = Mark.Empty;

		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out YamlNode node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			string text = scalar.Value;
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		public YamlScalarNode(string? value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (forceImplicitPlain && Style == ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == ScalarStyle.Plain || Style == ScalarStyle.Any))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
			{
				return object.Equals(Value, yamlScalarNode.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		public static explicit operator string?(YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly List<YamlNode> children = new List<YamlNode>();

		public IList<YamlNode> Children => children;

		public SequenceStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Sequence;

		internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			SequenceStart sequenceStart = parser.Consume<SequenceStart>();
			Load(sequenceStart, state);
			Style = sequenceStart.Style;
			bool flag = false;
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				children.Add(yamlNode);
				flag = flag || yamlNode is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlSequenceNode()
		{
		}

		public YamlSequenceNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlSequenceNode(IEnumerable<YamlNode> children)
		{
			foreach (YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new YamlScalarNode(child));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new SequenceEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], yamlSequenceNode.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (YamlNode child in children)
			{
				h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
			}
			return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (YamlNode child in children)
			{
				foreach (YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public IEnumerator<YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly List<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class YamlVisitor : IYamlVisitor
	{
		protected virtual void Visit(YamlStream stream)
		{
		}

		protected virtual void Visited(YamlStream stream)
		{
		}

		protected virtual void Visit(YamlDocument document)
		{
		}

		protected virtual void Visited(YamlDocument document)
		{
		}

		protected virtual void Visit(YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void IYamlVisitor.Visit(YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void IYamlVisitor.Visit(YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void IYamlVisitor.Visit(YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void IYamlVisitor.Visit(YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void IYamlVisitor.Visit(YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	internal abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	internal class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	internal static class ExpressionExtensions
	{
		public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
		{
			PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
			if (propertyInfo == null)
			{
				throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
			}
			return propertyInfo;
		}

		[return: MaybeNull]
		private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	internal static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object? value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

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

		public bool Contains(object? value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object? value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, object? value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.ContainsKey(item);
			}

			public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Key;
				}
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.ContainsValue(item);
			}

			public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Value;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

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

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	internal readonly struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

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

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

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

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

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct CharacterAnalyzer<TBuffer> where TBuffer : ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = buffer;
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	internal static class Constants
	{
		public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
		{
			new TagDirective("!", "!"),
			new TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class Cursor
	{
		public long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1L;
		}

		public Cursor(Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public Mark Mark()
		{
			return new Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	internal class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] NewLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private EmitterState state;

		private readonly Stack<EmitterState> states = new Stack<EmitterState>();

		private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly bool useUtf16SurrogatePair;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public Emitter(TextWriter output)
			: this(output, EmitterSettings.Default)
		{
		}

		public Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public Emitter(TextWriter output, EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				ParsingEvent evt = events.Peek();
				try
				{
					AnalyzeEvent(evt);
					StateMachine(evt);
				}
				finally
				{
					events.Dequeue();
				}
			}
		}

		private bool NeedMoreEvents()
		{
			if (events.Count == 0)
			{
				return true;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.DocumentStart:
				num = 1;
				break;
			case EventType.SequenceStart:
				num = 2;
				break;
			case EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			foreach (ParsingEvent @event in events)
			{
				switch (@event.Type)
				{
				case EventType.DocumentStart:
				case EventType.SequenceStart:
				case EventType.MappingStart:
					num2++;
					break;
				case EventType.DocumentEnd:
				case EventType.SequenceEnd:
				case EventType.MappingEnd:
					num2--;
					break;
				}
				if (num2 == 0)
				{
					return false;
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				bool flag3 = true;
				bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
				bool flag5 = false;
				bool flag6 = false;
				bool flag7 = false;
				bool flag8 = false;
				bool flag9 = false;
				bool flag10 = false;
				bool flag11 = false;
				bool flag12 = false;
				bool flag13 = false;
				bool flag14 = false;
				bool flag15 = false;
				bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
				bool flag17 = false;
				bool flag18 = false;
				bool flag19 = true;
				while (!characterAnalyzer.EndOfInput)
				{
					if (flag19)
					{
						if (characterAnalyzer.Check("#,[]{}&*!|>\"%@`'"))
						{
							flag = true;
							flag2 = true;
							flag9 = characterAnalyzer.Check('\'');
							flag17 |= characterAnalyzer.Check('\'');
						}
						if (characterAnalyzer.Check("?:"))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('-') && flag4)
						{
							flag = true;
							flag2 = true;
						}
					}
					else
					{
						if (characterAnalyzer.Check(",?[]{}"))
						{
							flag = true;
						}
						if (characterAnalyzer.Check(':'))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('#') && flag3)
						{
							flag = true;
							flag2 = true;
						}
						flag17 |= characterAnalyzer.Check('\'');
					}
					if (!flag16 && !characterAnalyzer.IsPrintable())
					{
						flag16 = true;
					}
					if (characterAnalyzer.IsBreak())
					{
						flag15 = true;
					}
					if (characterAnalyzer.IsSpace())
					{
						if (flag19)
						{
							flag5 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag7 = true;
						}
						if (flag13)
						{
							flag10 = true;
							flag14 = true;
						}
						flag12 = true;
						flag13 = false;
					}
					else if (characterAnalyzer.IsBreak())
					{
						if (flag19)
						{
							flag6 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag8 = true;
						}
						if (flag12)
						{
							flag11 = true;
						}
						if (flag14)
						{
							flag18 = true;
						}
						flag12 = false;
						flag13 = true;
					}
					else
					{
						flag12 = false;
						flag13 = false;
						flag14 = false;
					}
					flag3 = characterAnalyzer.IsWhiteBreakOrZero();
					characterAnalyzer.Skip(1);
					if (!characterAnalyzer.EndOfInput)
					{
						flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
					}
					flag19 = false;
				}
				scalarData.IsFlowPlainAllowed = true;
				scalarData.IsBlockPlainAllowed = true;
				scalarData.IsSingleQuotedAllowed = true;
				scalarData.IsBlockAllowed = true;
				if (flag5 || flag6 || flag7 || flag8 || flag9)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag7)
				{
					scalarData.IsBlockAllowed = false;
				}
				if (flag10)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag11 || flag16)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag18)
				{
					scalarData.IsBlockAllowed = false;
				}
				scalarData.IsMultiline = flag15;
				if (flag15)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag)
				{
					scalarData.IsFlowPlainAllowed = false;
				}
				if (flag2)
				{
					scalarData.IsBlockPlainAllowed = false;
				}
				scalarData.HasSingleQuotes = flag17;
			}
			finally
			{
				((IDisposable)bufferWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string text = output.Encoding.GetString(bytes, 0, bytes.Length);
				return text.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (TagDirective tagDirective in tagDirectives)
			{
				if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
				{
					tagData.Handle = tagDirective.Handle;
					tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
					break;
				}
			}
		}

		private void StateMachine(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case EmitterState.StreamEnd:
				throw new YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.Comment comment)
		{
			if (flowLevel > 0 || state == EmitterState.FlowMappingFirstKey || state == EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(NewLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == EmitterState.BlockMappingFirstKey;
				if (flag)
				{
					IncreaseIndent(isFlow: false, isIndentless: false);
				}
				string[] array2 = array;
				foreach (string value in array2)
				{
					WriteIndent();
					Write("# ");
					Write(value);
					WriteBreak();
				}
				if (flag)
				{
					indent = indents.Pop();
				}
			}
			isIndentation = true;
		}

		private void EmitStreamStart(ParsingEvent evt)
		{
			if (!(evt is YamlDotNet.Core.Events.StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(ParsingEvent evt, bool isFirst)
		{
			if (evt is YamlDotNet.Core.Events.DocumentStart documentStart)
			{
				bool flag = documentStart.IsImplicit && isFirst && !isCanonical;
				TagDirectiveCollection tagDirectiveCollection = NonDefaultTagsAmong(documentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (documentStart.Version != null || tagDirectiveCollection.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (documentStart.Version != null)
				{
					AnalyzeVersionDirective(documentStart.Version);
					Version version = documentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (TagDirective item in tagDirectiveCollection)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
				foreach (TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					TagDirective[] defaultTagDirectives2 = Constants.DefaultTagDirectives;
					foreach (TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, allowDuplicates: true, tagDirectiveCollection);
					}
					foreach (TagDirective item2 in tagDirectiveCollection)
					{
						WriteIndicator("%TAG", needWhitespace: true, whitespace: false, indentation: false);
						WriteTagHandle(item2.Handle);
						WriteTagContent(item2.Prefix, needsWhitespace: true);
						WriteIndent();
					}
				}
				if (CheckEmptyDocument())
				{
					flag = false;
				}
				if (!flag)
				{
					WriteIndent();
					WriteIndicator("---", needWhitespace: true, whitespace: false, indentation: false);
					if (isCanonical)
					{
						WriteIndent();
					}
				}
				state = EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is YamlDotNet.Core.Events.StreamEnd))
				{
					throw new YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = EmitterState.StreamEnd;
			}
		}

		private static TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<TagDirective>? tagCollection)
		{
			TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
			if (tagCollection == null)
			{
				return tagDirectiveCollection;
			}
			foreach (TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			foreach (TagDirective item in defaultTagDirectives)
			{
				tagDirectiveCollection.Remove(item);
			}
			return tagDirectiveCollection;
		}

		private static void AnalyzeVersionDirective(VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(TagDirective value, bool allowDuplicates, TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(ParsingEvent evt)
		{
			states.Push(EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case EventType.Alias:
				EmitAlias();
				break;
			case EventType.Scalar:
				EmitScalar(evt);
				break;
			case EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(ParsingEvent evt)
		{
			YamlDotNet.Core.Events.Scalar scalar = (YamlDotNet.Core.Events.Scalar)evt;
			ScalarStyle scalarStyle = scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !scalar.IsPlainImplicit && !scalar.IsQuotedImplicit)
			{
				throw new YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (scalarStyle == ScalarStyle.Any)
			{
				scalarStyle = ((!scalarData.IsMultiline) ? ScalarStyle.Plain : ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					scalarStyle = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
				if (flag && !scalar.IsPlainImplicit)
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
			}
			if (scalarStyle == ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if ((scalarStyle == ScalarStyle.Literal || scalarStyle == ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.ForcePlain)
			{
				scalarStyle = ScalarStyle.Plain;
			}
			scalarData.Style = scalarStyle;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case ScalarStyle.Folded:
				WriteFoldedScalar(scalarData.Value);
				break;
			default:
				throw new InvalidOperationException();
			}
		}

		private void WritePlainScalar(string value, bool allowBreaks)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsSpace(c))
				{
					if (allowBreaks && !flag && column > bestWidth && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteSingleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("'", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == ' ')
				{
					if (allowBreaks && !flag && column > bestWidth && i != 0 && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				if (c == '\'')
				{
					Write(c);
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			WriteIndicator("'", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteDoubleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("\"", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsPrintable(c) && !IsBreak(c, out var _))
				{
					switch (c)
					{
					case '"':
					case '\\':
						break;
					case ' ':
						if (allowBreaks && !flag && column > bestWidth && i > 0 && i + 1 < value.Length)
						{
							WriteIndent();
							if (value[i + 1] == ' ')
							{
								Write('\\');
							}
						}
						else
						{
							Write(c);
						}
						flag = true;
						continue;
					default:
						Write(c);
						flag = false;
						continue;
					}
				}
				Write('\\');
				switch (c)
				{
				case '\0':
					Write('0');
					break;
				case '\a':
					Write('a');
					break;
				case '\b':
					Write('b');
					break;
				case '\t':
					Write('t');
					break;
				case '\n':
					Write('n');
					break;
				case '\v':
					Write('v');
					break;
				case '\f':
					Write('f');
					break;
				case '\r':
					Write('r');
					break;
				case '\u001b':
					Write('e');
					break;
				case '"':
					Write('"');
					break;
				case '\\':
					Write('\\');
					break;
				case '\u0085':
					Write('N');
					break;
				case '\u00a0':
					Write('_');
					break;
				case '\u2028':
					Write('L');
					break;
				case '\u2029':
					Write('P');
					break;
				default:
				{
					ushort num = c;
					if (num <= 255)
					{
						Write('x');
						Write(num.ToString("X02", CultureInfo.InvariantCulture));
					}
					else if (IsHighSurrogate(c))
					{
						if (i + 1 >= value.Length || !IsLowSurrogate(value[i + 1]))
						{
							throw new SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							Write('U');
							Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						}
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			SequenceStart sequenceStart = (SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
			{
				state = EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			MappingStart mappingStart = (MappingStart)evt;
			if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
			{
				state = EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = EmitterState.BlockMappingFirstKey;
			}
		}

		private void ProcessAnchor()
		{
			if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
			{
				WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
				WriteAnchor(anchorData.Anchor);
			}
		}

		private void ProcessTag()
		{
			if (tagData.Handle == null && tagData.Suffix == null)
			{
				return;
			}
			if (tagData.Handle != null)
			{
				WriteTagHandle(tagData.Handle);
				if (tagData.Suffix != null)
				{
					WriteTagContent(tagData.Suffix, needsWhitespace: false);
				}
			}
			else
			{
				WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
				WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void EmitDocumentEnd(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
			{
				WriteIndent();
				if (!documentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is SequenceEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
			}
			else
			{
				if (!isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				}
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				states.Push(EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is MappingEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
				return;
			}
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			if (!isCanonical && CheckSimpleKey())
			{
				states.Push(EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
			}
			states.Push(EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private static int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				if (characterAnalyzer.IsSpace() || characterAnalyzer.IsBreak())
				{
					int num = bestIndent;
					string indicator = num.ToString(CultureInfo.InvariantCulture);
					WriteIndicator(indicator, needWhitespace: false, whitespace: false, indentation: false);
				}
				string text = null;
				if (value.Length == 0 || !characterAnalyzer.IsBreak(value.Length - 1))
				{
					text = "-";
				}
				else if (value.Length >= 2 && characterAnalyzer.IsBreak(value.Length - 2))
				{
					text = "+";
				}
				if (text != null)
				{
					WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, delegate(Match match)
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat(CultureInfo.InvariantCulture, "%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	internal sealed class EmitterSettings
	{
		public static readonly EmitterSettings Default = new EmitterSettings();

		public int BestIndent { get; } = 2;

		public int BestWidth { get; } = int.MaxValue;

		public string NewLine { get; } = Environment.NewLine;

		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;

		public bool IndentSequences { get; }

		public bool UseUtf16SurrogatePairs { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings Canonical()
		{
			return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithoutAnchorName()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithUtf16SurrogatePairs()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal static class HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object? o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object? obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!initialCapacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The initial capacity must be a power of 2.", "initialCapacity");
			}
			items = new T[initialCapacity];
			readPtr = initialCapacity / 2;
			writePtr = initialCapacity / 2;
			mask = initialCapacity - 1;
		}

		public void Enqueue(T item)
		{
			ResizeIfNeeded();
			items[writePtr] = item;
			writePtr = (writePtr - 1) & mask;
			count++;
		}

		public T Dequeue()
		{
			if (count == 0)
			{
				throw new InvalidOperationException("The queue is empty");
			}
			T result = items[readPtr];
			readPtr = (readPtr - 1) & mask;
			count--;
			return result;
		}

		public void Insert(int index, T item)
		{
			if (index > count)
			{
				throw new InvalidOperationException("Cannot insert outside of the bounds of the queue");
			}
			ResizeIfNeeded();
			CalculateInsertionParameters(mask, count, index, ref readPtr, ref writePtr, out var insertPtr, out var copyIndex, out var copyOffset, out var copyLength);
			if (copyLength != 0)
			{
				Array.Copy(items, copyIndex, items, copyIndex + copyOffset, copyLength);
			}
			items[insertPtr] = item;
			count++;
		}

		private void ResizeIfNeeded()
		{
			int num = items.Length;
			if (count == num)
			{
				T[] destinationArray = new T[num * 2];
				int num2 = readPtr + 1;
				if (num2 > 0)
				{
					Array.Copy(items, 0, destinationArray, 0, num2);
				}
				writePtr += num;
				int num3 = num - num2;
				if (num3 > 0)
				{
					Array.Copy(items, readPtr + 1, destinationArray, writePtr + 1, num3);
				}
				items = destinationArray;
				mask = mask * 2 + 1;
			}
		}

		internal static void CalculateInsertionParameters(int mask, int count, int index, ref int readPtr, ref int writePtr, out int insertPtr, out int copyIndex, out int copyOffset, out int copyLength)
		{
			int num = (readPtr + 1) & mask;
			if (index == 0)
			{
				insertPtr = (readPtr = num);
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			insertPtr = (readPtr - index) & mask;
			if (index == count)
			{
				writePtr = (writePtr - 1) & mask;
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			int num2 = ((num >= insertPtr) ? (readPtr - insertPtr) : int.MaxValue);
			int num3 = ((writePtr <= insertPtr) ? (insertPtr - writePtr) : int.MaxValue);
			if (num2 <= num3)
			{
				insertPtr++;
				readPtr++;
				copyIndex = insertPtr;
				copyOffset = 1;
				copyLength = num2;
			}
			else
			{
				copyIndex = writePtr + 1;
				copyOffset = -1;
				copyLength = num3;
				writePtr = (writePtr - 1) & mask;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			int ptr = readPtr;
			for (int i = 0; i < Count; i++)
			{
				yield return items[ptr];
				ptr = (ptr - 1) & mask;
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[DebuggerStepThrough]
	internal sealed class LookAheadBuffer : ILookAheadBuffer
	{
		private readonly TextReader input;

		private readonly char[] buffer;

		private readonly int blockSize;

		private readonly int mask;

		private int firstIndex;

		private int writeOffset;

		private int count;

		private bool endOfInput;

		public bool EndOfInput
		{
			get
			{
				if (endOfInput)
				{
					return count == 0;
				}
				return false;
			}
		}

		public LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!capacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The capacity must be a power of 2.", "capacity");
			}
			this.input = input ?? throw new ArgumentNullException("input");
			blockSize = capacity;
			buffer = new char[capacity * 2];
			mask = capacity * 2 - 1;
		}

		private int GetIndexForOffset(int offset)
		{
			return (firstIndex + offset) & mask;
		}

		public char Peek(int offset)
		{
			if (offset >= count)
			{
				FillBuffer();
			}
			if (offset < count)
			{
				return buffer[(firstIndex + offset) & mask];
			}
			return '\0';
		}

		public void Cache(int length)
		{
			if (length >= count)
			{
				FillBuffer();
			}
		}

		private void FillBuffer()
		{
			if (endOfInput)
			{
				return;
			}
			int num = blockSize;
			do
			{
				int num2 = input.Read(buffer, writeOffset, num);
				if (num2 == 0)
				{
					endOfInput = true;
					return;
				}
				num -= num2;
				writeOffset += num2;
				count += num2;
			}
			while (num > 0);
			if (writeOffset == buffer.Length)
			{
				writeOffset = 0;
			}
		}

		public void Skip(int length)
		{
			if (length < 1 || length > blockSize)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
			}
			firstIndex = GetIndexForOffset(length);
			count -= length;
		}
	}
	internal readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object? obj)
		{
			return Equals((Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object? obj)
		{
			return CompareTo((Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}

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

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

		public static bool operator <(Mark left, Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(Mark left, Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(Mark left, Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(Mark left, Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	internal sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class MergingParser : IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private static IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart { Anchor: { IsEmpty: false } anchor })
				{
					references[anchor] = node;
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				clonedEvent = new SequenceEnd(e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingStart e)
			{
				clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingEnd e)
			{
				clonedEvent = new MappingEnd(e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly IParser innerParser;

		private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

		private bool merged;

		public ParsingEvent? Current => iterator.Current?.Value;

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						throw new SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private static bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner parsingEventCloner = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(parsingEventCloner.Clone);
		}
	}
	internal class Parser : IParser
	{
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		private Token? currentToken;

		private VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public ParsingEvent? Current { get; private set; }

		private Token? GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public Parser(TextReader input)
			: this(new Scanner(input))
		{
		}

		public Parser(IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private ParsingEvent StateMachine()
		{
			return state switch
			{
				ParserState.StreamStart => ParseStreamStart(), 
				ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				ParserState.DocumentContent => ParseDocumentContent(), 
				ParserState.DocumentEnd => ParseDocumentEnd(), 
				ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private YamlDotNet.Core.Events.StreamStart ParseStreamStart()
		{
			Token token = GetCurrentToken();
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			return new YamlDotNet.Core.Events.StreamStart(streamStart.Start, streamStart.End);
		}

		private ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is VersionDirective)
			{
				throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			Token token = GetCurrentToken();
			if (!isImplicit)
			{
				while (token is YamlDotNet.Core.Tokens.DocumentEnd)
				{
					Skip();
					token = GetCurrentToken();
				}
			}
			if (token == null)
			{
				throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
			{
				TagDirectiveCollection tags = new TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(ParserState.DocumentEnd);
				state = ParserState.BlockNode;
				return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
			}
			if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
			{
				Mark start = token.Start;
				TagDirectiveCollection tags2 = new TagDirectiveCollection();
				VersionDirective versionDirective = ProcessDirectives(tags2);
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
				{
					throw new SemanticErrorException(token.Start, token.End, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end);
			}
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
			}
			state = ParserState.StreamEnd;
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(token.Start, token.End);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		private VersionDirective? ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						throw new SemanticErrorException(tagDirective.Start, tagDirective.End, "Found duplicate %TAG directive.");
					}
					tags.Add(tagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
				{
					version = new VersionDirective(new Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
		{
			foreach (TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
			{
				state = states.Pop();
				return ProcessEmptyScalar(scanner.CurrentPosition);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static YamlDotNet.Core.Events.Scalar ProcessEmptyScalar(in Mark position)
		{
			return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, string.Empty, ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			if (GetCurrentToken() is Error { Start: var start } error)
			{
				throw new SemanticErrorException(in start, error.End, error.Value);
			}
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				state = states.Pop();
				ParsingEvent result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
				Skip();
				return result;
			}
			Mark start2 = token.Start;
			AnchorName anchor = AnchorName.Empty;
			TagName tag = TagName.Empty;
			Anchor anchor2 = null;
			Tag tag2 = null;
			while (true)
			{
				if (anchor.IsEmpty && token is Anchor anchor3)
				{
					anchor2 = anchor3;
					anchor = anchor3.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(token is Tag tag3))
					{
						if (token is Anchor { Start: var start3 } anchor4)
						{
							throw new SemanticErrorException(in start3, anchor4.End, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias { Start: var start4 } anchorAlias2)
						{
							throw new SemanticErrorException(in start4, anchorAlias2.End, "While parsing a node, did not find expected token.");
						}
						if (!(token is Error error2))
						{
							break;
						}
						if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
						}
						throw new SemanticErrorException(error2.Start, error2.End, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							throw new SemanticErrorException(tag3.Start, tag3.End, "While parsing a node, found undefined tag handle.");
						}
						tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
					}
					Skip();
				}
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
			{
				state = ParserState.IndentlessSequenceEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				ParsingEvent result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start2, scalar.End, scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is Error)
					{
						Error error3 = currentToken as Error;
						throw new SemanticErrorException(error3.Start, error3.End, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && !(scanner.Current is FlowMappingEnd) && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						throw new SemanticErrorException(currentToken.Start, currentToken.End, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (token is FlowSequenceStart flowSequenceStart)
			{
				state = ParserState.FlowSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
			}
			throw new SemanticErrorException(token.Start, token.End, "While parsing a node, did not find expected node content.");
		}

		private YamlDotNet.Core.Events.DocumentEnd ParseDocumentEnd()
		{
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			Mark start = token.Start;
			Mark end = start;
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				end = token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is YamlDotNet.Core.Tokens.StreamEnd) && !(currentToken is YamlDotNet.Core.Tokens.DocumentStart) && !(currentToken is FlowSequenceEnd) && !(currentToken is VersionDirective) && (!(Current is YamlDotNet.Core.Events.Scalar) || !(currentToken is Error)))
			{
				throw new SemanticErrorException(in start, in end, "Did not find expected <document end>.");
			}
			if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
			{
				version = null;
			}
			state = ParserState.DocumentStart;
			return new YamlDotNet.Core.Events.DocumentEnd(isImplicit, start, end);
		}

		private ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is BlockEntry { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				ParsingEvent result = new SequenceEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			return new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			if (token is Value value)
			{
				Skip();
				return ProcessEmptyScalar(value.End);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				ParsingEvent result = new MappingEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error { Start: var start } error)
			{
				throw new SyntaxErrorException(in start, error.End, error.Value);
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			if (token is Error { Start: var start } error)
			{
				throw new SemanticErrorException(in start, error.End, error.Value);
			}
			state = ParserState.BlockMappingKey;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			ParsingEvent result;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					result = new MappingStart(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			result = new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
			Skip();
			return result;
		}

		private ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			Token token = GetCurrentToken();
			if (!(token is Value) && !(token is FlowEntry) && !(token is FlowSequenceEnd))
			{
				states.Push(ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			Mark position = token?.End ?? Mark.Empty;
			Skip();
			state = ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(in position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowSequenceEntryMappingEnd;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (token is Key)
				{
					Skip();
					token = GetCurrentToken();
					if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
					{
						states.Push(ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = ParserState.FlowMappingValue;
					return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
				}
				if (token is YamlDotNet.Core.Tokens.Scalar)
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (!isEmpty && token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowMappingKey;
			if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
			}
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				throw new YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [MaybeNullWhen(false)] out YamlDotNet.Core.Events.Scalar? key, [MaybeNullWhen(false)] out ParsingEvent? value)
		{
			if (parser.TryConsume<MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.Scalar scalar))
					{
						if (current is MappingStart || current is SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool flag = selector(scalar);
					parser.MoveNext();
					if (flag)
					{
						value = parser.Current;
						key = scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum ParserState
	{
		StreamStart,
		StreamEnd,
		ImplicitDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		BlockNode,
		BlockNodeOrIndentlessSequence,
		FlowNode,
		BlockSequenceFirstEntry,
		BlockSequenceEntry,
		IndentlessSequenceEntry,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingValue,
		FlowSequenceFirstEntry,
		FlowSequenceEntry,
		FlowSequenceEntryMappingKey,
		FlowSequenceEntryMappingValue,
		FlowSequenceEntryMappingEnd,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingValue,
		FlowMappingEmptyValue
	}
	internal sealed class RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	internal enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded,
		ForcePlain
	}
	internal class Scanner : IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<long> indents = new Stack<long>();

		private readonly InsertionQueue<Token> tokens = new InsertionQueue<Token>();

		private readonly Stack<SimpleKey> simpleKeys = new Stack<SimpleKey>();

		private readonly CharacterAnalyzer<LookAheadBuffer> analyzer;

		private readonly Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private long indent = -1L;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		private Token? previous;

		private Anchor? previousAnchor;

		private YamlDotNet.Core.Tokens.Scalar? lastScalar;

		private readonly int maxKeySize;

		private static readonly byte[] EmptyBytes = Array.Empty<byte>();

		public bool SkipComments { get; private set; }

		public Token? Current { get; private set; }

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public Scanner(TextReader input, bool skipComments = true)
			: this(input, skipComments, 1024)
		{
		}

		public Scanner(TextReader input, bool skipComments, int maxKeySize)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
			this.maxKeySize = maxKeySize;
		}

		public bool MoveNext()
		{
			if (Current != null)
			{
				ConsumeCurrent();
			}
			return MoveNextWithoutConsuming();
		}

		public bool MoveNextWithoutConsuming()
		{
			if (!tokenAvailable && !streamEndProduced)
			{
				FetchMoreTokens();
			}
			if (tokens.Count > 0)
			{
				Current = tokens.Dequeue();
				tokenAvailable = false;
				return true;
			}
			Current = null;
			return false;
		}

		public void ConsumeCurrent()
		{
			tokensParsed++;
			tokenAvailable = false;
			previous = Current;
			Current = null;
		}

		private char ReadCurrentCharacter()
		{
			char result = analyzer.Peek(0);
			Skip();
			return result;
		}

		private char ReadLine()
		{
			if (analyzer.Check("\r\n\u0085"))
			{
				SkipLine();
				return '\n';
			}
			char result = analyzer.Peek(0);
			SkipLine();
			return result;
		}

		private void FetchMoreTokens()
		{
			while (true)
			{
				bool flag = false;
				if (tokens.Count == 0)
				{
					flag = true;
				}
				else
				{
					foreach (SimpleKey simpleKey in simpleKeys)
					{
						if (simpleKey.IsPossible && simpleKey.TokenNumber == tokensParsed)
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					break;
				}
				FetchNextToken();
			}
			tokenAvailable = true;
		}

		private static bool StartsWith(StringBuilder what, char start)
		{
			if (what.Length > 0)
			{
				return what[0] == start;
			}
			return false;
		}

		private void StaleSimpleKeys()
		{
			foreach (SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + maxKeySize < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("While scanning a simple key, could not find expected ':'.", mark, mark));
					}
					simpleKey.MarkAsImpossible();
				}
			}
		}

		private void FetchNextToken()
		{
			if (!streamStartProduced)
			{
				FetchStreamStart();
				return;
			}
			ScanToNextToken();
			StaleSimpleKeys();
			UnrollIndent(cursor.LineOffset);
			analyzer.Buffer.Cache(4);
			if (analyzer.Buffer.EndOfInput)
			{
				lastScalar = null;
				FetchStreamEnd();
			}
			if (cursor.LineOffset == 0L && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchQuotedScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchQuotedScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
				}
				if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
				{
					Skip();
				}
				flowScalarFetched = false;
				flowCollectionFetched = false;
				startFlowCollectionFetched = false;
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
			}
			else
			{
				if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
				{
					throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark start = cursor.Mark();
					Skip();
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamStart(in start, in start));
		}

		private void UnrollIndent(long column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark start = cursor.Mark();
					tokens.Enqueue(new BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private Token? ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in start);
			}
			else
			{
				if (!(previous is YamlDotNet.Core.Tokens.DocumentStart) && !(previous is YamlDotNet.Core.Tokens.StreamStart) && !(previous is YamlDotNet.Core.Tokens.DocumentEnd))
				{
					throw new SemanticErrorException(in start, cursor.Mark(), "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in start, cursor.Mark()));
				return;
			}
			Token token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					token = new Error("While scanning a document end, found invalid content after '...' marker.", start, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(in start, in start));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Token item = ((!isSequenceToken) ? ((Token)new FlowMappingStart(in start, in start)) : ((Token)new FlowSequenceStart(in start, in start)));
			tokens.Enqueue(item);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Token token = null;
			Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					token = new Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
				}
				item = new FlowSequenceEnd(in start, in start);
			}
			else
			{
				item = new FlowMappingEnd(in start, in start);
			}
			tokens.Enqueue(item);
			if (token != null)
			{
				tokens.Enqueue(token);
			}
			flowCollectionFetched = true;
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new FlowEntry(in start, in end));
			}
		}

		private void FetchBlockEntry()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						throw new SemanticErrorException(previousAnchor.Start, previousAnchor.End, "Anchor before sequence entry on same line is not allowed.");
					}
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new BlockEntry(in start, cursor.Mark()));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start2 = cursor.Mark();
			Skip();
			tokens.Enqueue(new Key(in start2, cursor.Mark()));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible)
			{
				tokens.Insert(simpleKey.TokenNumber - tokensParsed, new Key(simpleKey.Mark, simpleKey.Mark));
				RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
				simpleKey.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0L && simpleKey.LineOffset == 0L)
					{
						tokens.Insert(tokens.Count, new Key(simpleKey.Mark, simpleKey.Mark));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new Value(in start, cursor.Mark()));
		}

		private void RollIndent(long column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				Token item = ((!isSequence) ? ((Token)new BlockMappingStart(in position, in position)) : ((Token)new BlockSequenceStart(in position, in position)));
				if (number == -1)
				{
					tokens.Enqueue(item);
				}
				else
				{
					tokens.Insert(number - tokensParsed, item);
				}
			}
		}

		private void FetchAnchor(bool isAlias)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanAnchor(isAlias));
		}

		private Token ScanAnchor(bool isAlias)
		{
			Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				SimpleKey simpleKey = simpleKeys.Peek();
				flag = simpleKey.IsRequired && simpleKey.IsPossible;
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private Tag ScanTag()
		{
			Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private YamlDotNet.Core.Tokens.Scalar ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						long currentIndent = 0L;
						bool flag = false;
						bool? isFirstLine = null;
						Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine == true)
							{
								isFirstLine = false;
							}
						}
						Mark end = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end);
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine == true)
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine == true)
			{
				long num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", mark, mark));
			}
		}

		private YamlDotNet.Core.Tokens.Scalar ScanFlowScalar(bool isSingleQuoted)
		{
			Mark start = cursor.Mark();
			Skip();
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							while (true)
							{
								if (IsDocumentIndicator())
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4/*cast due to .constrained prefix*/).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private YamlDotNet.Core.Tokens.Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							long num = indent + 1;
							Mark start = cursor.Mark();
							Mark end = start;
							SimpleKey simpleKey = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!simpleKey.IsPossible || !simpleKey.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !simpleKey.IsPossible)
										{
											tokens.Enqueue(new Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new InvalidOperationException();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4/*cast due to .constrained prefix*/).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				throw new SyntaxErrorException(simpleKey.Mark, simpleKey.Mark, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(in Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private VersionDirective ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private TagDirective ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(string? head, Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					throw new SyntaxErrorException(cursor.Mark(), cursor.Mark(), "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private string ScanUriEscapes(in Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string text = Encoding.UTF8.GetString(array, 0, count);
			if (text.Length == 0 || text.Length > 2)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return text;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	internal class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long LineOffset => cursor.LineOffset;

		public Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public SimpleKey()
		{
			cursor = new Cursor();
		}

		public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new Cursor(cursor);
		}
	}
	internal sealed class StringLookAheadBuffer : ILookAheadBuffer, IResettable
	{
		public string Value { get; set; } = string.Empty;

		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return Value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= Value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	internal sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
	{
		public TagDirectiveCollection()
		{
		}

		public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
		{
			foreach (TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	internal readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

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

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

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

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

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

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

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

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

		public static implicit operator TagName(string? value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		public override bool Equals(object? obj)
		{
			if (obj is Version version && Major == version.Major)
			{
				return Minor == version.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(in Mark.Empty, in Mark.Empty, message)
		{
		}

		public YamlException(in Mark start, in Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(in Mark.Empty, in Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class Anchor : Token
	{
		public AnchorName Value { get; }

		public Anchor(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public Anchor(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class AnchorAlias : Token
	{
		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Comment : Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	internal sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Key(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Scalar : Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public ScalarStyle Style { get; }

		public Scalar(string value)
			: this(value, ScalarStyle.Any)
		{
		}

		public Scalar(string value, ScalarStyle style)
			: this(value, style, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value, ScalarStyle style, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Tag : Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public Tag(string handle, string suffix)
			: this(handle, suffix, Mark.Empty, Mark.Empty)
		{
		}

		public Tag(string handle, string suffix, Mark start, Mark end)
			: base(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	internal class TagDirective : Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public TagDirective(string handle, string prefix)
			: this(handle, prefix, Mark.Empty, Mark.Empty)
		{
		}

		public TagDirective(string handle, string prefix, Mark start, Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	internal abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Value : Token
	{
		public Value()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Value(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class VersionDirective : Token
	{
		public Version Version { get; }

		public VersionDirective(Version version)
			: this(version, Mark.Empty, Mark.Empty)
		{
		}

		public VersionDirective(Version version, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		public override bool Equals(object? obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

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

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;

		public int MaximumRetainedCapacity { get; set; } = 4096;

		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly StringLookAheadBuffer Buffer;

			private readonly ObjectPool<StringLookAheadBuffer> pool;

			public BufferWrapper(StringLookAheadBuffer buffer, ObjectPool<StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

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

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			StringLookAheadBuffer stringLookAheadBuffer = Pool.Get();
			stringLookAheadBuffer.Value = value;
			return new BufferWrapper(stringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class Comment : ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override EventType Type => EventType.Comment;

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	internal sealed class DocumentEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public DocumentEnd(bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			IsImplicit = isImplicit;
		}

		public DocumentEnd(bool isImplicit)
			: this(isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class DocumentStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.DocumentStart;

		public TagDirectiveCollection? Tags { get; }

		public VersionDirective? Version { get; }

		public bool IsImplicit { get; }

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	internal interface IParsingEventVisitor
	{
		void Visit(AnchorAlias e);

		void Visit(StreamStart e);

		void Visit(StreamEnd e);

		void Visit(DocumentStart e);

		void Visit(DocumentEnd e);

		void Visit(Scalar e);

		void Visit(SequenceStart e);

		void Visit(SequenceEnd e);

		void Visit(MappingStart e);

		void Visit(MappingEnd e);

		void Visit(Comment e);
	}
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public MappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class MappingStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public MappingStyle Style { get; }

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public MappingStart()
			: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	internal abstract class ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract EventType Type { get; }

		public Mark Start { get; }

		public Mark End { get; }

		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Scalar : NodeEvent
	{
		internal override EventType Type => EventType.Scalar;

		public string Value { get; }

		public ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public bool IsKey { get; }

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value)
			: this(AnchorName.Empty, TagName.Empty, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(TagName tag, string value)
			: this(AnchorName.Empty, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(AnchorName anchor, TagName tag, string value)
			: this(anchor, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Scalar [anchor = {base.Anchor}, tag = {base.Tag}, value = {Value}, style = {Style}, isPlainImplicit = {IsPlainImplicit}, isQuotedImplicit = {IsQuotedImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public SequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

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

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

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

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

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

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

		public string[] Members { get; }

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

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

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

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