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.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
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.RepresentationModel;
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("InventorySlots")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("sighsorry")]
[assembly: AssemblyProduct("InventorySlots")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("A57F2112-F59E-48EF-9D76-F2E4580F7401")]
[assembly: AssemblyFileVersion("1.3.3")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.3.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;
		}
	}
}
namespace LocalizationManager
{
	internal static class Localizer
	{
		private static readonly string[] FileExtensions = new string[2] { ".yml", ".json" };

		private static readonly ManualLogSource Log = Logger.CreateLogSource("InventorySlots.Localization");

		private static BaseUnityPlugin? _plugin;

		private static bool _loaded;

		public static event Action? OnLocalizationComplete;

		public static void Load(BaseUnityPlugin plugin)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			_plugin = plugin;
			if (_loaded)
			{
				TryLoadCurrentLanguage();
				return;
			}
			_loaded = true;
			PatchLocalization(new Harmony(plugin.Info.Metadata.GUID + ".LocalizationManager"));
			TryLoadCurrentLanguage();
		}

		private static void PatchLocalization(Harmony harmony)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Localizer), "LocalizationSetupLanguagePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			MethodInfo methodInfo2 = AccessTools.DeclaredMethod(typeof(FejdStartup), "SetupGui", (Type[])null, (Type[])null);
			if (methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(Localizer), "FejdStartupSetupGuiPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void LocalizationSetupLanguagePostfix(Localization __instance, string language)
		{
			LoadLocalization(__instance, language);
		}

		private static void FejdStartupSetupGuiPostfix()
		{
			TryLoadCurrentLanguage();
		}

		private static void TryLoadCurrentLanguage()
		{
			if (Localization.instance != null)
			{
				LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
			}
		}

		private static void LoadLocalization(Localization localization, string language)
		{
			if ((Object)(object)_plugin == (Object)null || localization == null)
			{
				return;
			}
			Dictionary<string, string> dictionary = LoadLanguageDictionary("English");
			if (!string.Equals(language, "English", StringComparison.OrdinalIgnoreCase))
			{
				Merge(dictionary, LoadLanguageDictionary(language));
			}
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				localization.AddWord(item.Key, item.Value);
			}
			Localizer.OnLocalizationComplete?.Invoke();
		}

		private static Dictionary<string, string> LoadLanguageDictionary(string language)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Merge(dictionary, LoadEmbeddedLanguage(language));
			foreach (string item in FindExternalTranslationFiles(language))
			{
				try
				{
					Merge(dictionary, ParseTranslations(File.ReadAllText(item), item));
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Failed to load localization file " + item + ": " + ex.Message));
				}
			}
			return dictionary;
		}

		private static Dictionary<string, string> LoadEmbeddedLanguage(string language)
		{
			string[] fileExtensions = FileExtensions;
			foreach (string text in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + text);
				if (array != null)
				{
					return ParseTranslations(Encoding.UTF8.GetString(array), language + text);
				}
			}
			if (string.Equals(language, "English", StringComparison.OrdinalIgnoreCase))
			{
				Log.LogWarning((object)"Found no embedded English localization for InventorySlots.");
			}
			return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
		}

		private static IEnumerable<string> FindExternalTranslationFiles(string language)
		{
			if ((Object)(object)_plugin == (Object)null)
			{
				yield break;
			}
			string modName = _plugin.Info.Metadata.Name;
			foreach (string root in GetExternalTranslationRoots())
			{
				if (!Directory.Exists(root))
				{
					continue;
				}
				string[] fileExtensions = FileExtensions;
				foreach (string text in fileExtensions)
				{
					string searchPattern = modName + "." + language + text;
					string[] files = Directory.GetFiles(root, searchPattern, SearchOption.AllDirectories);
					for (int j = 0; j < files.Length; j++)
					{
						yield return files[j];
					}
				}
			}
		}

		private static IEnumerable<string> GetExternalTranslationRoots()
		{
			if (!string.IsNullOrWhiteSpace(Paths.PluginPath))
			{
				yield return Paths.PluginPath;
			}
			if ((Object)(object)_plugin != (Object)null)
			{
				yield return Path.Combine(Paths.ConfigPath, _plugin.Info.Metadata.GUID + "Translations");
			}
		}

		private static Dictionary<string, string> ParseTranslations(string text, string source)
		{
			try
			{
				return new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text) ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to parse localization source " + source + ": " + ex.Message));
				return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			}
		}

		private static void Merge(Dictionary<string, string> target, Dictionary<string, string> source)
		{
			foreach (KeyValuePair<string, string> item in source)
			{
				target[item.Key] = item.Value;
			}
		}

		private static byte[]? ReadEmbeddedFileBytes(string resourceFileName)
		{
			if ((Object)(object)_plugin == (Object)null)
			{
				return null;
			}
			Assembly assembly = ((object)_plugin).GetType().Assembly;
			string text = assembly.GetManifestResourceNames().FirstOrDefault((string name) => name.EndsWith(resourceFileName, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				return null;
			}
			using Stream stream = assembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace InventorySlots
{
	[BepInPlugin("sighsorry.InventorySlots", "InventorySlots", "1.3.3")]
	[BepInIncompatibility("Azumatt.AzuExtendedPlayerInventory")]
	[BepInIncompatibility("shudnal.ExtraSlots")]
	[BepInIncompatibility("shudnal.ExtraSlotsCustomSlots")]
	[BepInIncompatibility("randyknapp.mods.equipmentandquickslots")]
	[BepInIncompatibility("com.bruce.valheim.comfyquickslots")]
	[BepInIncompatibility("goldenrevolver.quick_stack_store")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class InventorySlotsPlugin : BaseUnityPlugin
	{
		private sealed class AzuCraftyBoxesApi
		{
			private readonly MethodInfo _getNearbyContainersMethod;

			private readonly MethodInfo _canItemBePulledMethod;

			private readonly MethodInfo? _shouldPreventMethod;

			private readonly FieldInfo? _rangeField;

			private readonly FieldInfo? _leaveOneField;

			private readonly FieldInfo? _resourceStringField;

			private readonly FieldInfo? _flashColorField;

			private readonly FieldInfo? _unFlashColorField;

			private readonly Dictionary<Type, MethodInfo?> _getPrefabNameMethods = new Dictionary<Type, MethodInfo>();

			private readonly Dictionary<Type, MethodInfo?> _itemCountMethods = new Dictionary<Type, MethodInfo>();

			private ConfigEntryBase? _rangeConfig;

			private ConfigEntryBase? _leaveOneConfig;

			private ConfigEntryBase? _resourceStringConfig;

			private ConfigEntryBase? _flashColorConfig;

			private ConfigEntryBase? _unFlashColorConfig;

			private AzuCraftyBoxesApi(MethodInfo getNearbyContainersMethod, MethodInfo canItemBePulledMethod, MethodInfo? shouldPreventMethod, FieldInfo? rangeField, FieldInfo? leaveOneField, FieldInfo? resourceStringField, FieldInfo? flashColorField, FieldInfo? unFlashColorField)
			{
				_getNearbyContainersMethod = getNearbyContainersMethod;
				_canItemBePulledMethod = canItemBePulledMethod;
				_shouldPreventMethod = shouldPreventMethod;
				_rangeField = rangeField;
				_leaveOneField = leaveOneField;
				_resourceStringField = resourceStringField;
				_flashColorField = flashColorField;
				_unFlashColorField = unFlashColorField;
			}

			public static bool TryCreate(Assembly assembly, out AzuCraftyBoxesApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetType("AzuCraftyBoxes.API");
				Type type2 = assembly.GetType("AzuCraftyBoxes.AzuCraftyBoxesPlugin");
				Type type3 = assembly.GetType("AzuCraftyBoxes.Util.Functions.MiscFunctions");
				MethodInfo methodInfo = (type?.GetMethods(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((MethodInfo method) => method.Name == "GetNearbyContainers" && method.IsGenericMethodDefinition && method.GetParameters().Length == 2))?.MakeGenericMethod(typeof(Player));
				MethodInfo methodInfo2 = type?.GetMethod("CanItemBePulled", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(string),
					typeof(string)
				}, null);
				if (methodInfo == null || methodInfo2 == null)
				{
					detail = "required API methods were not found";
					return false;
				}
				api = new AzuCraftyBoxesApi(methodInfo, methodInfo2, type3?.GetMethod("ShouldPrevent", BindingFlags.Static | BindingFlags.NonPublic), type2?.GetField("mRange", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), type2?.GetField("leaveOne", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), type2?.GetField("resourceString", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), type2?.GetField("flashColor", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), type2?.GetField("unFlashColor", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic));
				detail = "";
				return true;
			}

			public IEnumerable? GetNearbyContainers(Player player, float range)
			{
				return _getNearbyContainersMethod.Invoke(null, new object[2] { player, range }) as IEnumerable;
			}

			public bool CanItemBePulled(string containerPrefab, string itemPrefab)
			{
				try
				{
					object obj = _canItemBePulledMethod.Invoke(null, new object[2] { containerPrefab, itemPrefab });
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public bool ShouldPrevent()
			{
				if (_shouldPreventMethod == null)
				{
					return false;
				}
				try
				{
					object obj = _shouldPreventMethod.Invoke(null, null);
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public float GetRange()
			{
				object cachedConfigEntryValue = GetCachedConfigEntryValue(_rangeField, ref _rangeConfig);
				if (cachedConfigEntryValue == null)
				{
					return 20f;
				}
				try
				{
					return Convert.ToSingle(cachedConfigEntryValue);
				}
				catch
				{
					return 20f;
				}
			}

			public bool GetLeaveOne()
			{
				string a = GetCachedConfigEntryValue(_leaveOneField, ref _leaveOneConfig)?.ToString() ?? "";
				if (!string.Equals(a, "On", StringComparison.OrdinalIgnoreCase))
				{
					return string.Equals(a, "True", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}

			public string InvokeString(object instance, string methodName)
			{
				Type type = instance.GetType();
				if (!_getPrefabNameMethods.TryGetValue(type, out MethodInfo value))
				{
					value = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);
					_getPrefabNameMethods[type] = value;
				}
				try
				{
					return (value?.Invoke(instance, null) as string) ?? "";
				}
				catch
				{
					return "";
				}
			}

			public int InvokeInt(object instance, string methodName, string argument)
			{
				Type type = instance.GetType();
				if (!_itemCountMethods.TryGetValue(type, out MethodInfo value))
				{
					value = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
					_itemCountMethods[type] = value;
				}
				try
				{
					return (value?.Invoke(instance, new object[1] { argument }) is int num) ? num : 0;
				}
				catch
				{
					return 0;
				}
			}

			public bool TryFormatRequirementAmount(int available, int required, out string text)
			{
				text = "";
				string text2 = (GetCachedConfigEntryValue(_resourceStringField, ref _resourceStringConfig) as string) ?? "";
				if (string.IsNullOrWhiteSpace(text2))
				{
					text = required.ToString();
					return true;
				}
				try
				{
					text = string.Format(text2, FormatThousands(available), required);
					return true;
				}
				catch
				{
					text = $"{FormatThousands(available)}/{required}";
					return true;
				}
			}

			public bool TryGetRequirementFlashColor(out Color color)
			{
				//IL_0001: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				color = default(Color);
				FieldInfo fieldInfo = ((Mathf.Sin(Time.time * 10f) > 0f) ? _flashColorField : _unFlashColorField);
				if (((fieldInfo == _flashColorField) ? GetCachedConfigEntryValue(fieldInfo, ref _flashColorConfig) : GetCachedConfigEntryValue(fieldInfo, ref _unFlashColorConfig)) is Color val)
				{
					color = val;
					return true;
				}
				return false;
			}

			private object? GetCachedConfigEntryValue(FieldInfo? field, ref ConfigEntryBase? config)
			{
				if (field == null)
				{
					return null;
				}
				try
				{
					if (config == null)
					{
						object? value = field.GetValue(null);
						config = (ConfigEntryBase?)((value is ConfigEntryBase) ? value : null);
					}
					ConfigEntryBase? obj = config;
					return (obj != null) ? obj.BoxedValue : null;
				}
				catch
				{
					config = null;
					return null;
				}
			}

			private static string FormatThousands(int number)
			{
				if (number >= 1000000)
				{
					return ((double)number / 1000000.0).ToString("0.#") + "M";
				}
				if (number < 1000)
				{
					return number.ToString();
				}
				return ((double)number / 1000.0).ToString("0.#") + "K";
			}
		}

		private sealed class AdventureBackpacksApi
		{
			private readonly MethodInfo _isBackpackMethod;

			private readonly MethodInfo? _equipItemPostfixMethod;

			private readonly MethodInfo? _unequipItemPrefixMethod;

			private readonly MethodInfo? _isBackpackEquippedMethod;

			private readonly MethodInfo? _isThisBackpackEquippedMethod;

			private readonly MethodInfo? _getEquippedBackpackMethod;

			private readonly MethodInfo? _reorderBonesMethod;

			private readonly FieldInfo? _backpackEquippedField;

			private AdventureBackpacksApi(MethodInfo isBackpackMethod, MethodInfo? equipItemPostfixMethod, MethodInfo? unequipItemPrefixMethod, MethodInfo? isBackpackEquippedMethod, MethodInfo? isThisBackpackEquippedMethod, MethodInfo? getEquippedBackpackMethod, MethodInfo? reorderBonesMethod, FieldInfo? backpackEquippedField)
			{
				_isBackpackMethod = isBackpackMethod;
				_equipItemPostfixMethod = equipItemPostfixMethod;
				_unequipItemPrefixMethod = unequipItemPrefixMethod;
				_isBackpackEquippedMethod = isBackpackEquippedMethod;
				_isThisBackpackEquippedMethod = isThisBackpackEquippedMethod;
				_getEquippedBackpackMethod = getEquippedBackpackMethod;
				_reorderBonesMethod = reorderBonesMethod;
				_backpackEquippedField = backpackEquippedField;
			}

			public static bool TryCreate(Assembly assembly, out AdventureBackpacksApi? api, out string detail)
			{
				api = null;
				MethodInfo methodInfo = assembly.GetType("AdventureBackpacks.API.ABAPI")?.GetMethod("IsBackpack", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, null);
				if (methodInfo == null)
				{
					detail = "AdventureBackpacks.API.ABAPI.IsBackpack was not found";
					return false;
				}
				Type? type = assembly.GetType("AdventureBackpacks.Patches.HumanoidPatches");
				Type type2 = type?.GetNestedType("HumanoidEquipItemPatch", BindingFlags.NonPublic);
				Type type3 = type?.GetNestedType("HumanoidUnequipItemPatch", BindingFlags.NonPublic);
				Type type4 = assembly.GetType("AdventureBackpacks.Extensions.PlayerExtensions");
				Type type5 = assembly.GetType("AdventureBackpacks.Patches.InventoryGuiPatches");
				Type type6 = assembly.GetType("Vapok.Common.Tools.BoneReorder");
				api = new AdventureBackpacksApi(methodInfo, type2?.GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic), type3?.GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic), type4?.GetMethod("IsBackpackEquipped", BindingFlags.Static | BindingFlags.Public), type4?.GetMethod("IsThisBackpackEquipped", BindingFlags.Static | BindingFlags.Public), type4?.GetMethod("GetEquippedBackpack", BindingFlags.Static | BindingFlags.Public), AccessTools.Method(type6, "ReorderBones", (Type[])null, (Type[])null), type5?.GetField("BackpackEquipped", BindingFlags.Static | BindingFlags.Public));
				detail = "";
				return true;
			}

			public bool IsBackpack(ItemData? item)
			{
				if (item == null)
				{
					return false;
				}
				try
				{
					object obj = _isBackpackMethod.Invoke(null, new object[1] { item });
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public bool IsBackpackEquippedFlagSet()
			{
				try
				{
					object obj = _backpackEquippedField?.GetValue(null);
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public void OnCustomBackpackEquipped(Player player, ItemData item)
			{
				if ((Object)(object)player == (Object)null || item == null || !IsBackpack(item))
				{
					return;
				}
				try
				{
					_equipItemPostfixMethod?.Invoke(null, new object[2] { item, true });
					_backpackEquippedField?.SetValue(null, true);
				}
				catch (Exception)
				{
				}
			}

			public void OnCustomBackpackUnequipping(Player player, ItemData item)
			{
				if ((Object)(object)player == (Object)null || item == null || !IsBackpack(item))
				{
					return;
				}
				ItemData shoulderItem = ((Humanoid)player).m_shoulderItem;
				try
				{
					((Humanoid)player).m_shoulderItem = item;
					_unequipItemPrefixMethod?.Invoke(null, new object[1] { item });
				}
				catch (Exception)
				{
				}
				finally
				{
					((Humanoid)player).m_shoulderItem = shoulderItem;
				}
			}

			public void ReorderBones(VisEquipment visEquipment, int itemHash, List<GameObject>? instances)
			{
				if (_reorderBonesMethod == null || IsUnityNull((Object?)(object)visEquipment) || instances == null || instances.Count == 0)
				{
					return;
				}
				try
				{
					_reorderBonesMethod.Invoke(null, new object[3] { visEquipment, itemHash, instances });
				}
				catch
				{
				}
			}

			public void ApplyPatches(Harmony harmony)
			{
				PatchOptional(harmony, _isBackpackEquippedMethod, null, "AdventureBackpackIsBackpackEquippedPostfix", "AdventureBackpacks IsBackpackEquipped");
				PatchOptional(harmony, _isThisBackpackEquippedMethod, null, "AdventureBackpackIsThisBackpackEquippedPostfix", "AdventureBackpacks IsThisBackpackEquipped");
				PatchOptional(harmony, _getEquippedBackpackMethod, "AdventureBackpackGetEquippedBackpackPrefix", "AdventureBackpackGetEquippedBackpackPostfix", "AdventureBackpacks GetEquippedBackpack");
			}

			private static void PatchOptional(Harmony harmony, MethodInfo? target, string? prefix = null, string? postfix = null, string? label = null)
			{
				//IL_004b: 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)
				if (harmony != null && !(target == null))
				{
					MethodInfo methodInfo = ((prefix == null) ? null : AccessTools.Method(typeof(InventorySlotsPlugin), prefix, (Type[])null, (Type[])null));
					MethodInfo methodInfo2 = ((postfix == null) ? null : AccessTools.Method(typeof(InventorySlotsPlugin), postfix, (Type[])null, (Type[])null));
					harmony.Patch((MethodBase)target, (methodInfo == null) ? ((HarmonyMethod)null) : new HarmonyMethod(methodInfo), (methodInfo2 == null) ? ((HarmonyMethod)null) : new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private sealed class SmoothbrainBackpacksApi
		{
			private readonly MethodInfo _validateBackpackMethod;

			private readonly FieldInfo _visualsField;

			private readonly FieldInfo _equippedBackpackItemField;

			private readonly FieldInfo? _currentBackpackItemHashField;

			private readonly MethodInfo? _setBackpackItemMethod;

			private readonly MethodInfo? _forceSetBackpackEquippedMethod;

			private SmoothbrainBackpacksApi(MethodInfo validateBackpackMethod, FieldInfo visualsField, FieldInfo equippedBackpackItemField, FieldInfo? currentBackpackItemHashField, MethodInfo? setBackpackItemMethod, MethodInfo? forceSetBackpackEquippedMethod)
			{
				_validateBackpackMethod = validateBackpackMethod;
				_visualsField = visualsField;
				_equippedBackpackItemField = equippedBackpackItemField;
				_currentBackpackItemHashField = currentBackpackItemHashField;
				_setBackpackItemMethod = setBackpackItemMethod;
				_forceSetBackpackEquippedMethod = forceSetBackpackEquippedMethod;
			}

			public static bool TryCreate(Assembly assembly, out SmoothbrainBackpacksApi? api, out string detail)
			{
				api = null;
				Type? type = assembly.GetType("Backpacks.Backpacks");
				Type type2 = assembly.GetType("Backpacks.Visual");
				MethodInfo methodInfo = type?.GetMethod("validateBackpack", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[1] { typeof(ItemData) }, null);
				FieldInfo fieldInfo = type2?.GetField("visuals", BindingFlags.Static | BindingFlags.Public);
				FieldInfo fieldInfo2 = type2?.GetField("equippedBackpackItem", BindingFlags.Instance | BindingFlags.Public);
				if (methodInfo == null || fieldInfo == null || fieldInfo2 == null)
				{
					detail = "validateBackpack or Visual fields were not found";
					return false;
				}
				api = new SmoothbrainBackpacksApi(methodInfo, fieldInfo, fieldInfo2, type2?.GetField("currentBackpackItemHash", BindingFlags.Instance | BindingFlags.Public), type2?.GetMethod("setBackpackItem", BindingFlags.Instance | BindingFlags.NonPublic), type2?.GetMethod("forceSetBackpackEquipped", BindingFlags.Instance | BindingFlags.Public));
				detail = "";
				return true;
			}

			public bool IsBackpack(ItemData? item)
			{
				if (item == null)
				{
					return false;
				}
				try
				{
					object obj = _validateBackpackMethod.Invoke(null, new object[1] { item });
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public void SyncEquippedBackpack(Player player, ItemData? item)
			{
				if ((Object)(object)player == (Object)null || IsUnityNull((Object?)(object)((Humanoid)player).m_visEquipment) || !TryGetVisual(((Humanoid)player).m_visEquipment, out object visual) || visual == null)
				{
					return;
				}
				try
				{
					string text = (((Object)(object)item?.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : "");
					int num = ((!string.IsNullOrWhiteSpace(text)) ? StringExtensionMethods.GetStableHashCode(text) : 0);
					if (_equippedBackpackItemField.GetValue(visual) != item)
					{
						_equippedBackpackItemField.SetValue(visual, item);
					}
					_setBackpackItemMethod?.Invoke(visual, new object[1] { text });
					if (_forceSetBackpackEquippedMethod != null && GetCurrentHash(visual) != num)
					{
						_forceSetBackpackEquippedMethod.Invoke(visual, new object[1] { num });
					}
				}
				catch (Exception)
				{
				}
			}

			private bool TryGetVisual(VisEquipment visEquipment, out object? visual)
			{
				visual = null;
				if (!(_visualsField.GetValue(null) is IDictionary dictionary) || !dictionary.Contains(visEquipment))
				{
					return false;
				}
				visual = dictionary[visEquipment];
				return visual != null;
			}

			private int GetCurrentHash(object visual)
			{
				try
				{
					return (_currentBackpackItemHashField?.GetValue(visual) is int num) ? num : 0;
				}
				catch
				{
					return 0;
				}
			}
		}

		private sealed class RustyBagsApi
		{
			private readonly MethodInfo _isBagMethod;

			private readonly MethodInfo _isQuiverMethod;

			private readonly Type _bagEquipmentType;

			private readonly Type _bagType;

			private readonly Type _quiverType;

			private readonly MethodInfo _getBagMethod;

			private readonly MethodInfo _getQuiverMethod;

			private readonly MethodInfo _setBagMethod;

			private readonly MethodInfo _setQuiverMethod;

			private RustyBagsApi(MethodInfo isBagMethod, MethodInfo isQuiverMethod, Type bagEquipmentType, Type bagType, Type quiverType, MethodInfo getBagMethod, MethodInfo getQuiverMethod, MethodInfo setBagMethod, MethodInfo setQuiverMethod)
			{
				_isBagMethod = isBagMethod;
				_isQuiverMethod = isQuiverMethod;
				_bagEquipmentType = bagEquipmentType;
				_bagType = bagType;
				_quiverType = quiverType;
				_getBagMethod = getBagMethod;
				_getQuiverMethod = getQuiverMethod;
				_setBagMethod = setBagMethod;
				_setQuiverMethod = setQuiverMethod;
			}

			public static bool TryCreate(Assembly assembly, out RustyBagsApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetType("RustyBags.API");
				Type type2 = assembly.GetType("RustyBags.BagEquipment");
				Type type3 = assembly.GetType("RustyBags.Bag");
				Type type4 = assembly.GetType("RustyBags.Quiver");
				MethodInfo methodInfo = type?.GetMethod("IsBag", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
				MethodInfo methodInfo2 = type?.GetMethod("IsQuiver", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
				MethodInfo methodInfo3 = type2?.GetMethod("GetBag", BindingFlags.Instance | BindingFlags.Public);
				MethodInfo methodInfo4 = type2?.GetMethod("GetQuiver", BindingFlags.Instance | BindingFlags.Public);
				MethodInfo methodInfo5 = type2?.GetMethod("SetBag", BindingFlags.Instance | BindingFlags.NonPublic);
				MethodInfo methodInfo6 = type2?.GetMethod("SetQuiver", BindingFlags.Instance | BindingFlags.Public);
				if (methodInfo == null || methodInfo2 == null || type2 == null || type3 == null || type4 == null || methodInfo3 == null || methodInfo4 == null || methodInfo5 == null || methodInfo6 == null)
				{
					detail = "RustyBags API or BagEquipment methods were not found";
					return false;
				}
				api = new RustyBagsApi(methodInfo, methodInfo2, type2, type3, type4, methodInfo3, methodInfo4, methodInfo5, methodInfo6);
				detail = "";
				return true;
			}

			public bool IsBag(ItemData? item)
			{
				if (item?.m_shared == null)
				{
					return false;
				}
				try
				{
					object obj = _isBagMethod.Invoke(null, new object[1] { item.m_shared.m_name });
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public bool IsQuiver(ItemData? item)
			{
				if (item?.m_shared == null)
				{
					return false;
				}
				try
				{
					object obj = _isQuiverMethod.Invoke(null, new object[1] { item.m_shared.m_name });
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public void SyncBag(Player player, ItemData? item)
			{
				if (item == null || _bagType.IsInstanceOfType(item))
				{
					InvokeEquipmentSetter(player, _setBagMethod, item);
				}
			}

			public void SyncQuiver(Player player, ItemData? item)
			{
				if (item == null || _quiverType.IsInstanceOfType(item))
				{
					InvokeEquipmentSetter(player, _setQuiverMethod, item);
				}
			}

			public void ClearBagIfCurrent(Player player, ItemData item)
			{
				object bagEquipment = GetBagEquipment(player);
				if (bagEquipment != null && _getBagMethod.Invoke(bagEquipment, Array.Empty<object>()) == item)
				{
					_setBagMethod.Invoke(bagEquipment, new object[1]);
				}
			}

			public void ClearQuiverIfCurrent(Player player, ItemData item)
			{
				object bagEquipment = GetBagEquipment(player);
				if (bagEquipment != null && _getQuiverMethod.Invoke(bagEquipment, Array.Empty<object>()) == item)
				{
					_setQuiverMethod.Invoke(bagEquipment, new object[1]);
				}
			}

			private void InvokeEquipmentSetter(Player player, MethodInfo setter, ItemData? item)
			{
				object bagEquipment = GetBagEquipment(player);
				if (bagEquipment == null)
				{
					return;
				}
				try
				{
					setter.Invoke(bagEquipment, new object[1] { item });
				}
				catch (Exception)
				{
				}
			}

			private object? GetBagEquipment(Player player)
			{
				if ((Object)(object)player == (Object)null)
				{
					return null;
				}
				try
				{
					return ((Component)player).GetComponent(_bagEquipmentType);
				}
				catch
				{
					return null;
				}
			}
		}

		private sealed class BetterArcheryQuiverApi
		{
			private readonly FieldInfo _quiverEnabledField;

			private readonly FieldInfo _quiverRowIndexField;

			private ConfigEntry<bool>? _quiverEnabledConfig;

			private bool _quiverRowIndexResolved;

			private int _quiverRowIndex;

			private BetterArcheryQuiverApi(FieldInfo quiverEnabledField, FieldInfo quiverRowIndexField)
			{
				_quiverEnabledField = quiverEnabledField;
				_quiverRowIndexField = quiverRowIndexField;
			}

			public static bool TryCreate(Assembly assembly, out BetterArcheryQuiverApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetTypes().FirstOrDefault((Type candidate) => candidate.IsClass && candidate.Name == "BetterArchery");
				if (type == null)
				{
					detail = "BetterArchery type was not found";
					return false;
				}
				FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public);
				FieldInfo fieldInfo = fields.FirstOrDefault((FieldInfo field) => string.Equals(field.Name, "ConfigQuiverEnabled", StringComparison.OrdinalIgnoreCase));
				FieldInfo fieldInfo2 = fields.FirstOrDefault((FieldInfo field) => string.Equals(field.Name, "QuiverRowIndex", StringComparison.OrdinalIgnoreCase));
				if (fieldInfo == null || fieldInfo2 == null)
				{
					detail = "quiver config fields were not found";
					return false;
				}
				api = new BetterArcheryQuiverApi(fieldInfo, fieldInfo2);
				detail = "";
				return true;
			}

			public bool IsQuiverCell(Vector2i pos, bool includeRestockableSlots)
			{
				//IL_00a0: 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)
				try
				{
					if (_quiverEnabledConfig == null)
					{
						_quiverEnabledConfig = _quiverEnabledField.GetValue(null) as ConfigEntry<bool>;
					}
				}
				catch
				{
					_quiverEnabledConfig = null;
				}
				if (_quiverEnabledConfig == null || !_quiverEnabledConfig.Value)
				{
					return false;
				}
				if (!_quiverRowIndexResolved || _quiverRowIndex == 0)
				{
					try
					{
						_quiverRowIndex = ((_quiverRowIndexField.GetValue(null) is int num) ? num : 0);
					}
					catch
					{
						_quiverRowIndex = 0;
					}
					_quiverRowIndexResolved = _quiverRowIndex != 0;
				}
				if (_quiverRowIndex == 0)
				{
					return false;
				}
				if (pos.y == _quiverRowIndex - 1)
				{
					return true;
				}
				if (pos.y == _quiverRowIndex)
				{
					if (!includeRestockableSlots)
					{
						return pos.x > 2;
					}
					return true;
				}
				return false;
			}
		}

		private sealed class CompatApiRuntimeState<TApi> where TApi : class
		{
			public TApi? Api;

			public bool ReflectionFailed;
		}

		private sealed class CompatRuntimeState
		{
			public readonly CompatApiRuntimeState<AzuCraftyBoxesApi> AzuCraftyBoxes = new CompatApiRuntimeState<AzuCraftyBoxesApi>();

			public readonly CompatApiRuntimeState<JewelcraftingTooltipApi> JewelcraftingTooltip = new CompatApiRuntimeState<JewelcraftingTooltipApi>();

			public readonly CompatApiRuntimeState<JewelcraftingGemApi> JewelcraftingGem = new CompatApiRuntimeState<JewelcraftingGemApi>();

			public readonly CompatApiRuntimeState<JewelcraftingEffectApi> JewelcraftingEffect = new CompatApiRuntimeState<JewelcraftingEffectApi>();

			public readonly CompatApiRuntimeState<JewelcraftingSlotApi> JewelcraftingSlot = new CompatApiRuntimeState<JewelcraftingSlotApi>();

			public readonly CompatApiRuntimeState<JewelcraftingCraftingSocketUiApi> JewelcraftingCraftingSocketUi = new CompatApiRuntimeState<JewelcraftingCraftingSocketUiApi>();

			public readonly CompatApiRuntimeState<JewelcraftingGemCuttingApi> JewelcraftingGemCutting = new CompatApiRuntimeState<JewelcraftingGemCuttingApi>();

			public readonly CompatApiRuntimeState<JewelcraftingVisualApi> JewelcraftingVisual = new CompatApiRuntimeState<JewelcraftingVisualApi>();

			public readonly CompatApiRuntimeState<ItemRequiresSkillLevelApi> ItemRequiresSkillLevel = new CompatApiRuntimeState<ItemRequiresSkillLevelApi>();

			public readonly CompatApiRuntimeState<RecycleNReclaimApi> RecycleNReclaim = new CompatApiRuntimeState<RecycleNReclaimApi>();

			public readonly CompatApiRuntimeState<AdventureBackpacksApi> AdventureBackpacks = new CompatApiRuntimeState<AdventureBackpacksApi>();

			public readonly CompatApiRuntimeState<SmoothbrainBackpacksApi> SmoothbrainBackpacks = new CompatApiRuntimeState<SmoothbrainBackpacksApi>();

			public readonly CompatApiRuntimeState<RustyBagsApi> RustyBags = new CompatApiRuntimeState<RustyBagsApi>();

			public readonly CompatApiRuntimeState<MagicSupremacyApi> MagicSupremacy = new CompatApiRuntimeState<MagicSupremacyApi>();

			public readonly CompatApiRuntimeState<BetterArcheryQuiverApi> BetterArcheryQuiver = new CompatApiRuntimeState<BetterArcheryQuiverApi>();

			public readonly CompatApiRuntimeState<VeiledRecipesApi> VeiledRecipes = new CompatApiRuntimeState<VeiledRecipesApi>();
		}

		private delegate bool CompatApiFactory<TApi>(Assembly assembly, out TApi? api, out string detail) where TApi : class;

		private enum ContainerAccessMode
		{
			Unavailable,
			DirectOwner,
			MultiUserChestRemote
		}

		private delegate bool TryGetContainerHoldContext(Player player, out Container container);

		private enum ContainerPreviewPhase
		{
			Hidden,
			PreviewVisible,
			RestorePending,
			RealInventoryVisible
		}

		private enum ContainerTakeStacksMode
		{
			CurrentContainerMatchingStacks,
			AreaFavoriteRestock
		}

		private sealed class ControllerActionOption
		{
			public ControllerHotkeyAction Action { get; }

			public string Label { get; }

			public ControllerActionOption(ControllerHotkeyAction action, string label)
			{
				Action = action;
				Label = label;
			}
		}

		private readonly struct CraftingRequirementAvailabilityCacheEntry
		{
			public int Amount { get; }

			public float ExpiresAt { get; }

			public CraftingRequirementAvailabilityCacheEntry(int amount, float expiresAt)
			{
				Amount = amount;
				ExpiresAt = expiresAt;
			}
		}

		private sealed class CraftingRequirementRuntimeState
		{
			public readonly Dictionary<string, CraftingRequirementAvailabilityCacheEntry> AvailabilityCache = new Dictionary<string, CraftingRequirementAvailabilityCacheEntry>(StringComparer.OrdinalIgnoreCase);

			public readonly List<Requirement> VisibleRequirements = new List<Requirement>();

			public readonly List<Requirement> VisibleRequirementCandidates = new List<Requirement>();

			public readonly List<RectTransform?> OwnedSlots = new List<RectTransform>();

			public int AvailabilityVersion;
		}

		private sealed class CraftingRecipeRuntimeState
		{
			public readonly List<CraftingRecipeGridCell> GridCells = new List<CraftingRecipeGridCell>();

			public readonly List<CraftingRecipeViewEntry> View = new List<CraftingRecipeViewEntry>();

			public readonly Dictionary<int, int> ViewIndexByOriginal = new Dictionary<int, int>();

			public readonly List<CraftingRecipeGroupPanel> GroupPanels = new List<CraftingRecipeGroupPanel>();

			public readonly List<CraftingRecipeGroupButton> GroupButtons = new List<CraftingRecipeGroupButton>();

			public readonly Dictionary<Recipe, int> Variants = new Dictionary<Recipe, int>();

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

			public readonly Dictionary<string, CraftingHoverTooltipContent> HoverTooltipContentCache = new Dictionary<string, CraftingHoverTooltipContent>(StringComparer.Ordinal);

			public readonly List<JewelcraftingGemIconData> HoverGemIconCache = new List<JewelcraftingGemIconData>();

			public readonly Dictionary<string, string> EnglishLocalizationCache = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, string> EnglishLocalizationIndex = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<CraftingRecipePairCacheKey, SortKey> SortKeyCache = new Dictionary<CraftingRecipePairCacheKey, SortKey>();

			public readonly Dictionary<CraftingRecipePairCacheKey, Dictionary<string, bool>> GroupMatchCache = new Dictionary<CraftingRecipePairCacheKey, Dictionary<string, bool>>();

			public readonly List<CraftingRecipeGroupFilter> SelectableGroupFilterCache = new List<CraftingRecipeGroupFilter>();

			public readonly Dictionary<string, bool> GroupHasRecipesCache = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
		}

		private sealed class CraftingGridRuntimeState
		{
			public RectTransform? RecipeGrid;

			public bool RecipeGridDirty = true;

			public int RecipePage;

			public CraftingRecipeGridStamp RecipeGridStamp;

			public string RecipeGridLayoutSignature = "";

			public int RecipeGridCellCapacity = -1;
		}

		private sealed class CraftingScrollbarRuntimeState
		{
			public RectTransform? RecipeScrollbar;

			public Scrollbar? RecipeScrollbarComponent;

			public bool UpdatingRecipeScrollbar;

			public bool RecipeScrollbarDirty = true;

			public CraftingRecipeScrollbarStamp RecipeScrollbarStamp;
		}

		private sealed class CraftingQueueRuntimeState
		{
			public bool ContinuingQueue;

			public int QueueTotal;

			public int QueueRemaining;

			public int QueueVariant;

			public int ProgressLabelCount;

			public int ProgressLabelVariant;

			public Recipe? QueueRecipe;

			public Recipe? ProgressLabelRecipe;

			public int InventoryLimitNoticeDepth;

			public ItemData? PendingInventoryLimitItem;

			public int PendingInventoryLimitMax = -1;
		}

		private sealed class CraftingUiRuntimeState
		{
			public GameObject? HoverTooltip;

			public RectTransform? HoverTooltipPanel;

			public TMP_Text? HoverTooltipTopic;

			public TMP_Text? HoverTooltipText;

			public readonly ScrollableTooltipBodyState HoverTooltipTextScroll = new ScrollableTooltipBodyState();

			public RectTransform? TooltipRecipeOverlay;

			public RectTransform? TooltipGemIconRow;

			public TMP_InputField? SearchInput;

			public RectTransform? SearchInputRect;

			public RectTransform? RecipeGridZoomHint;

			public RectTransform? GroupRail;

			public TMP_InputField? CountInput;

			public RectTransform? CountInputRect;

			public RectTransform? CountInputViewport;

			public RectTransform? UpgradeProgressionRect;

			public TMP_Text? UpgradeProgressionText;

			public RectTransform? SortModeButtonGroup;

			public RectTransform? ControlsBackground;

			public RectTransform? SocketWarningRect;

			public TMP_Text? SocketWarningText;

			public Transform? RequiredStationLevelOriginalRoot;

			public RectTransform? RequiredStationLevelHitbox;

			public RectTransformSnapshot? PanelRootSnapshot;

			public Vector2 PanelOriginalSizeDelta;

			public bool SearchInputDirty = true;

			public int HoveredRecipeIndex = -1;

			public CraftingSearchInputStamp SearchInputStamp;

			public string HoverTooltipSignature = "";

			public string HoverTooltipLayoutSignature = "";

			public string HoverTooltipVisualSignature = "";

			public string HoverGemIconSignature = "";

			public float HoverTooltipScrollOffset;

			public float HoverTooltipMaxScroll;

			public bool RecipeHoverMouseSyncPending;
		}

		private sealed class CraftingRefreshRuntimeState
		{
			public bool RecipeViewDirty = true;

			public string RecipeViewSignature = "";

			public bool GroupRailDirty = true;

			public CraftingGroupRailStamp GroupRailStamp;

			public bool BottomControlsDirty = true;

			public string BottomControlsSignature = "";

			public CraftingStatusHudStamp SocketWarningStamp;

			public CraftingSortModeButtonsStamp SortModeButtonsStamp;

			public CraftingFrameFastPathStamp FrameFastPathStamp;

			public string RecipeListChangeSignature = "";
		}

		private static class CraftingController
		{
			public static int HoveredRecipeIndex => CraftingUi.HoveredRecipeIndex;

			public static bool IsSearchInputDirty => CraftingUi.SearchInputDirty;

			public static bool NeedsModelRefresh(CraftingPanelUpdateReason reason, bool firstApply)
			{
				if (!firstApply && reason == CraftingPanelUpdateReason.FrameTick)
				{
					return HasModelRefreshWork();
				}
				return true;
			}

			public static bool HasModelRefreshWork()
			{
				if (!CraftingRefresh.RecipeViewDirty && !CraftingGrid.RecipeGridDirty && !CraftingScrollbar.RecipeScrollbarDirty)
				{
					return CraftingRefresh.GroupRailDirty;
				}
				return true;
			}

			public static bool HasFrameRebuildWork()
			{
				if (!HasModelRefreshWork())
				{
					return CraftingRefresh.BottomControlsDirty;
				}
				return true;
			}

			public static void MarkRecipeViewDirty()
			{
				CraftingRefresh.RecipeViewDirty = true;
				CraftingRefresh.RecipeViewSignature = "";
			}

			public static void MarkRecipeGridDirty()
			{
				CraftingGrid.RecipeGridDirty = true;
				CraftingGrid.RecipeGridStamp = default(CraftingRecipeGridStamp);
			}

			public static void MarkRecipeScrollbarDirty()
			{
				CraftingScrollbar.RecipeScrollbarDirty = true;
				CraftingScrollbar.RecipeScrollbarStamp = default(CraftingRecipeScrollbarStamp);
			}

			public static void MarkGroupRailDirty()
			{
				CraftingRefresh.GroupRailDirty = true;
				CraftingRefresh.GroupRailStamp = default(CraftingGroupRailStamp);
			}

			public static void MarkBottomControlsDirty()
			{
				CraftingRefresh.BottomControlsDirty = true;
				CraftingRefresh.BottomControlsSignature = "";
			}

			public static void MarkSearchInputDirty()
			{
				CraftingUi.SearchInputDirty = true;
				CraftingUi.SearchInputStamp = default(CraftingSearchInputStamp);
			}

			public static bool CanReuseRecipeView(string signature)
			{
				if (!CraftingRefresh.RecipeViewDirty)
				{
					return string.Equals(CraftingRefresh.RecipeViewSignature, signature, StringComparison.Ordinal);
				}
				return false;
			}

			public static void StoreRecipeViewSignature(string signature)
			{
				CraftingRefresh.RecipeViewSignature = signature;
				CraftingRefresh.RecipeViewDirty = false;
			}

			public static bool CanReuseRecipeGrid(CraftingRecipeGridStamp stamp)
			{
				if (!CraftingGrid.RecipeGridDirty)
				{
					return CraftingGrid.RecipeGridStamp.Equals(stamp);
				}
				return false;
			}

			public static void StoreRecipeGridStamp(CraftingRecipeGridStamp stamp)
			{
				CraftingGrid.RecipeGridStamp = stamp;
				CraftingGrid.RecipeGridDirty = false;
			}

			public static bool CanReuseRecipeScrollbar(CraftingRecipeScrollbarStamp stamp)
			{
				if (!CraftingScrollbar.RecipeScrollbarDirty)
				{
					return CraftingScrollbar.RecipeScrollbarStamp.Equals(stamp);
				}
				return false;
			}

			public static void StoreRecipeScrollbarStamp(CraftingRecipeScrollbarStamp stamp)
			{
				CraftingScrollbar.RecipeScrollbarStamp = stamp;
				CraftingScrollbar.RecipeScrollbarDirty = false;
			}

			public static bool CanReuseGroupRail(CraftingGroupRailStamp stamp)
			{
				if (!CraftingRefresh.GroupRailDirty)
				{
					return CraftingRefresh.GroupRailStamp.Equals(stamp);
				}
				return false;
			}

			public static void StoreGroupRailStamp(CraftingGroupRailStamp stamp)
			{
				CraftingRefresh.GroupRailStamp = stamp;
				CraftingRefresh.GroupRailDirty = false;
			}

			public static bool CanReuseSearchInput(CraftingSearchInputStamp stamp)
			{
				if (!CraftingUi.SearchInputDirty)
				{
					return CraftingUi.SearchInputStamp.Equals(stamp);
				}
				return false;
			}

			public static void StoreSearchInputStamp(CraftingSearchInputStamp stamp)
			{
				CraftingUi.SearchInputStamp = stamp;
				CraftingUi.SearchInputDirty = false;
			}

			public static bool NeedsBottomControlsLayout(string signature)
			{
				if (!CraftingRefresh.BottomControlsDirty)
				{
					return !string.Equals(CraftingRefresh.BottomControlsSignature, signature, StringComparison.Ordinal);
				}
				return true;
			}

			public static void StoreBottomControlsSignature(string signature)
			{
				CraftingRefresh.BottomControlsSignature = signature;
				CraftingRefresh.BottomControlsDirty = false;
			}

			public static bool CanReuseFrameFastPath(CraftingFrameFastPathStamp stamp)
			{
				return CraftingRefresh.FrameFastPathStamp.Equals(stamp);
			}

			public static void StoreFrameFastPathStamp(CraftingFrameFastPathStamp stamp)
			{
				CraftingRefresh.FrameFastPathStamp = stamp;
			}

			public static void ResetFrameFastPathStamp()
			{
				CraftingRefresh.FrameFastPathStamp = default(CraftingFrameFastPathStamp);
			}

			public static bool CanReuseSortModeButtons(CraftingSortModeButtonsStamp stamp)
			{
				return CraftingRefresh.SortModeButtonsStamp.Equals(stamp);
			}

			public static void StoreSortModeButtonsStamp(CraftingSortModeButtonsStamp stamp)
			{
				CraftingRefresh.SortModeButtonsStamp = stamp;
			}

			public static void ResetSortModeButtonsStamp()
			{
				CraftingRefresh.SortModeButtonsStamp = default(CraftingSortModeButtonsStamp);
			}

			public static bool CanReuseSocketWarning(CraftingStatusHudStamp stamp)
			{
				return CraftingRefresh.SocketWarningStamp.Equals(stamp);
			}

			public static void StoreSocketWarningStamp(CraftingStatusHudStamp stamp)
			{
				CraftingRefresh.SocketWarningStamp = stamp;
			}

			public static void ResetSocketWarningStamp()
			{
				CraftingRefresh.SocketWarningStamp = default(CraftingStatusHudStamp);
			}

			public static bool TryStoreRecipeListChangeSignature(string signature)
			{
				if (string.Equals(CraftingRefresh.RecipeListChangeSignature, signature, StringComparison.Ordinal))
				{
					return false;
				}
				CraftingRefresh.RecipeListChangeSignature = signature;
				return true;
			}

			public static void ResetRecipeListChangeSignature()
			{
				CraftingRefresh.RecipeListChangeSignature = "";
			}

			public static void MarkRecipeGridLayoutDirty()
			{
				MarkRecipeGridDirty();
				MarkRecipeScrollbarDirty();
				MarkBottomControlsDirty();
			}

			public static void SetHoveredRecipe(int index)
			{
				CraftingUi.HoveredRecipeIndex = index;
			}

			public static void ClearHoveredRecipe()
			{
				CraftingUi.HoveredRecipeIndex = -1;
			}

			public static bool IsHoveredRecipe(int index)
			{
				return CraftingUi.HoveredRecipeIndex == index;
			}

			public static void ClearHoveredRecipeAndRequestMouseSync()
			{
				ClearHoveredRecipe();
				CraftingUi.RecipeHoverMouseSyncPending = true;
			}

			public static bool ConsumeRecipeHoverMouseSync()
			{
				if (!CraftingUi.RecipeHoverMouseSyncPending)
				{
					return false;
				}
				CraftingUi.RecipeHoverMouseSyncPending = false;
				return true;
			}
		}

		private sealed class CustomEquipmentVisualState
		{
			public string SlotId { get; }

			public int ItemHash { get; }

			public int Variant { get; }

			public string PrefabName { get; }

			public ItemType ItemType { get; }

			public bool ReorderAdventureBackpackBones { get; }

			public CustomEquipmentVisualState(string slotId, int itemHash, int variant, string prefabName, ItemType itemType, bool reorderAdventureBackpackBones)
			{
				//IL_0024: 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)
				SlotId = slotId;
				ItemHash = itemHash;
				Variant = variant;
				PrefabName = prefabName;
				ItemType = itemType;
				ReorderAdventureBackpackBones = reorderAdventureBackpackBones;
			}
		}

		private sealed class CustomEquipmentVisual
		{
			private readonly List<GameObject> _instances = new List<GameObject>();

			public string Key { get; }

			public VisEquipment Owner { get; }

			public string PrefabName { get; }

			public int Variant { get; }

			public CustomEquipmentVisual(string key, VisEquipment owner, string prefabName, int variant)
			{
				Key = key;
				Owner = owner;
				PrefabName = prefabName;
				Variant = variant;
			}

			public bool Matches(VisEquipment owner, string prefabName, int variant)
			{
				if (!IsUnityNull((Object?)(object)Owner) && (Object)(object)Owner == (Object)(object)owner && string.Equals(PrefabName, prefabName, StringComparison.Ordinal))
				{
					return Variant == variant;
				}
				return false;
			}

			public bool IsOwnedBy(VisEquipment owner)
			{
				if (!IsUnityNull((Object?)(object)Owner))
				{
					return (Object)(object)Owner == (Object)(object)owner;
				}
				return false;
			}

			public void Add(GameObject? instance)
			{
				if (!IsUnityNull((Object?)(object)instance))
				{
					_instances.Add(instance);
				}
			}

			public void AddRange(IEnumerable<GameObject>? instances)
			{
				if (instances == null)
				{
					return;
				}
				foreach (GameObject instance in instances)
				{
					Add(instance);
				}
			}

			public void AddActiveInstancesTo(List<GameObject> roots)
			{
				foreach (GameObject instance in _instances)
				{
					if (!IsUnityNull((Object?)(object)instance))
					{
						roots.Add(instance);
					}
				}
			}

			public void Destroy()
			{
				foreach (GameObject instance in _instances)
				{
					if (!IsUnityNull((Object?)(object)instance))
					{
						if (!IsUnityNull((Object?)(object)Owner) && !IsUnityNull((Object?)(object)Owner.m_lodGroup))
						{
							Utils.RemoveFromLodgroup(Owner.m_lodGroup, instance);
						}
						Object.Destroy((Object)(object)instance);
					}
				}
				_instances.Clear();
			}
		}

		internal sealed class KeepOnDeathItemState
		{
			public ItemData Item { get; }

			public Vector2i OriginalGridPos { get; }

			public string OriginalSlotId { get; }

			public SlotKind? OriginalSlotKind { get; }

			public bool WasQuickSlot => OriginalSlotKind == SlotKind.Quick;

			public bool WasSpecialSlot => OriginalSlotKind.HasValue;

			public KeepOnDeathItemState(ItemData item, Vector2i originalGridPos, string originalSlotId, SlotKind? originalSlotKind)
			{
				//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)
				Item = item;
				OriginalGridPos = originalGridPos;
				OriginalSlotId = originalSlotId;
				OriginalSlotKind = originalSlotKind;
			}
		}

		internal sealed class TombStonePreparationState
		{
			public List<KeepOnDeathItemState> KeptItems { get; }

			public bool DeathDropUnequipPrepared { get; }

			public bool Completed { get; set; }

			public TombStonePreparationState(List<KeepOnDeathItemState> keptItems, bool deathDropUnequipPrepared)
			{
				KeptItems = keptItems;
				DeathDropUnequipPrepared = deathDropUnequipPrepared;
			}
		}

		private sealed class InventoryHoverTooltipRuntimeState
		{
			public GameObject? HoverTooltip;

			public RectTransform? HoverTooltipPanel;

			public TMP_Text? HoverTooltipTopic;

			public TMP_Text? HoverTooltipText;

			public readonly ScrollableTooltipBodyState HoverTooltipTextScroll = new ScrollableTooltipBodyState();

			public readonly TooltipSourceCacheCore<UITooltip, InventoryHoverTooltipItemSource> HoverTooltipItems = new TooltipSourceCacheCore<UITooltip, InventoryHoverTooltipItemSource>(64);

			public string HoverTooltipSignature = "";

			public string HoverTooltipLayoutSignature = "";

			public float HoverTooltipScrollOffset;

			public float HoverTooltipMaxScroll;

			public bool HoverTooltipNeedsScroll;

			public RectTransform? HoverJewelcraftingTooltipRoot;

			public string HoverJewelcraftingTooltipSignature = "";

			public int HoverJewelcraftingTooltipLayoutRefreshFrames;

			public GameObject? SimpleNameTooltip;

			public RectTransform? SimpleNameTooltipRect;

			public TMP_Text? SimpleNameTooltipText;

			public string SimpleNameTooltipValue = "";

			public SimpleNameTooltipPlacement SimpleNameTooltipPlacement;

			public readonly SimpleTooltipOwnershipCore SimpleNameTooltipOwner = new SimpleTooltipOwnershipCore();

			public readonly object SimpleNameTooltipFallbackOwner = new object();

			public object? PinnedGemNameTooltipOwner;

			public float PinnedGemNameTooltipHoldUntil = -1000f;

			public UITooltip? ContainerHoverTooltipSource;

			public UITooltip? OwnedHoverTooltipSource;

			public bool LateUpdateExceptionLogged;
		}

		private enum SimpleNameTooltipPlacement
		{
			RightOfCursor,
			LeftOfCursor
		}

		private readonly struct InventoryHoverTooltipItemSource
		{
			public InventoryGrid? Grid { get; }

			public ItemData Item { get; }

			public InventoryHoverTooltipItemSource(InventoryGrid? grid, ItemData item)
			{
				Grid = grid;
				Item = item;
			}
		}

		private readonly struct PlayerInventoryPanelBackgroundSnapshot
		{
			public bool ActiveSelf { get; }

			public bool ImageEnabled { get; }

			public Sprite? Sprite { get; }

			public Type Type { get; }

			public float PixelsPerUnitMultiplier { get; }

			public Material? Material { get; }

			public Color Color { get; }

			public Vector2 AnchorMax { get; }

			public Vector2 Pivot { get; }

			public Vector2 OffsetMin { get; }

			public Vector2 OffsetMax { get; }

			public Vector2 AnchoredPosition { get; }

			public Vector2 SizeDelta { get; }

			public Vector3 LocalScale { get; }

			public Quaternion LocalRotation { get; }

			public PlayerInventoryPanelBackgroundSnapshot(bool activeSelf, bool imageEnabled, Sprite? sprite, Type type, float pixelsPerUnitMultiplier, Material? material, Color color, Vector2 anchorMax, Vector2 pivot, Vector2 offsetMin, Vector2 offsetMax, Vector2 anchoredPosition, Vector2 sizeDelta, Vector3 localScale, Quaternion localRotation)
			{
				//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_002e: 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_0038: 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_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: 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_0050: 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_0058: 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_0060: 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_0068: 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_0070: Unknown result type (might be due to invalid IL or missing references)
				ActiveSelf = activeSelf;
				ImageEnabled = imageEnabled;
				Sprite = sprite;
				Type = type;
				PixelsPerUnitMultiplier = pixelsPerUnitMultiplier;
				Material = material;
				Color = color;
				AnchorMax = anchorMax;
				Pivot = pivot;
				OffsetMin = offsetMin;
				OffsetMax = offsetMax;
				AnchoredPosition = anchoredPosition;
				SizeDelta = sizeDelta;
				LocalScale = localScale;
				LocalRotation = localRotation;
			}
		}

		internal enum InventoryStateEnsureReason
		{
			Unknown,
			PeriodicAudit,
			PlayerAwake,
			PlayerSpawned,
			PlayerLoad,
			PlayerSave,
			InventoryChanged,
			EquipmentChanged,
			InventoryLoad,
			InventoryMove,
			Tombstone,
			GuiShow,
			SlotAction,
			BackupRestore,
			YamlReload,
			JewelcraftingSlotRefresh,
			ProgressionReset,
			ConfigChanged,
			ReentrantFollowUp
		}

		internal enum InventoryStateAuditLevel
		{
			None,
			HeightOnly,
			SlotLight,
			FullIntegrity
		}

		private sealed class InventoryPanelRuntimeState
		{
			public readonly Dictionary<int, RectTransform> CustomSlotPanels = new Dictionary<int, RectTransform>();

			public readonly Dictionary<int, RectTransform> QuickSlotPanels = new Dictionary<int, RectTransform>();

			public readonly List<MovedPlayerStatPanel> MovedPlayerStatPanels = new List<MovedPlayerStatPanel>();

			public readonly Dictionary<int, Vector3> QuickSlotPanelOutroStartPositions = new Dictionary<int, Vector3>();

			public readonly Dictionary<int, GameObject> FavoriteKeyHintObjects = new Dictionary<int, GameObject>();

			public readonly Dictionary<int, GameObject> PinnedTooltipKeyHintObjects = new Dictionary<int, GameObject>();

			public RectTransform? QuickSlotsHotkeyBarRect;

			public HotkeyBar? QuickSlotsHotkeyBar;

			public RectTransform? PlayerStatPanelHost;

			public RectTransform? InventorySortPanel;

			public RectTransform? CurrencyPocketPanel;

			public Button? ContainerRestockButton;

			public Button? ContainerStoreAllButton;

			public Button? ContainerSortButton;

			public RectTransformSnapshot? TakeAllButtonOriginal;

			public RectTransformSnapshot? StackAllButtonOriginal;

			public RectTransform? TrackedContainerPanel;

			public RectTransform? TrackedContainerWeightPanel;

			public Vector3 ContainerPanelBasePosition;

			public Vector3 ContainerPanelAppliedOffset;

			public Vector3 ContainerWeightPanelBasePosition;

			public float ContainerWeightPanelAppliedYOffset;

			public RectTransform? DraggedInventoryPanel;

			public Vector2 InventoryPanelDragStartLocalMouse;

			public Vector2 InventoryPanelDragStartOffset;

			public bool ContainerPanelBasePositionSet;

			public bool ContainerWeightPanelBasePositionSet;

			public bool DraggingQuickSlotsPanelOffset;

			public bool DraggingEquipmentSlotsPanelOffset;

			public Vector2 EquipmentSlotsPanelRuntimeOffset = EquipmentSlotsPanelFixedOffset;

			public Vector2 QuickSlotsPanelRuntimeOffset = QuickSlotsPanelFixedOffset;

			public int LastExpandableInventoryRows = 4;

			public float QuickSlotPanelIntroStartTime = -1f;

			public float QuickSlotPanelIntroDuration = 0.25f;

			public float QuickSlotPanelOutroStartTime = -1f;

			public float QuickSlotPanelOutroDuration = 0.25f;

			public float QuickSlotHudElementSpace = 70f;

			public readonly ContainerHoldActionState ContainerRestockHold = new ContainerHoldActionState();

			public readonly ContainerHoldActionState ContainerQuickStackHold = new ContainerHoldActionState();

			public bool QuickSlotPanelIntroActive;

			public bool QuickSlotPanelOutroActive;

			public bool QuickSlotHudAnchorValid;

			public bool LastExpandableInventoryRowsLoaded;

			public Vector3 QuickSlotHudAnchoredPosition;
		}

		private sealed class ContainerHoldActionState
		{
			public Container? Container;

			public float StartTime = -1f;

			public bool Triggered;
		}

		private sealed class InventorySafetyRuntimeState
		{
			public readonly Dictionary<ItemData, PendingSlotEquip> PendingSlotEquips = new Dictionary<ItemData, PendingSlotEquip>();

			public readonly Dictionary<ItemData, PendingSlotUnequip> PendingSlotUnequips = new Dictionary<ItemData, PendingSlotUnequip>();

			public readonly Dictionary<Inventory, int> LoadPreservationInventoryDepth = new Dictionary<Inventory, int>();

			public readonly Stack<ItemData?> InventoryAddItemDataStackLookupItems = new Stack<ItemData>();

			public readonly HashSet<string> SlotRecoveryWarnings = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> ForeignSlotPreservationWarnings = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<ItemData, float> SlotUnequipToInventoryRequests = new Dictionary<ItemData, float>();

			public bool RoutingEquipToDedicatedSlot;

			public bool RestoringSlotBackup;

			public bool EnsuringInventoryState;

			public InventoryStateEnsureReason PendingEnsureReason;

			public InventoryStateAuditLevel PendingAuditLevel;

			public InventoryStateEnsureReason DeferredEnsureReason;

			public InventoryStateAuditLevel DeferredAuditLevel;

			public int DeferredEnsureFrame = -1;

			public float HeavyAuditDelayUntil = -1f;

			public int LastFullIntegrityAuditSignature = int.MinValue;

			public int LastSlotLightProjectionSignature = int.MinValue;

			public int InventoryPlacementCacheVersion;

			public Inventory? UsableRegularEmptyCellCacheInventory;

			public int UsableRegularEmptyCellCacheVersion = -1;

			public int UsableRegularEmptyCellCacheContext;

			public int UsableRegularEmptyCellCacheCount;

			public Inventory? DedicatedSlotRouteFailureCacheInventory;

			public int DedicatedSlotRouteFailureCacheVersion = -1;

			public int DedicatedSlotRouteFailureCacheContext;

			public int DedicatedSlotRouteFailureCacheItemKey;

			public Inventory? CanAddItemFailureCacheInventory;

			public int CanAddItemFailureCacheVersion = -1;

			public int CanAddItemFailureCacheContext;

			public int CanAddItemFailureCacheItemKey;

			public int CanAddItemFailureCacheRequestedStack;

			public Inventory? InventoryLimitCountCacheInventory;

			public int InventoryLimitCountCachePlacementVersion = -1;

			public int InventoryLimitCountCacheRuleVersion = -1;

			public readonly Dictionary<string, long> InventoryLimitCountCache = new Dictionary<string, long>(StringComparer.OrdinalIgnoreCase);

			public string LastInventoryLimitMessageKey = "";

			public float LastInventoryLimitMessageTime = -1f;

			public bool SlotUnequipInProgress;

			public bool SuppressSlotAutoEquip;

			public bool SuppressKnownItemRediscovery;

			public bool HandlingSlotDropOutside;
		}

		private sealed class InventoryContainerRuntimeState
		{
			public readonly List<Container> KnownContainers = new List<Container>();
		}

		private sealed class InventoryDefinitionRuntimeState
		{
			public readonly List<SlotDefinition> SlotDefinitions = new List<SlotDefinition>();

			public readonly List<SlotDefinition> CustomPanelSlotCache = new List<SlotDefinition>();

			public readonly List<SlotDefinition> VisibleCustomPanelSlotCache = new List<SlotDefinition>();

			public readonly List<SlotDefinition> QuickPanelSlotCache = new List<SlotDefinition>();

			public readonly Dictionary<int, SlotDefinition> QuickSlotDefinitionCache = new Dictionary<int, SlotDefinition>();

			public readonly Dictionary<string, bool> EquipmentSlotUnlockCache = new Dictionary<string, bool>(StringComparer.Ordinal);

			public readonly Dictionary<string, List<string>> PredefinedGroupDefinitions = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

			public readonly List<string> PredefinedGroupOrder = new List<string>();

			public readonly Dictionary<string, List<string>> PredefinedGroupOrders = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, int> InventoryLimits = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, int> ResourceTierByToken = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> CookingStationInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> CraftingRecipeFoodInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> CookingStationFoodInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> FermenterInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> FermenterOutputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> FermenterFoodInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, string> ItemNameTokens = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

			public Dictionary<string, int> RestockTargetStackLimits = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

			public int SlotDefinitionVersion;

			public int InventoryLimitVersion;

			public int CustomPanelSlotCacheVersion = -1;

			public int VisibleCustomPanelSlotCacheVersion = -1;

			public string VisibleCustomPanelSlotCacheSignature = "";

			public string EquipmentSlotUnlockCacheSignature = "";

			public int QuickPanelSlotCacheVersion = -1;

			public int QuickPanelSlotCacheUnlockedCount = -1;

			public int QuickSlotDefinitionCacheVersion = -1;

			public int CachedObjectDbItemCount = -1;

			public int CachedStationInputObjectDbItemCount = -1;

			public int CachedStationInputPrefabCount = -1;

			public int CachedStationInputRecipeCount = -1;

			public bool StationInputTokensInitialized;
		}

		private sealed class InventoryClientRuntimeState
		{
			public bool ClientStateLoaded;

			public string LoadedFavoritesPlayerId = "";

			public InventorySlotsClientState ClientState = new InventorySlotsClientState();

			public readonly HashSet<Vector2i> FavoriteSlots = new HashSet<Vector2i>();
		}

		private sealed class EquipmentVisualRuntimeState
		{
			public readonly Dictionary<string, CustomEquipmentVisual> Visuals = new Dictionary<string, CustomEquipmentVisual>(StringComparer.Ordinal);

			public readonly HashSet<StatusEffect> StatusEffects = new HashSet<StatusEffect>();

			public readonly Dictionary<StatusEffect, int> StatusEffectLevels = new Dictionary<StatusEffect, int>();

			public int LocalPlayerUpdateFrame = -1;

			public int LocalPlayerUpdateSignature = int.MinValue;

			public int LocalPlayerUpdateStateCount;
		}

		private sealed class InventorySortRuntimeState
		{
			public readonly Dictionary<string, Recipe> RecipeOutputLookupCache = new Dictionary<string, Recipe>(StringComparer.OrdinalIgnoreCase);

			public string RecipeOutputLookupSignature = "";
		}

		private sealed class ItemClassification
		{
			public readonly Dictionary<string, bool> BuiltInGroupMatches = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

			public bool BigGroupResolved;

			public string BigGroupId = "";
		}

		private sealed class ItemClassifierRuntimeState
		{
			public readonly Dictionary<string, ItemClassification> Cache = new Dictionary<string, ItemClassification>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> FeastMaterialTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public string FeastMaterialSignature = "";

			public int Version;

			public int AppliedVersion = -1;
		}

		private sealed class ItemRequiresSkillLevelApi
		{
			private readonly MethodInfo _tryGetReqForItemMethod;

			private readonly MethodInfo _tryGetReqForPrefabNameMethod;

			private readonly MethodInfo _getTextEquipMethod;

			private readonly MethodInfo _getTextCraftMethod;

			private ItemRequiresSkillLevelApi(MethodInfo tryGetReqForItemMethod, MethodInfo tryGetReqForPrefabNameMethod, MethodInfo getTextEquipMethod, MethodInfo getTextCraftMethod)
			{
				_tryGetReqForItemMethod = tryGetReqForItemMethod;
				_tryGetReqForPrefabNameMethod = tryGetReqForPrefabNameMethod;
				_getTextEquipMethod = getTextEquipMethod;
				_getTextCraftMethod = getTextCraftMethod;
			}

			public static bool TryCreate(Assembly assembly, out ItemRequiresSkillLevelApi? api, out string detail)
			{
				api = null;
				Type? type = assembly.GetType("ItemRequiresSkillLevel.Patches");
				MethodInfo methodInfo = type?.GetMethod("TryGetReqForItem", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo methodInfo2 = type?.GetMethod("TryGetReqForPrefabName", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo methodInfo3 = type?.GetMethod("GetTextEquip", BindingFlags.Static | BindingFlags.Public);
				MethodInfo methodInfo4 = type?.GetMethod("GetTextCraft", BindingFlags.Static | BindingFlags.Public);
				if (type == null || methodInfo == null || methodInfo2 == null || methodInfo3 == null || methodInfo4 == null)
				{
					detail = "ItemRequiresSkillLevel tooltip methods were not found";
					return false;
				}
				api = new ItemRequiresSkillLevelApi(methodInfo, methodInfo2, methodInfo3, methodInfo4);
				detail = "";
				return true;
			}

			public string GetTooltipText(ItemData? item, string? prefabName, bool includeEquip, bool includeCraft)
			{
				if (!includeEquip && !includeCraft)
				{
					return "";
				}
				if (!TryGetRequirement(item, prefabName, out object requirement) || requirement == null)
				{
					return "";
				}
				StringBuilder stringBuilder = new StringBuilder();
				if (includeEquip)
				{
					stringBuilder.Append(GetText(_getTextEquipMethod, requirement));
				}
				if (includeCraft)
				{
					stringBuilder.Append(GetText(_getTextCraftMethod, requirement));
				}
				return stringBuilder.ToString();
			}

			private bool TryGetRequirement(ItemData? item, string? prefabName, out object? requirement)
			{
				requirement = null;
				if (item != null && TryGetRequirementForItem(item, out requirement))
				{
					return true;
				}
				if (!string.IsNullOrWhiteSpace(prefabName))
				{
					return TryGetRequirementForPrefabName(prefabName, out requirement);
				}
				return false;
			}

			private bool TryGetRequirementForItem(ItemData item, out object? requirement)
			{
				requirement = null;
				try
				{
					object[] array = new object[2] { item, null };
					object obj = _tryGetReqForItemMethod.Invoke(null, array);
					bool num = obj is bool && (bool)obj;
					requirement = array[1];
					return num && requirement != null;
				}
				catch
				{
					requirement = null;
					return false;
				}
			}

			private bool TryGetRequirementForPrefabName(string prefabName, out object? requirement)
			{
				requirement = null;
				try
				{
					object[] array = new object[2] { prefabName, null };
					object obj = _tryGetReqForPrefabNameMethod.Invoke(null, array);
					bool num = obj is bool && (bool)obj;
					requirement = array[1];
					return num && requirement != null;
				}
				catch
				{
					requirement = null;
					return false;
				}
			}

			private static string GetText(MethodInfo method, object requirement)
			{
				try
				{
					return (method.Invoke(null, new object[1] { requirement }) as string) ?? "";
				}
				catch
				{
					return "";
				}
			}
		}

		private sealed class JewelcraftingCraftingSocketUiApi
		{
			private readonly FieldInfo _socketIconsField;

			private readonly FieldInfo? _socketingButtonField;

			private readonly FieldInfo? _socketTabField;

			private readonly FieldInfo? _socketCostField;

			private readonly MethodInfo? _socketTabOpenMethod;

			private JewelcraftingCraftingSocketUiApi(FieldInfo socketIconsField, FieldInfo? socketingButtonField, FieldInfo? socketTabField, FieldInfo? socketCostField, MethodInfo? socketTabOpenMethod)
			{
				_socketIconsField = socketIconsField;
				_socketingButtonField = socketingButtonField;
				_socketTabField = socketTabField;
				_socketCostField = socketCostField;
				_socketTabOpenMethod = socketTabOpenMethod;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingCraftingSocketUiApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetType("Jewelcrafting.GemStones+AddSocketIcons");
				Type type2 = assembly.GetType("Jewelcrafting.GemStones+AddSocketAddingTab");
				Type type3 = assembly.GetType("Jewelcrafting.Jewelcrafting");
				FieldInfo fieldInfo = type?.GetField("socketIcons", BindingFlags.Static | BindingFlags.Public);
				if (fieldInfo == null)
				{
					detail = "AddSocketIcons.socketIcons was not found";
					return false;
				}
				api = new JewelcraftingCraftingSocketUiApi(fieldInfo, type?.GetField("socketingButton", BindingFlags.Static | BindingFlags.Public), type2?.GetField("tab", BindingFlags.Static | BindingFlags.Public), type3?.GetField("socketCost", BindingFlags.Static | BindingFlags.Public), type2?.GetMethod("TabOpen", BindingFlags.Static | BindingFlags.Public));
				detail = "";
				return true;
			}

			public Array? GetSocketIcons()
			{
				return _socketIconsField.GetValue(null) as Array;
			}

			public Button? GetSocketingButton()
			{
				object? obj = _socketingButtonField?.GetValue(null);
				return (Button?)((obj is Button) ? obj : null);
			}

			public Transform? GetSocketTab()
			{
				object? obj = _socketTabField?.GetValue(null);
				return (Transform?)((obj is Transform) ? obj : null);
			}

			public string GetSocketCostMode()
			{
				try
				{
					object? obj = _socketCostField?.GetValue(null);
					ConfigEntryBase val = (ConfigEntryBase)((obj is ConfigEntryBase) ? obj : null);
					return (val == null) ? "" : (val.BoxedValue?.ToString() ?? "");
				}
				catch
				{
					return "";
				}
			}

			public bool IsSocketTabOpen()
			{
				try
				{
					object obj = _socketTabOpenMethod?.Invoke(null, null);
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}
		}

		private enum JewelcraftingSocketTabState
		{
			Unavailable,
			PrimaryCraftingTab,
			Closed,
			Selected
		}

		private sealed class JewelcraftingEffectApi
		{
			private readonly MethodInfo _calculateEffectsMethod;

			private bool _warningLogged;

			private JewelcraftingEffectApi(MethodInfo calculateEffectsMethod)
			{
				_calculateEffectsMethod = calculateEffectsMethod;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingEffectApi? api, out string detail)
			{
				api = null;
				MethodInfo methodInfo = assembly.GetType("Jewelcrafting.GemEffects.TrackEquipmentChanges")?.GetMethod("CalculateEffects", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Player) }, null);
				if (methodInfo == null)
				{
					detail = "TrackEquipmentChanges.CalculateEffects(Player) was not found";
					return false;
				}
				api = new JewelcraftingEffectApi(methodInfo);
				detail = "";
				return true;
			}

			public void Recalculate(Player player)
			{
				if ((Object)(object)player == (Object)null || IsUnityNull((Object?)(object)player))
				{
					return;
				}
				try
				{
					_calculateEffectsMethod.Invoke(null, new object[1] { player });
				}
				catch (Exception ex)
				{
					if (!_warningLogged)
					{
						_warningLogged = true;
						Log.LogWarning((object)("Failed to recalculate Jewelcrafting equipment effects: " + ex.GetBaseException().Message));
					}
				}
			}
		}

		private sealed class JewelcraftingGemApi
		{
			private readonly MethodInfo _getGemsMethod;

			private readonly MethodInfo? _itemDataMethod;

			private readonly MethodInfo? _itemInfoGetSocketableMethod;

			private readonly MethodInfo? _itemInfoGetItemContainerMethod;

			private readonly FieldInfo? _socketedGemsField;

			private readonly FieldInfo? _socketNameField;

			private readonly FieldInfo? _socketSeedField;

			private readonly FieldInfo? _openEquipmentField;

			private readonly FieldInfo? _openInventoryField;

			private readonly MethodInfo? _openSocketContainerMethod;

			private readonly FieldInfo? _inventoryInteractBehaviourField;

			private readonly FieldInfo? _inventorySocketingField;

			private readonly Type? _itemBagType;

			private readonly PropertyInfo? _itemInfoItemDataProperty;

			private readonly MethodInfo? _itemInfoGetAllSocketSeedsMethod;

			private readonly PropertyInfo? _socketSeedSeedProperty;

			private readonly Dictionary<Type, MemberInfo?> _gemSpriteMembers = new Dictionary<Type, MemberInfo>();

			private readonly Dictionary<Type, MemberInfo?> _gemPrefabMembers = new Dictionary<Type, MemberInfo>();

			private JewelcraftingGemApi(MethodInfo getGemsMethod, MethodInfo? itemDataMethod, MethodInfo? itemInfoGetSocketableMethod, MethodInfo? itemInfoGetItemContainerMethod, FieldInfo? socketedGemsField, FieldInfo? socketNameField, FieldInfo? socketSeedField, FieldInfo? openEquipmentField, FieldInfo? openInventoryField, MethodInfo? openSocketContainerMethod, FieldInfo? inventoryInteractBehaviourField, FieldInfo? inventorySocketingField, Type? itemBagType, PropertyInfo? itemInfoItemDataProperty, MethodInfo? itemInfoGetAllSocketSeedsMethod, PropertyInfo? socketSeedSeedProperty)
			{
				_getGemsMethod = getGemsMethod;
				_itemDataMethod = itemDataMethod;
				_itemInfoGetSocketableMethod = itemInfoGetSocketableMethod;
				_itemInfoGetItemContainerMethod = itemInfoGetItemContainerMethod;
				_socketedGemsField = socketedGemsField;
				_socketNameField = socketNameField;
				_socketSeedField = socketSeedField;
				_openEquipmentField = openEquipmentField;
				_openInventoryField = openInventoryField;
				_openSocketContainerMethod = openSocketContainerMethod;
				_inventoryInteractBehaviourField = inventoryInteractBehaviourField;
				_inventorySocketingField = inventorySocketingField;
				_itemBagType = itemBagType;
				_itemInfoItemDataProperty = itemInfoItemDataProperty;
				_itemInfoGetAllSocketSeedsMethod = itemInfoGetAllSocketSeedsMethod;
				_socketSeedSeedProperty = socketSeedSeedProperty;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingGemApi? api, out string detail)
			{
				api = null;
				MethodInfo methodInfo = assembly.GetType("Jewelcrafting.API")?.GetMethod("GetGems", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, null);
				if (methodInfo == null)
				{
					detail = "API.GetGems was not found";
					return false;
				}
				Type? type = assembly.GetType("ItemDataManager.ItemExtensions");
				Type type2 = assembly.GetType("ItemDataManager.ItemInfo");
				Type type3 = assembly.GetType("Jewelcrafting.Socketable");
				Type type4 = assembly.GetType("Jewelcrafting.ItemContainer");
				Type type5 = assembly.GetType("Jewelcrafting.ItemBag");
				Type type6 = assembly.GetType("Jewelcrafting.SocketItem");
				Type type7 = assembly.GetType("Jewelcrafting.Jewelcrafting");
				Type type8 = assembly.GetType("Jewelcrafting.GemStones+AddFakeSocketsContainer");
				Type type9 = assembly.GetType("Jewelcrafting.GemStones+OpenFakeSocketsContainer");
				Type type10 = assembly.GetType("Jewelcrafting.SocketSeed");
				MethodInfo itemDataMethod = type?.GetMethod("Data", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, null);
				MethodInfo itemInfoGetAllSocketSeedsMethod = null;
				MethodInfo itemInfoGetSocketableMethod = null;
				MethodInfo methodInfo2 = null;
				if (type2 != null)
				{
					MethodInfo[] methods = type2.GetMethods(BindingFlags.Instance | BindingFlags.Public);
					foreach (MethodInfo methodInfo3 in methods)
					{
						if (methodInfo3.Name == "Get" && methodInfo3.IsGenericMethodDefinition)
						{
							ParameterInfo[] parameters = methodInfo3.GetParameters();
							if (type3 != null && parameters.Length == 1)
							{
								itemInfoGetSocketableMethod = methodInfo3.MakeGenericMethod(type3);
							}
							if (type4 != null && (parameters.Length == 0 || (parameters.Length == 1 && methodInfo2 == null)))
							{
								methodInfo2 = methodInfo3.MakeGenericMethod(type4);
							}
						}
						else if (type10 != null && methodInfo3.Name == "GetAll" && methodInfo3.IsGenericMethodDefinition && methodInfo3.GetParameters().Length == 0)
						{
							itemInfoGetAllSocketSeedsMethod = methodInfo3.MakeGenericMethod(type10);
						}
					}
				}
				api = new JewelcraftingGemApi(methodInfo, itemDataMethod, itemInfoGetSocketableMethod, methodInfo2, type3?.GetField("socketedGems", BindingFlags.Instance | BindingFlags.Public), type6?.GetField("Name", BindingFlags.Instance | BindingFlags.Public), type6?.GetField("Seed", BindingFlags.Instance | BindingFlags.Public), type8?.GetField("openEquipment", BindingFlags.Static | BindingFlags.Public), type8?.GetField("openInventory", BindingFlags.Static | BindingFlags.Public), type9?.GetMethod("Open", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(InventoryGui),
					typeof(ItemData)
				}, null), type7?.GetField("inventoryInteractBehaviour", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), type7?.GetField("inventorySocketing", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), type5, type2?.GetProperty("ItemData", BindingFlags.Instance | BindingFlags.Public), itemInfoGetAllSocketSeedsMethod, type10?.GetProperty("Seed", BindingFlags.Instance | BindingFlags.Public));
				detail = "";
				return true;
			}

			public object? GetGems(ItemData item)
			{
				return _getGemsMethod.Invoke(null, new object[1] { item });
			}

			public bool CanOpenSocketContainerFromInventory(ItemData item, bool gemcutterStationActive)
			{
				object itemContainer = GetItemContainer(item);
				if (itemContainer == null || string.Equals(GetConfigEntryValueName(_inventoryInteractBehaviourField), "Enabled", StringComparison.Ordinal))
				{
					return false;
				}
				string configEntryValueName = GetConfigEntryValueName(_inventorySocketingField);
				return string.IsNullOrWhiteSpace(configEntryValueName) || string.Equals(configEntryValueName, "On", StringComparison.Ordinal) || IsItemBag(itemContainer) || gemcutterStationActive;
			}

			public bool HasSocketContainer(ItemData item)
			{
				return GetItemContainer(item) != null;
			}

			public bool TryOpenSocketContainer(InventoryGui gui, ItemData item)
			{
				if (_openSocketContainerMethod == null || (Object)(object)gui == (Object)null || item?.m_shared == null)
				{
					return false;
				}
				try
				{
					return _openSocketContainerMethod.Invoke(null, new object[2] { gui, item }) is bool flag && !flag;
				}
				catch (Exception)
				{
					return false;
				}
			}

			public ItemData? GetOpenSocketContainerItem()
			{
				if (_openEquipmentField == null || _itemInfoItemDataProperty == null)
				{
					return null;
				}
				try
				{
					object value = _openEquipmentField.GetValue(null);
					return (ItemData?)((value != null) ? /*isinst with value type is only supported in some contexts*/: null);
				}
				catch
				{
					return null;
				}
			}

			private object? GetItemContainer(ItemData item)
			{
				if (_itemDataMethod == null || _itemInfoGetItemContainerMethod == null || item?.m_shared == null)
				{
					return null;
				}
				try
				{
					object obj = _itemDataMethod.Invoke(null, new object[1] { item });
					return (obj != null) ? InvokeItemInfoGet(_itemInfoGetItemContainerMethod, obj) : null;
				}
				catch
				{
					return null;
				}
			}

			private static object? InvokeItemInfoGet(MethodInfo method, object itemInfo)
			{
				if (method.GetParameters().Length != 0)
				{
					return method.Invoke(itemInfo, new object[1] { "" });
				}
				return method.Invoke(itemInfo, Array.Empty<object>());
			}

			private bool IsItemBag(object itemContainer)
			{
				if (_itemBagType != null)
				{
					return _itemBagType.IsInstanceOfType(itemContainer);
				}
				return false;
			}

			private static string GetConfigEntryValueName(FieldInfo? field)
			{
				if (field == null)
				{
					return "";
				}
				try
				{
					object value = field.GetValue(null);
					return (value?.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value))?.ToString() ?? "";
				}
				catch
				{
					return "";
				}
			}

			public Inventory? GetOpenSocketContainerInventory()
			{
				if (_openInventoryField == null)
				{
					return null;
				}
				try
				{
					object? value = _openInventoryField.GetValue(null);
					return (Inventory?)((value is Inventory) ? value : null);
				}
				catch
				{
					return null;
				}
			}

			public bool TryGetGemIconData(object gem, out Sprite? sprite, out string prefabName)
			{
				sprite = null;
				prefabName = "";
				if (gem == null)
				{
					return false;
				}
				Type type = gem.GetType();
				if (!_gemSpriteMembers.TryGetValue(type, out MemberInfo value))
				{
					value = FindGemMember(type, typeof(Sprite), "gemSprite", "GemSprite", "sprite", "Sprite", "icon", "Icon", "gemIcon", "GemIcon");
					_gemSpriteMembers[type] = value;
				}
				if (!_gemPrefabMembers.TryGetValue(type, out MemberInfo value2))
				{
					value2 = FindGemMember(type, null, "gemPrefab", "GemPrefab", "prefab", "Prefab", "prefabName", "PrefabName", "name", "Name");
					_gemPrefabMembers[type] = value2;
				}
				object? gemMemberValue = GetGemMemberValue(value, gem);
				sprite = (Sprite?)((gemMemberValue is Sprite) ? gemMemberValue : null);
				object gemMemberValue2 = GetGemMemberValue(value2, gem);
				object obj = gemMemberValue2;
				string text2;
				if (!(obj is string text))
				{
					GameObject val = (GameObject)((obj is GameObject) ? obj : null);
					if (val == null)
					{
						ItemDrop val2 = (ItemDrop)((obj is ItemDrop) ? obj : null);
						if (val2 == null || !((Object)(object)val2 != (Object)null) || IsUnityNull((Object?)(object)val2))
						{
							goto IL_017e;
						}
						text2 = ((Object)((Component)val2).gameObject).name;
					}
					else
					{
						if (!((Object)(object)val != (Object)null) || IsUnityNull((Object?)(object)val))
						{
							goto IL_017e;
						}
						text2 = ((Object)val).name;
					}
				}
				else
				{
					text2 = text;
				}
				goto IL_0195;
				IL_017e:
				text2 = gemMemberValue2?.ToString() ?? "";
				goto IL_0195;
				IL_0195:
				prefabName = text2;
				if (!((Object)(object)sprite != (Object)null))
				{
					return !string.IsNullOrWhiteSpace(prefabName);
				}
				return true;
			}

			public List<JewelcraftingSocketGemData> GetSocketGemData(ItemData item)
			{
				List<JewelcraftingSocketGemData> list = new List<JewelcraftingSocketGemData>();
				if (_itemDataMethod == null || _itemInfoGetSocketableMethod == null || _socketedGemsField == null || _socketNameField == null)
				{
					return list;
				}
				try
				{
					object obj = _itemDataMethod.Invoke(null, new object[1] { item });
					object obj2 = ((obj != null) ? _itemInfoGetSocketableMethod.Invoke(obj, new object[1] { "" }) : null);
					if (obj2 == null || !(_socketedGemsField.GetValue(obj2) is IEnumerable enumerable))
					{
						return list;
					}
					foreach (object item2 in enumerable)
					{
						if (item2 == null)
						{
							list.Add(new JewelcraftingSocketGemData("", null));
							continue;
						}
						string prefabName = (_socketNameField.GetValue(item2) as string) ?? "";
						Dictionary<string, uint> seeds = CopySocketSeeds(_socketSeedField?.GetValue(item2));
						list.Add(new JewelcraftingSocketGemData(prefabName, seeds));
					}
				}
				catch (Exception)
				{
				}
				return list;
			}

			public List<JewelcraftingSocketGemData> GetOpenSocketGemData(ItemData item)
			{
				List<JewelcraftingSocketGemData> list = new List<JewelcraftingSocketGemData>();
				ItemData openSocketContainerItem = GetOpenSocketContainerItem();
				Inventory openSocketContainerInventory = GetOpenSocketContainerInventory();
				if (openSocketContainerItem?.m_shared == null || openSocketContainerInventory == null || !IsSameOpenSocketContainerItem(item, openSocketContainerItem))
				{
					return list;
				}
				int num = Math.Max(1, openSocketContainerInventory.m_width);
				int num2 = Math.Max(0, num * Math.Max(0, openSocketContainerInventory.m_height));
				for (int i = 0; i < num2; i++)
				{
					list.Add(new JewelcraftingSocketGemData("", null));
				}
				foreach (ItemData item2 in openSocketContainerInventory.m_inventory)
				{
					if (item2?.m_shared != null)
					{
						int num3 = item2.m_gridPos.x + item2.m_gridPos.y * num;
						if (num3 >= 0 && num3 < list.Count)
						{
							string prefabName = (((Object)(object)item2.m_dropPrefab != (Object)null && !IsUnityNull((Object?)(object)item2.m_dropPrefab)) ? ((Object)item2.m_dropPrefab).name : GetItemPrefabName(item2));
							list[num3] = new JewelcraftingSocketGemData(prefabName, GetSocketSeedData(item2));
						}
					}
				}
				return list;
			}

			private static Dictionary<string, uint>? CopySocketSeeds(object? seedObject)
			{
				if (!(seedObject is IDictionary { Count: not 0 } dictionary))
				{
					return null;
				}
				Dictionary<string, uint> dictionary2 = new Dictionary<string, uint>();
				foreach (DictionaryEntry item in dictionary)
				{
					string text = item.Key?.ToString() ?? "";
					if (!string.IsNullOrWhiteSpace(text))
					{
						uint result;
						if (item.Value is uint value)
						{
							dictionary2[text] = value;
						}
						else if (item.Value != null && uint.TryParse(item.Value.ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
						{
							dictionary2[text] = result;
						}
					}
				}
				if (dictionary2.Count <= 0)
				{
					return null;
				}
				return dictionary2;
			}

			private Dictionary<string, uint>? GetSocketSeedData(ItemData gem)
			{
				if (_itemDataMethod == null || _itemInfoGetAllSocketSeedsMethod == null || _socketSeedSeedProperty == null)
				{
					return null;
				}
				try
				{
					object obj = _itemDataMethod.Invoke(null, new object[1] { gem });
					if (!(((obj != null) ? _itemInfoGetAllSocketSeedsMethod.Invoke(obj, null) : null) is IDictionary { Count: not 0 } dictionary))
					{
						return null;
					}
					Dictionary<string, uint> dictionary2 = new Dictionary<string, uint>();
					foreach (DictionaryEntry item in dictionary)
					{
						string text = item.Key?.ToString() ?? "";
						if (!string.IsNullOrWhiteSpace(text) && item.Value != null)
						{
							object value = _socketSeedSeedProperty.GetValue(item.Value);
							uint result;
							if (value is uint value2)
							{
								dictionary2[text] = value2;
							}
							else if (value != null && uint.TryParse(value.ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
							{
								dictionary2[text] = result;
							}
						}
					}
					return (dictionary2.Count > 0) ? dictionary2 : null;
				}
				catch
				{
					return null;
				}
			}

			private static bool IsSameOpenSocketContainerItem(ItemData item, ItemData openItem)
			{
				if (item == openItem)
				{
					return true;
				}
				if (item.m_shared != null && openItem.m_shared != null && string.Equals(GetItemPrefabName(item), GetItemPrefabName(openItem), StringComparison.Ordinal) && string.Equals(item.m_shared.m_name, openItem.m_shared.m_name, StringComparison.Ordinal) && item.m_variant == openItem.m_variant && item.m_quality == openItem.m_quality && item.m_gridPos.x == openItem.m_gridPos.x)
				{
					return item.m_gridPos.y == openItem.m_gridPos.y;
				}
				return false;
			}

			private static MemberInfo? FindGemMember(Type type, Type? targetType, params string[] names)
			{
				foreach (string name in names)
				{
					FieldInfo field = type.GetField(name, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null && (targetType == null || targetType.IsAssignableFrom(field.FieldType) || (targetType == typeof(IDictionary) && typeof(IDictionary).IsAssignableFrom(field.FieldType))))
					{
						return field;
					}
					PropertyInfo property = type.GetProperty(name, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if ((object)property != null && property.GetIndexParameters().Length == 0 && (targetType == null || targetType.IsAssignableFrom(property.PropertyType) || (targetType == typeof(IDictionary) && typeof(IDictionary).IsAssignableFrom(property.PropertyType))))
					{
						return property;
					}
				}
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (targetType != null && (targetType.IsAssignableFrom(fieldInfo.FieldType) || (targetType == typeof(IDictionary) && typeof(IDictionary).IsAssignableFrom(fieldInfo.FieldType))))
					{
						return fieldInfo;
					}
				}
				return null;
			}

			private static object? GetGemMemberValue(MemberInfo? member, object instance)
			{
				try
				{
					return (member is FieldInfo fieldInfo) ? fieldInfo.GetValue(instance) : ((!(member is PropertyInfo { CanRead: not false } propertyInfo) || propertyInfo.GetIndexParameters().Length != 0) ? null : propertyInfo.GetValue(instance));
				}
				catch
				{
					return null;
				}
			}
		}

		private sealed class JewelcraftingGemCuttingApi
		{
			private readonly FieldInfo _gemUpgradeChancesField;

			private JewelcraftingGemCuttingApi(FieldInfo gemUpgradeChancesField)
			{
				_gemUpgradeChancesField = gemUpgradeChancesField;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingGemCuttingApi? api, out string detail)
			{
				api = null;
				FieldInfo fieldInfo = assembly.GetType("Jewelcrafting.Jewelcrafting")?.GetField("gemUpgradeChances", BindingFlags.Static | BindingFlags.Public);
				if (fieldInfo == null)
				{
					detail = "Jewelcrafting.gemUpgradeChances was not found";
					return false;
				}
				api = new JewelcraftingGemCuttingApi(fieldInfo);
				detail = "";
				return true;
			}

			public bool IsGemCuttingRecipe(Recipe recipe)
			{
				string text = (((Object)(object)recipe.m_item != (Object)null) ? (recipe.m_item.m_itemData.m_shared.m_name ?? "") : "");
				if (string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				try
				{
					return _gemUpgradeChancesField.GetValue(null) is IDictionary dictionary && dictionary.Contains(text);
				}
				catch
				{
					return false;
				}
			}
		}

		private readonly struct JewelcraftingGemIconData
		{
			public readonly Sprite Sprite;

			public readonly string DisplayName;

			public JewelcraftingGemIconData(Sprite sprite, string displayName)
			{
				Sprite = sprite;
				DisplayName = displayName;
			}
		}

		private readonly struct JewelcraftingSocketGemData
		{
			public readonly string PrefabName;

			public readonly Dictionary<string, uint>? Seeds;

			public bool HasGem => !string.IsNullOrWhiteSpace(PrefabName);

			public JewelcraftingSocketGemData(string prefabName, Dictionary<string, uint>? seeds)
			{
				PrefabName = prefabName ?? "";
				Seeds = seeds;
			}
		}

		private sealed class JewelcraftingSlotApi
		{
			private readonly FieldInfo _ringSlotField;

			private readonly FieldInfo _necklaceSlotField;

			private readonly FieldInfo? _wisplightGemField;

			private readonly FieldInfo? _wishboneGemField;

			private readonly MethodInfo? _isJewelryEquippedMethod;

			private ConfigEntryBase? _ringSlotConfig;

			private ConfigEntryBase? _necklaceSlotConfig;

			private ConfigEntryBase? _wisplightGemConfig;

			private ConfigEntryBase? _wishboneGemConfig;

			private JewelcraftingSlotApi(FieldInfo ringSlotField, FieldInfo necklaceSlotField, FieldInfo? wisplightGemField, FieldInfo? wishboneGemField, MethodInfo? isJewelryEquippedMethod)
			{
				_ringSlotField = ringSlotField;
				_necklaceSlotField = necklaceSlotField;
				_wisplightGemField = wisplightGemField;
				_wishboneGemField = wishboneGemField;
				_isJewelryEquippedMethod = isJewelryEquippedMethod;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingSlotApi? api, out string detail)
			{
				api = null;
				Type? type = assembly.GetType("Jewelcrafting.Jewelcrafting");
				Type type2 = assembly.GetType("Jewelcrafting.API");
				FieldInfo fieldInfo = type?.GetField("ringSlot", BindingFlags.Static | BindingFlags.Public);
				FieldInfo fieldInfo2 = type?.GetField("necklaceSlot", BindingFlags.Static | BindingFlags.Public);
				FieldInfo wisplightGemField = type?.GetField("wisplightGem", BindingFlags.Static | BindingFlags.Public);
				FieldInfo wishboneGemField = type?.GetField("wishboneGem", BindingFlags.Static | BindingFlags.Public);
				if (fieldInfo == null || fieldInfo2 == null)
				{
					detail = "ringSlot or necklaceSlot config field was not found";
					return false;
				}
				MethodInfo isJewelryEquippedMethod = type2?.GetMethod("IsJewelryEquipped", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(Player),
					typeof(string)
				}, null);
				api = new JewelcraftingSlotApi(fieldInfo, fieldInfo2, wisplightGemField, wishboneGemField, isJewelryEquippedMethod);
				detail = "";
				return true;
			}

			public bool IsRingEnabled()
			{
				return GetCompatConfigEntryToggleOn(_ringSlotField, ref _ringSlotConfig);
			}

			public bool IsNecklaceEnabled()
			{
				return GetCompatConfigEntryToggleOn(_necklaceSlotField, ref _necklaceSlotConfig);
			}

			public bool IsWisplightGemEnabled()
			{
				if (_wisplightGemField != null)
				{
					return GetCompatConfigEntryToggleOn(_wisplightGemField, ref _wisplightGemConfig);
				}
				return false;
			}

			public bool IsWishboneGemEnabled()
			{
				if (_wishboneGemField != null)
				{
					return GetCompatConfigEntryToggleOn(_wishboneGemField, ref _wishboneGemConfig);
				}
				return false;
			}

			public bool TryGetIsJewelryEquippedMethod(out MethodBase? method)
			{
				method = _isJewelryEquippedMethod;
				return method != null;
			}
		}

		private sealed class JewelcraftingTooltipApi
		{
			private readonly MethodInfo _fillItemContainerTooltipMethod;

			private readonly FieldInfo _socketTooltipField;

			private readonly FieldInfo? _advancedTooltipKeyField;

			private JewelcraftingTooltipApi(MethodInfo fillItemContainerTooltipMethod, FieldInfo socketTooltipField, FieldInfo? advancedTooltipKeyField)
			{
				_fillItemContainerTooltipMethod = fillItemContainerTooltipMethod;
				_socketTooltipField = socketTooltipField;
				_advancedTooltipKeyField = advancedTooltipKeyField;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingTooltipApi? api, out string detail)
			{
				api = null;
				Type? type = assembly.GetType("Jewelcrafting.API");
				Type type2 = assembly.GetType("Jewelcrafting.GemStoneSetup");
				Type type3 = assembly.GetType("Jewelcrafting.Jewelcrafting");
				MethodInfo methodInfo = type?.GetMethod("FillItemContainerTooltip", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(ItemData),
					typeof(Transform),
					typeof(bool)
				}, null);
				FieldInfo fieldInfo = type2?.GetField("SocketTooltip", BindingFlags.Static | BindingFlags.Public);
				if (methodInfo == null || fieldInfo == null)
				{
					detail = "required API members were not found";
					return false;
				}
				api = new JewelcraftingTooltipApi(methodInfo, fieldInfo, type3?.GetField("advancedTooltipKey", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic));
				detail = "";
				return true;
			}

			public void FillItemContainerTooltip(ItemData item, RectTransform root, bool showInteract)
			{
				_fillItemContainerTooltipMethod.Invoke(null, new object[3] { item, root, showInteract });
			}

			public GameObject? GetSocketTooltip()
			{
				object? value = _socketTooltipField.GetValue(null);
				return (GameObject?)((value is GameObject) ? value : null);
			}

			public bool TryIsAdvancedTooltipPressed(out bool pressed)
			{
				//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)
				pressed = false;
				if (!(_advancedTooltipKeyField?.GetValue(null) is ConfigEntry<KeyboardShortcut> val))
				{
					return false;
				}
				KeyboardShortcut value = val.Value;
				pressed = ((KeyboardShortcut)(ref value)).IsPressed();
				return true;
			}
		}

		private sealed class JewelcraftingVisualApi
		{
			private readonly FieldInfo _visualsField;

			private readonly FieldInfo _equippedFingerItemField;

			private readonly FieldInfo _equippedNeckItemField;

			private readonly FieldInfo? _currentFingerItemHashField;

			private readonly FieldInfo? _currentNeckItemHashField;

			private readonly MethodInfo? _setFingerItemMethod;

			private readonly MethodInfo? _setNeckItemMethod;

			private readonly MethodInfo? _setFingerEquippedMethod;

			private readonly MethodInfo? _setNeckEquippedMethod;

			private JewelcraftingVisualApi(FieldInfo visualsField, FieldInfo equippedFingerItemField, FieldInfo equippedNeckItemField, FieldInfo? currentFingerItemHashField, FieldInfo? currentNeckItemHashField, MethodInfo? setFingerItemMethod, MethodInfo? setNeckItemMethod, MethodInfo? setFingerEquippedMethod, MethodInfo? setNeckEquippedMethod)
			{
				_visualsField = visualsField;
				_equippedFingerItemField = equippedFingerItemField;
				_equippedNeckItemField = equippedNeckItemField;
				_currentFingerItemHashField = currentFingerItemHashField;
				_currentNeckItemHashField = currentNeckItemHashField;
				_setFingerItemMethod = setFingerItemMethod;
				_setNeckItemMethod = setNeckItemMethod;
				_setFingerEquippedMethod = setFingerEquippedMethod;
				_setNeckEquippedMethod = setNeckEquippedMethod;
			}

			public static bool TryCreate(Assembly assembly, out JewelcraftingVisualApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetType("Jewelcrafting.Visual");
				FieldInfo fieldInfo = type?.GetField("visuals", BindingFlags.Static | BindingFlags.Public);
				FieldInfo fieldInfo2 = type?.GetField("equippedFingerItem", BindingFlags.Instance | BindingFlags.Public);
				FieldInfo fieldInfo3 = type?.GetField("equippedNeckItem", BindingFlags.Instance | BindingFlags.Public);
				if (fieldInfo == null || fieldInfo2 == null || fieldInfo3 == null)
				{
					detail = "Visual fields were not found";
					return false;
				}
				api = new JewelcraftingVisualApi(fieldInfo, fieldInfo2, fieldInfo3, type?.GetField("currentFingerItemHash", BindingFlags.Instance | BindingFlags.Public), type?.GetField("currentNeckItemHash", BindingFlags.Instance | BindingFlags.Public), type?.GetMethod("setFingerItem", BindingFlags.Instance | BindingFlags.NonPublic), type?.GetMethod("setNeckItem", BindingFlags.Instance | BindingFlags.NonPublic), type?.GetMethod("setFingerEquipped", BindingFlags.Instance | BindingFlags.NonPublic), type?.GetMethod("setNeckEquipped", BindingFlags.Instance | BindingFlags.NonPublic));
				detail = "";
				return true;
			}

			public bool TryGetVisual(VisEquipment visEquipment, out object? visual)
			{
				visual = null;
				if (!(_visualsField.GetValue(null) is IDictionary dictionary) || !dictionary.Contains(visEquipment))
				{
					return false;
				}
				visual = dictionary[visEquipment];
				return visual != null;
			}

			public void ClearSlot(object visual, bool isRing)
			{
				FieldInfo fieldInfo = (isRing ? _equippedFingerItemField : _equippedNeckItemField);
				FieldInfo fieldInfo2 = (isRing ? _currentFingerItemHashField : _currentNeckItemHashField);
				MethodInfo? obj = (isRing ? _setFingerItemMethod : _setNeckItemMethod);
				MethodInfo methodInfo = (isRing ? _setFingerEquippedMethod : _setNeckEquippedMethod);
				fieldInfo.SetValue(visual, null);
				obj?.Invoke(visual, new object[1] { "" });
				if (methodInfo != null)
				{
					methodInfo.Invoke(visual, new object[1] { 0 });
				}
				else
				{
					fieldInfo2?.SetValue(visual, 0);
				}
			}
		}

		private sealed class MagicSupremacyApi
		{
			private readonly MethodInfo _getMatchingSlotDefinitionMethod;

			private readonly MethodInfo _getDefinitionBySlotIdMethod;

			private readonly MethodInfo _getEquippedItemMethod;

			private readonly MethodInfo _setEquippedItemMethod;

			private readonly MethodInfo _getOrCreateItemGuidMethod;

			private readonly MethodInfo _setSavedEquippedGuidMethod;

			private readonly MethodInfo _clearSavedEquippedGuidMethod;

			private readonly FieldInfo _slotIdField;

			private object? _beltDefinition;

			private MagicSupremacyApi(MethodInfo getMatchingSlotDefinitionMethod, MethodInfo getDefinitionBySlotIdMethod, MethodInfo getEquippedItemMethod, MethodInfo setEquippedItemMethod, MethodInfo getOrCreateItemGuidMethod, MethodInfo setSavedEquippedGuidMethod, MethodInfo clearSavedEquippedGuidMethod, FieldInfo slotIdField)
			{
				_getMatchingSlotDefinitionMethod = getMatchingSlotDefinitionMethod;
				_getDefinitionBySlotIdMethod = getDefinitionBySlotIdMethod;
				_getEquippedItemMethod = getEquippedItemMethod;
				_setEquippedItemMethod = setEquippedItemMethod;
				_getOrCreateItemGuidMethod = getOrCreateItemGuidMethod;
				_setSavedEquippedGuidMethod = setSavedEquippedGuidMethod;
				_clearSavedEquippedGuidMethod = clearSavedEquippedGuidMethod;
				_slotIdField = slotIdField;
			}

			public static bool TryCreate(Assembly assembly, out MagicSupremacyApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetType("Magic_Supremacy.CustomSlotSystem");
				Type type2 = type?.GetNestedType("CustomSlotDefinition", BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo methodInfo = type?.GetMethod("GetMatchingSlotDefinition", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, null);
				MethodInfo methodInfo2 = type?.GetMethod("GetDefinitionBySlotId", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
				MethodInfo methodInfo3 = type?.GetMethod("GetEquippedItem", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(Humanoid),
					typeof(string)
				}, null);
				MethodInfo methodInfo4 = type?.GetMethod("SetEquippedItem", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(Humanoid),
					typeof(string),
					typeof(ItemData)
				}, null);
				MethodInfo methodInfo5 = type?.GetMethod("GetOrCreateItemGuid", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[1] { typeof(ItemData) }, null);
				MethodInfo methodInfo6 = FindMethod(type, "SetSavedEquippedGuid", 3);
				MethodInfo methodInfo7 = FindMethod(type, "ClearSavedEquippedGuid", 2);
				FieldInfo fieldInfo = type2?.GetField("SlotId", BindingFlags.Instance | BindingFlags.Public);
				if (type == null || type2 == null || methodInfo == null || methodInfo2 == null || methodInfo3 == null || methodInfo4 == null || methodInfo5 == null || methodInfo6 == null || methodInfo7 == null || fieldInfo == null)
				{
					detail = "Magic_Supremacy.CustomSlotSystem belt slot methods were not found";
					return false;
				}
				api = new MagicSupremacyApi(methodInfo, methodInfo2, methodInfo3, methodInfo4, methodInfo5, methodInfo6, methodInfo7, fieldInfo);
				detail = "";
				return true;
			}

			public bool IsBeltItem(ItemData? item)
			{
				if (item == null)
				{
					return false;
				}
				try
				{
					object definition = _getMatchingSlotDefinitionMethod.Invoke(null, new object[1] { item });
					return IsBeltDefinition(definition);
				}
				catch
				{
					return false;
				}
			}

			public bool IsBeltEquipped(Player player, ItemData item)
			{
				if ((Object)(object)player == (Object)null || item == null)
				{
					return false;
				}
				try
				{
					return _getEquippedItemMethod.Invoke(null, new object[2] { player, "belt" }) == item;
				}
				catch
				{
					return false;
				}
			}

			public void SyncBelt(Player player, ItemData item)
			{
				if ((Object)(object)player == (Object)null || item == null || !IsBeltItem(item))
				{
					return;
				}
				try
				{
					object beltDefinition = GetBeltDefinition();
					if (beltDefinition != null)
					{
						if (_getOrCreateItemGuidMethod.Invoke(null, new object[1] { item }) is string text && !string.IsNullOrWhiteSpace(text))
						{
							_setSavedEquippedGuidMethod.Invoke(null, new object[3] { player, beltDefinition, text });
						}
						_setEquippedItemMethod.Invoke(null, new object[3] { player, "belt", item });
					}
				}
				catch (Exception)
				{
				}
			}

			public void ClearBeltIfCurrent(Player player, ItemData item)
			{
				if ((Object)(object)player == (Object)null || item == null)
				{
					return;
				}
				try
				{
					object obj = _getEquippedItemMethod.Invoke(null, new object[2] { player, "belt" });
					if (obj == null || obj == item)
					{
						object beltDefinition = GetBeltDefinition();
						_setEquippedItemMethod.Invoke(null, new object[3] { player, "belt", null });
						if (beltDefinition != null)
						{
							_clearSavedEquippedGuidMethod.Invoke(null, new object[2] { player, beltDefinition });
						}
					}
				}
				catch (Exception)
				{
				}
			}

			private object? GetBeltDefinition()
			{
				if (_beltDefinition != null)
				{
					return _beltDefinition;
				}
				_beltDefinition = _getDefinitionBySlotIdMethod.Invoke(null, new object[1] { "belt" });
				if (!IsBeltDefinition(_beltDefinition))
				{
					return null;
				}
				return _beltDefinition;
			}

			private bool IsBeltDefinition(object? definition)
			{
				if (definition == null)
				{
					return false;
				}
				try
				{
					return _slotIdField.GetValue(definition) is string a && string.Equals(a, "belt", StringComparison.Ordinal);
				}
				catch
				{
					return false;
				}
			}

			private static MethodInfo? FindMethod(Type? type, string name, int parameterCount)
			{
				if (type == null)
				{
					return null;
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.Name == name && methodInfo.GetParameters().Length == parameterCount)
					{
						return methodInfo;
					}
				}
				return null;
			}
		}

		private enum MultiUserContainerBatchKind
		{
			TakeAll,
			PlaceStacks,
			AreaPlaceStacks,
			AreaFavoriteRestock
		}

		private sealed class MultiUserContainerBatchItem
		{
			public Vector2i SourcePosition;

			public ItemData Identity;

			public int RemainingAmount;

			public int ExpectedStack;

			public bool MovedAny;
		}

		private sealed class MultiUserContainerBatchTarget
		{
			public Container Container;

			public ZDOID ContainerId;

			public bool HasContainerId;

			public bool MovedAny;
		}

		private sealed class MultiUserContainerBatchState
		{
			public MultiUserContainerBatchKind Kind;

			public ZDOID ContainerId;

			public readonly List<MultiUserContainerBatchTarget> Containers = new List<MultiUserContainerBatchTarget>();

			public readonly List<MultiUserContainerBatchItem> Items = new List<MultiUserContainerBatchItem>();

			public int ContainerIndex;

			public int ItemIndex;

			public int PendingAmount;

			public int MovedStacks;

			public int MovedAmount;

			public int ChangedContainerVfxCount;

			public float AreaRangeSquared;

			public bool WaitingForTransfer;
		}

		private enum MultiUserContainerRecoveryMode
		{
			InventoryFirst,
			RegularInventoryFirst,
			BatchInventoryFirst,
			ConsumeAfterInventory,
			WorldFirst
		}

		private enum MultiUserContainerLocalPlacementPolicy
		{
			AnyUsable,
			RegularAndHotbar,
			ContainerBatch
		}

		private enum MultiUserContainerWorldDeliveryResult
		{
			NotAttempted,
			Succeeded,
			DefinitelyNotSpawned,
			Uncertain
		}

		private sealed class PendingMultiUserContainerTransfer
		{
			public Container Container;

			public ZDOID ContainerId;

			public long RequesterPeerId;

			public long Owner;

			public HashSet<long> RequestOwners = new HashSet<long>();

			public MultiUserContainerRequest Request;

			public byte[] RequestBytes;

			public byte[] RequestDigest;

			public Inventory? LocalInventory;

			public ItemData? LocalEscrow;

			public Vector2i PreferredLocalPosition;

			public Inventory? Projection;

			public float StartedAt;

			public float LastSentAt;

			public float LastReceiptCheckAt;

			public int SendAttempts;

			public bool TimeoutNotified;

			public bool ResponseApplied;

			public bool AuthoritativeStateObserved;

			public float ResponseAppliedAt;

			public bool AuthorityChangedOrReloaded;

			public bool TerminalFailureReceived;

			public bool LocalRecoveryPending;

			public ItemData? PendingRecoveryItem;

			public bool AcknowledgementPending;

			public bool PermanentlyDestroyed;

			public MultiUserContainerRecoveryMode RecoveryMode;

			public bool CompletionActionAttempted;

			public MultiUserContainerWorldDeliveryResult WorldDeliveryResult;
		}

		private sealed class PendingMultiUserContainerLocalRecovery
		{
			public Inventory? Inventory;

			public ItemData Item;

			public Vector2i PreferredPosition;

			public float NextAttemptAt;

			public MultiUserContainerLocalPlacementPolicy PlacementPolicy;
		}

		private enum MultiUserContainerOperation : byte
		{
			Add = 1,
			Remove,
			Move,
			Exchange,
			Swap
		}

		private enum MultiUserContainerFailure : byte
		{
			None,
			Disabled,
			InvalidRequest,
			AccessDenied,
			OwnerChanged,
			ItemChanged,
			DestinationChanged
		}

		private sealed class MultiUserContainerRequest
		{
			public int RequestId;

			public MultiUserContainerOperation Operation;

			public long RequesterPlayerId;

			public Vector2i SourcePosition;

			public Vector2i TargetPosition;

			public int ExpectedTargetStack;

			public int Amount;

			public ItemData Item;

			public ItemData? CounterpartItem;
		}

		private sealed class MultiUserContainerResponse
		{
			public int RequestId;

			public MultiUserContainerOperation Operation;

			public bool Success;

			public MultiUserContainerFailure Failure;

			public int Amount;

			public Vector2i SourcePosition;

			public Vector2i TargetPosition;

			public ItemData? Item;
		}

		private readonly struct MultiUserContainerOwnerRequestKey : IEquatable<MultiUserContainerOwnerRequestKey>
		{
			public long Sender { get; }

			public int RequestId { get; }

			public MultiUserContainerOwnerRequestKey(long sender, int requestId)
			{
				Sender = sender;
				RequestId = requestId;
			}

			public bool Equals(MultiUserContainerOwnerRequestKey other)
			{
				if (Sender == other.Sender)
				{
					return RequestId == other.RequestId;
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				return (Sender.GetHashCode() * 397) ^ RequestId;
			}
		}

		private sealed class MultiUserContainerOwnerResponse
		{
			public float CreatedAt;

			public byte[] RequestDigest;

			public byte[] ResponseBytes;
		}

		private sealed class MultiUserContainerUncertainRequest
		{
			public byte[] RequestDigest;
		}

		private sealed class MultiUserContainerDurableReceipt
		{
			public bool Acknowledged;

			public long RequesterPlayerId;

			public long Sender;

			public int RequestId;

			public long CreatedUtcTicks;

			public byte[] RequestDigest;

			public byte[] ResponseBytes;
		}

		private sealed class MultiUserContainerOwnerState
		{
			public readonly Dictionary<MultiUserContainerOwnerRequestKey, MultiUserContainerOwnerResponse> Responses = new Dictionary<MultiUserContainerOwnerRequestKey, MultiUserContainerOwnerResponse>();

			public readonly Dictionary<MultiUserContainerOwnerRequestKey, MultiUserContainerUncertainRequest> UncertainRequests = new Dictionary<MultiUserContainerOwnerRequestKey, MultiUserContainerUncertainRequest>();

			public int TotalResponseBytes;
		}

		private enum PinnedTooltipContext
		{
			None,
			InventoryContainer,
			CraftingCraft,
			CraftingUpgrade
		}

		private readonly struct PinnedTooltipVerticalFrame
		{
			public readonly float TopY;

			public readonly float BottomY;

			public readonly float Height;

			public PinnedTooltipVerticalFrame(float topY, float bottomY)
			{
				TopY = topY;
				BottomY = bottomY;
				Height = Mathf.Max(1f, topY - bottomY);
			}
		}

		private readonly struct InventoryPinnedTooltipTarget
		{
			public InventoryGrid Grid { get; }

			public Vector2i Pos { get; }

			public ItemData Item { get; }

			public InventoryPinnedTooltipTarget(InventoryGrid grid, Vector2i pos, ItemData item)
			{
				//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)
				Grid = grid;
				Pos = pos;
				Item = item;
			}
		}

		public enum Toggle
		{
			Off,
			On
		}

		public enum CraftingHoverTooltipMode
		{
			Full,
			TitleOnly,
			Off
		}

		public enum InventoryRowsDisplayMode
		{
			Fixed,
			Expandable
		}

		public enum PinnedTooltipSlotMode
		{
			One = 1,
			Two,
			Three
		}

		public enum PlayerStatBarLengthScaling
		{
			Linear,
			Logarithmic
		}

		public enum GamepadUiScrollSource
		{
			RightStickY,
			DPadVertical,
			RightStickYOrDPadVertical
		}

		public enum ControllerDPadHotkeyMode
		{
			InventoryNavigation,
			Hotkeys,
			HotkeysWhileHoldingModifier
		}

		public enum ControllerHotkeyAction
		{
			Off,
			JoyButtonA,
			JoyButtonB,
			JoyButtonX,
			JoyButtonY,
			JoyLBumper,
			JoyRBumper,
			JoyLTrigger,
			JoyRTrigger,
			JoyBack,
			JoyStart,
			JoyLStick,
			JoyRStick,
			JoyDPadUp,
			JoyDPadDown,
			JoyDPadLeft,
			JoyDPadRight,
			JoyHotbarUse,
			JoyAltKeys,
			AltPlace,
			JoyUse
		}

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

		private sealed class ConfigurationManagerAttributes
		{
			public int? Order { get; set; }

			public bool? Browsable { get; set; }

			public Action<ConfigEntryBase>? CustomDrawer { get; set; }
		}

		private readonly struct RecycleNReclaimYieldTextEntry
		{
			public string Name { get; }

			public int Amount { get; }

			public ItemData? Item { get; }

			public RecycleNReclaimYieldTextEntry(string name, int amount, ItemData? item = null)
			{
				Name = name;
				Amount = amount;
				Item = item;
			}
		}

		private sealed class RecycleNReclaimApi
		{
			private readonly PropertyInfo _recyclingTabButtonHolderProperty;

			private readonly MethodInfo _inRecycleTabMethod;

			private readonly MethodInfo? _updateRecipeMethod;

			private readonly FieldInfo? _recyclingAnalysisContextsField;

			private readonly PropertyInfo? _recyclingImpedimentsProperty;

			private readonly PropertyInfo? _entriesProperty;

			private readonly FieldInfo? _entryRecipeItemDataField;

			private readonly FieldInfo? _entryAmountField;

			private RecycleNReclaimApi(PropertyInfo recyclingTabButtonHolderProperty, MethodInfo inRecycleTabMethod, MethodInfo? updateRecipeMethod, FieldInfo? recyclingAnalysisContextsField, PropertyInfo? recyclingImpedimentsProperty, PropertyInfo? entriesProperty, FieldInfo? entryRecipeItemDataField, FieldInfo? entryAmountField)
			{
				_recyclingTabButtonHolderProperty = recyclingTabButtonHolderProperty;
				_inRecycleTabMethod = inRecycleTabMethod;
				_updateRecipeMethod = updateRecipeMethod;
				_recyclingAnalysisContextsField = recyclingAnalysisContextsField;
				_recyclingImpedimentsProperty = recyclingImpedimentsProperty;
				_entriesProperty = entriesProperty;
				_entryRecipeItemDataField = entryRecipeItemDataField;
				_entryAmountField = entryAmountField;
			}

			public static bool TryCreate(Assembly assembly, out RecycleNReclaimApi? api, out string detail)
			{
				api = null;
				Type? type = assembly.GetType("Recycle_N_Reclaim.Recycle_N_ReclaimPlugin");
				Type type2 = assembly.GetType("Recycle_N_Reclaim.GamePatches.UI.StationRecyclingTabHolder");
				PropertyInfo propertyInfo = type?.GetProperty("RecyclingTabButtonHolder", BindingFlags.Static | BindingFlags.Public);
				MethodInfo methodInfo = type2?.GetMethod("InRecycleTab", BindingFlags.Instance | BindingFlags.Public);
				if (propertyInfo == null || type2 == null || methodInfo == null)
				{
					detail = "Recycle_N_Reclaim tab holder API was not found";
					return false;
				}
				FieldInfo field = type2.GetField("_recyclingAnalysisContexts", BindingFlags.Instance | BindingFlags.NonPublic);
				Type? type3 = assembly.GetType("Recycle_N_Reclaim.GamePatches.Recycling.RecyclingAnalysisContext");
				Type type4 = type3?.GetNestedType("ReclaimingYieldEntry", BindingFlags.Public);
				PropertyInfo recyclingImpedimentsProperty = type3?.GetProperty("RecyclingImpediments", BindingFlags.Instance | BindingFlags.Public);
				PropertyInfo entriesProperty = type3?.GetProperty("Entries", BindingFlags.Instance | BindingFlags.Public);
				api = new RecycleNReclaimApi(propertyInfo, methodInfo, type2.GetMethod("UpdateRecipe", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
				{
					typeof(Player),
					typeof(float)
				}, null), field, recyclingImpedimentsProperty, entriesProperty, type4?.GetField("RecipeItemData", BindingFlags.Instance | BindingFlags.Public), type4?.GetField("Amount", BindingFlags.Instance | BindingFlags.Public));
				detail = "";
				return true;
			}

			public bool IsRecycleTabActive()
			{
				object holder = GetHolder();
				if (holder == null)
				{
					return false;
				}
				try
				{
					object obj = _inRecycleTabMethod.Invoke(holder, null);
					return obj is bool && (bool)obj;
				}
				catch
				{
					return false;
				}
			}

			public bool TryRefreshSelectedRecipeUi()
			{
				if (_updateRecipeMethod == null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return false;
				}
				object holder = GetHolder();
				if (holder == null)
				{
					return false;
				}
				try
				{
					_updateRecipeMethod.Invoke(holder, new object[2]
					{
						Player.m_localPlayer,
						0f
					});
					return true;
				}
				catch
				{
					return false;
				}
			}

			public bool TryGetRecyclingImpedimentCount(int index, out int count)
			{
				count = 0;
				if (_recyclingImpedimentsProperty == null || !TryGetContext(index, out object context))
				{
					return false;
				}
				try
				{
					if (!(_recyclingImpedimentsProperty.GetValue(context, null) is ICollection collection))
					{
						return false;
					}
					count = collection.Count;
					return true;
				}
				catch
				{
					count = 0;
					return false;
				}
			}

			public bool TryGetReclaimSummary(int index, List<string> impediments, List<RecycleNReclaimYieldTextEntry> yields)
			{
				impediments.Clear();
				yields.Clear();
				if (!TryGetContext(index, out object context))
				{
					return false;
				}
				try
				{
					if (_recyclingImpedimentsProperty?.GetValue(context, null) is IEnumerable enumerable)
					{
						foreach (object item in enumerable)
						{
							string text = item?.ToString() ?? "";
							if (!string.IsNullOrWhiteSpace(text))
							{
								impediments.Add(text);
							}
						}
					}
					if (!(_entriesProperty?.GetValue(context, null) is IEnumerable enumerable2) || _entryRecipeItemDataField == null || _entryAmountField == null)
					{
						return true;
					}
					foreach (object item2 in enumerable2)
					{
						if (item2 == null)
						{
							continue;
						}
						int num = ((_entryAmountField.GetValue(item2) is int num2) ? num2 : 0);
						if (num > 0)
						{
							object? value = _entryRecipeItemDataField.GetValue(item2);
							ItemData val = (ItemData)((value is ItemData) ? value : null);
							if (val != null && val.m_shared != null)
							{
								yields.Add(new RecycleNReclaimYieldTextEntry(val.m_shared.m_name ?? "", num, val));
							}
						}
					}
					return true;
				}
				catch
				{
					return false;
				}
			}

			public string GetContextSignature()
			{
				object holder = GetHolder();
				if (holder == null || _recyclingAnalysisContextsField == null)
				{
					return "no-context";
				}
				try
				{
					if (!(_recyclingAnalysisContextsField.GetValue(holder) is IList list))
					{
						return "no-list";
					}
					int num = 17;
					for (int i = 0; i < list.Count; i++)
					{
						object obj = list[i];
						num = num * 31 + ((obj != null) ? RuntimeHelpers.GetHashCode(obj) : 0);
						if (_recyclingImpedimentsProperty?.GetValue(obj, null) is ICollection collection)
						{
							num = num * 31 + collection.Count;
						}
					}
					return $"{list.Count}:{num}";
				}
				catch
				{
					return "error";
				}
			}

			private object? GetHolder()
			{
				try
				{
					return _recyclingTabButtonHolderProperty.GetValue(null, null);
				}
				catch
				{
					return null;
				}
			}

			private bool TryGetContext(int index, out object? context)
			{
				context = null;
				if (index < 0 || _recyclingAnalysisContextsField == null)
				{
					return false;
				}
				object holder = GetHolder();
				if (holder == null)
				{
					return false;
				}
				try
				{
					if (!(_recyclingAnalysisContextsField.GetValue(holder) is IList list) || index >= list.Count)
					{
						return false;
					}
					context = list[index];
					return context != null;
				}
				catch
				{
					context = null;
					return false;
				}
			}
		}

		private sealed class RestockTargetLimitEditorRow
		{
			public string Item { get; set; }

			public string Amount { get; set; }

			public RestockTargetLimitEditorRow(string item, string amount)
			{
				Item = item;
				Amount = amount;
			}
		}

		private sealed class SlotEquipItemSnapshot
		{
			public ItemData Item { get; }

			public bool WasInInventory { get; }

			public Vector2i GridPos { get; }

			public bool Equipped { get; }

			public Dictionary<string, string> CustomData { get; }

			public SlotEquipItemSnapshot(ItemData item, bool wasInInventory)
			{
				//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)
				Item = item;
				WasInInventory = wasInInventory;
				GridPos = item.m_gridPos;
				Equipped = item.m_equipped;
				CustomData = new Dictionary<string, string>(item.m_customData);
			}
		}

		private sealed class HumanoidEquipmentSnapshot
		{
			public ItemData? RightItem { get; }

			public ItemData? LeftItem { get; }

			public ItemData? ChestItem { get; }

			public ItemData? LegItem { get; }

			public ItemData? AmmoItem { get; }

			public ItemData? HelmetItem { get; }

			public ItemData? ShoulderItem { get; }

			public ItemData? UtilityItem { get; }

			public ItemData? TrinketItem { get; }

			public HumanoidEquipmentSnapshot(Humanoid humanoid)
			{
				RightItem = humanoid.m_rightItem;
				LeftItem = humanoid.m_leftItem;
				ChestItem = humanoid.m_chestItem;
				LegItem = humanoid.m_legItem;
				AmmoItem = humanoid.m_ammoItem;
				HelmetItem = humanoid.m_helmetItem;
				ShoulderItem = humanoid.m_shoulderItem;
				UtilityItem = humanoid.m_utilityItem;
				TrinketItem = humanoid.m_trinketItem;
			}
		}

		private readonly struct TooltipCanvasGroupVisualSnapshot
		{
			public bool HadCanvasGroup { get; }

			public float Alpha { get; }

			public bool Interactable { get; }

			public bool BlocksRaycasts { get; }

			public bool IgnoreParentGroups { get; }

			public TooltipCanvasGroupVisualSnapshot(bool hadCanvasGroup, float alpha, bool interactable, bool blocksRaycasts, bool ignoreParentGroups)
			{
				HadCanvasGroup = hadCanvasGroup;
				Alpha = alpha;
				Interactable = interactable;
				BlocksRaycasts = blocksRaycasts;
				IgnoreParentGroups = ignoreParentGroups;
			}
		}

		private sealed class InventoryPinnedTooltipRuntimeState
		{
			public readonly RectTransform?[] Panels = (RectTransform?[])(object)new RectTransform[3];

			public readonly Image?[] Icons = (Image?[])(object)new Image[3];

			public readonly TMP_Text?[] Texts = (TMP_Text?[])(object)new TMP_Text[3];

			public readonly RectTransform?[] JewelcraftingTooltipRoots = (RectTransform?[])(object)new RectTransform[3];

			public readonly ItemData?[] Items = (ItemData?[])(object)new ItemData[3];

			public readonly InventoryGrid?[] Grids = (InventoryGrid?[])(object)new InventoryGrid[3];

			public readonly Vector2i[] Positions = Enumerable.Repeat<Vector2i>(new Vector2i(-1, -1), 3).ToArray();

			public InventoryGrid? HoveredGrid;

			public Vector2i HoveredPos = new Vector2i(-1, -1);
		}

		private sealed class CraftingPinnedTooltipRuntimeState
		{
			public readonly RectTransform?[] Panels = (RectTransform?[])(object)new RectTransform[3];

			public readonly Image?[] Icons = (Image?[])(object)new Image[3];

			public readonly TMP_Text?[] Texts = (TMP_Text?[])(object)new TMP_Text[3];

			public readonly RectTransform?[] JewelcraftingTooltipRoots = (RectTransform?[])(object)new RectTransform[3];

			public readonly RectTransform?[] GemIconRows = (RectTransform?[])(object)new RectTransform[3];

			public readonly int[] RecipeIndices = Enumerable.Repeat(-1, 3).ToArray();
		}

		private sealed class PinnedTooltipRuntimeState
		{
			public readonly InventoryPinnedTooltipRuntimeState Inventory = new InventoryPinnedTooltipRuntimeState();

			public readonly CraftingPinnedTooltipRuntimeState Crafting = new CraftingPinnedTooltipRuntimeState();

			public PinnedTooltipContext ActiveContext;
		}

		private sealed class TooltipUiRuntimeState
		{
			public RectTransform? HotbarSwitchHudHint;

			public TMP_Text? HotbarSwitchHudHintText;

			public RectTransform? InventoryWheelHint;

			public TMP_Text? InventoryWheelHintText;

			public TMP_FontAsset? DefaultFontAsset;

			public Material? DefaultFontMaterial;

			public Sprite? SolidUiSprite;

			public Sprite? MouseWheelHintSprite;
		}

		private static class TooltipController
		{
			public static void SetPinnedContext(PinnedTooltipContext context)
			{
				if (PinnedTooltips.ActiveContext != context)
				{
					PinnedTooltipContext activeContext = PinnedTooltips.ActiveContext;
					PinnedTooltips.ActiveContext = context;
					switch (activeContext)
					{
					case PinnedTooltipContext.InventoryContainer:
						HideInventoryPinnedTooltips();
						break;
					case PinnedTooltipContext.CraftingCraft:
					case PinnedTooltipContext.CraftingUpgrade:
						HideCraftingPinnedTooltips();
						break;
					}
				}
			}

			public static void SyncCraftingPinnedContext(PinnedTooltipContext current)
			{
				if ((PinnedTooltips.ActiveContext == PinnedTooltipContext.CraftingCraft || PinnedTooltips.ActiveContext == PinnedTooltipContext.CraftingUpgrade) && PinnedTooltips.ActiveContext != current)
				{
					HideCraftingPinnedTooltips();
					PinnedTooltips.ActiveContext = current;
				}
			}

			public static bool IsCraftingPinnedContext()
			{
				if (PinnedTooltips.ActiveContext != PinnedTooltipContext.CraftingCraft)
				{
					return PinnedTooltips.ActiveContext == PinnedTooltipContext.CraftingUpgrade;
				}
				return true;
			}

			public static bool IsInventoryPinnedContext()
			{
				return PinnedTooltips.ActiveContext == PinnedTooltipContext.InventoryContainer;
			}

			public static void SetInventoryHover(InventoryGrid grid, Vector2i pos)
			{
				//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)
				PinnedTooltips.Inventory.HoveredGrid = grid;
				PinnedTooltips.Inventory.HoveredPos = pos;
			}

			public static void ClearInventoryHover()
			{
				//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)
				PinnedTooltips.Inventory.HoveredGrid = null;
				PinnedTooltips.Inventory.HoveredPos = new Vector2i(-1, -1);
			}

			public static bool IsInventoryHover(InventoryGrid grid, Vector2i pos)
			{
				//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)(object)PinnedTooltips.Inventory.HoveredGrid == (Object)(object)grid)
				{
					return PinnedTooltips.Inventory.HoveredPos == pos;
				}
				return false;
			}

			public static bool TryGetInventoryHover(out InventoryGrid? grid, out Vector2i pos)
			{
				//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)
				grid = PinnedTooltips.Inventory.HoveredGrid;
				pos = PinnedTooltips.Inventory.HoveredPos;
				if ((Object)(object)grid != (Object)null && pos.x >= 0)
				{
					return pos.y >= 0;
				}
				return false;
			}
		}

		private enum UiScrollInputMode
		{
			Discrete,
			Continuous
		}

		private sealed class VeiledRecipesApi
		{
			private delegate bool ShouldMaskRecipePairDelegate(Player player, RecipeDataPair pair);

			private delegate bool IsUnknownRecipePreviewDelegate(Player player, Recipe recipe);

			private delegate bool IsMaterialKnownDelegate(Player player, Requirement requirement);

			private delegate bool KnowsRecipeStationRequirementDelegate(Player player, Recipe recipe, int quality);

			private readonly ShouldMaskRecipePairDelegate _shouldMaskRecipePair;

			private readonly IsUnknownRecipePreviewDelegate? _isUnknownRecipePreview;

			private readonly IsMaterialKnownDelegate _isMaterialKnown;

			private readonly KnowsRecipeStationRequirementDelegate _knowsRecipeStationRequirement;

			private readonly PropertyInfo _unknownNameTextProperty;

			private readonly PropertyInfo _unknownDescriptionTextProperty;

			private readonly PropertyInfo _unknownRequirementTextProperty;

			private readonly PropertyInfo? _groupUnknownRecipePreviewsBelowKnownRecipesProperty;

			public string UnknownNameText => GetStringProperty(_unknownNameTextProperty, "???");

			public string UnknownDescriptionText => GetStringProperty(_unknownDescriptionTextProperty, "Not enough info");

			public string UnknownRequirementText => GetStringProperty(_unknownRequirementTextProperty, "?");

			public bool GroupUnknownRecipePreviewsBelowKnownRecipes => GetBoolProperty(_groupUnknownRecipePreviewsBelowKnownRecipesProperty, fallback: false);

			public bool HasUnknownRecipePreviewApi => _isUnknownRecipePreview != null;

			private VeiledRecipesApi(ShouldMaskRecipePairDelegate shouldMaskRecipePair, IsUnknownRecipePreviewDelegate? isUnknownRecipePreview, IsMaterialKnownDelegate isMaterialKnown, KnowsRecipeStationRequirementDelegate knowsRecipeStationRequirement, PropertyInfo unknownNameTextProperty, PropertyInfo unknownDescriptionTextProperty, PropertyInfo unknownRequirementTextProperty, PropertyInfo? groupUnknownRecipePreviewsBelowKnownRecipesProperty)
			{
				_shouldMaskRecipePair = shouldMaskRecipePair;
				_isUnknownRecipePreview = isUnknownRecipePreview;
				_isMaterialKnown = isMaterialKnown;
				_knowsRecipeStationRequirement = knowsRecipeStationRequirement;
				_unknownNameTextProperty = unknownNameTextProperty;
				_unknownDescriptionTextProperty = unknownDescriptionTextProperty;
				_unknownRequirementTextProperty = unknownRequirementTextProperty;
				_groupUnknownRecipePreviewsBelowKnownRecipesProperty = groupUnknownRecipePreviewsBelowKnownRecipesProperty;
			}

			public static bool TryCreate(Assembly assembly, out VeiledRecipesApi? api, out string detail)
			{
				api = null;
				Type type = assembly.GetType("VeiledRecipes.VeiledRecipesCompat");
				MethodInfo methodInfo = type?.GetMethod("ShouldMaskRecipePair", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(Player),
					typeof(RecipeDataPair)
				}, null);
				MethodInfo methodInfo2 = type?.GetMethod("IsUnknownRecipePreview", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(Player),
					typeof(Recipe)
				}, null);
				MethodInfo methodInfo3 = type?.GetMethod("IsMaterialKnown", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(Player),
					typeof(Requirement)
				}, null);
				MethodInfo methodInfo4 = type?.GetMethod("KnowsRecipeStationRequirement", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(Player),
					typeof(Recipe),
					typeof(int)
				}, null);
				PropertyInfo propertyInfo = type?.GetProperty("UnknownNameText", BindingFlags.Static | BindingFlags.Public);
				PropertyInfo propertyInfo2 = type?.GetProperty("UnknownDescriptionText", BindingFlags.Static | BindingFlags.Public);
				PropertyInfo propertyInfo3 = type?.GetProperty("UnknownRequirementText", BindingFlags.Static | BindingFlags.Public);
				PropertyInfo groupUnknownRecipePreviewsBelowKnownRecipesProperty = type?.GetProperty("GroupUnknownRecipePreviewsBelowKnownRecipes", BindingFlags.Static | BindingFlags.Public);
				if (type == null || methodInfo == null || methodInfo3 == null || methodInfo4 == null || propertyInfo == null || propertyInfo2 == null || propertyInfo3 == null)
				{
					detail = "VeiledRecipes compatibility API was not found";
					return false;
				}
				try
				{
					api = new VeiledRecipesApi((ShouldMaskRecipePairDelegate)Delegate.CreateDelegate(typeof(ShouldMaskRecipePairDelegate), methodInfo), (methodInfo2 != null) ? ((IsUnknownRecipePreviewDelegate)Delegate.CreateDelegate(typeof(IsUnknownRecipePreviewDelegate), methodInfo2)) : null, (IsMaterialKnownDelegate)Delegate.CreateDelegate(typeof(IsMaterialKnownDelegate), methodInfo3), (KnowsRecipeStationRequirementDelegate)Delegate.CreateDelegate(typeof(KnowsRecipeStationRequirementDelegate), methodInfo4), propertyInfo, propertyInfo2, propertyInfo3, groupUnknownRecipePreviewsBelowKnownRecipesProperty);
					detail = "";
					return true;
				}
				catch (Exception ex)
				{
					detail = ex.Message;
					api = null;
					return false;
				}
			}

			public bool ShouldMaskRecipePair(Player player, RecipeDataPair pair)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					return _shouldMaskRecipePair(player, pair);
				}
				catch
				{
					return false;
				}
			}

			public bool IsUnknownRecipePreview(Player player, Recipe recipe)
			{
				if (_isUnknownRecipePreview == null)
				{
					return false;
				}
				try
				{
					return _isUnknownRecipePreview(player, recipe);
				}
				catch
				{
					return false;
				}
			}

			public bool IsMaterialKnown(Player player, Requirement requirement)
			{
				try
				{
					return _isMaterialKnown(player, requirement);
				}
				catch
				{
					return false;
				}
			}

			public bool KnowsRecipeStationRequirement(Player player, Recipe recipe, int quality)
			{
				try
				{
					return _knowsRecipeStationRequirement(player, recipe, quality);
				}
				catch
				{
					return false;
				}
			}

			private static string GetStringProperty(PropertyInfo property, string fallback)
			{
				try
				{
					return (property.GetValue(null, null) as string) ?? fallback;
				}
				catch
				{
					return fallback;
				}
			}

			private static bool GetBoolProperty(PropertyInfo? property, bool fallback)
			{
				if (property == null)
				{
					return fallback;
				}
				try
				{
					return (property.GetValue(null, null) is bool flag) ? flag : fallback;
				}
				catch
				{
					return fallback;
				}
			}
		}

		private sealed class YamlApplySnapshot
		{
			public YamlRoot Config { get; }

			public List<SlotDefinition> SlotDefinitions { get; }

			public Dictionary<string, List<string>> PredefinedGroupDefinitions { get; }

			public List<string> PredefinedGroupOrder { get; }

			public Dictionary<string, List<string>> PredefinedGroupOrders { get; }

			public YamlApplySnapshot(YamlRoot config, List<SlotDefinition> slotDefinitions, Dictionary<string, List<string>> predefinedGroupDefinitions, List<string> predefinedGroupOrder, Dictionary<string, List<string>> predefinedGroupOrders)
			{
				Config = config;
				SlotDefinitions = slotDefinitions;
				PredefinedGroupDefinitions = predefinedGroupDefinitions;
				PredefinedGroupOrder = predefinedGroupOrder;
				PredefinedGroupOrders = predefinedGroupOrders;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static CompatApiFactory<AzuCraftyBoxesApi> <0>__TryCreate;

			public static Func<ItemData?, bool> <1>__IsAdventureBackpackItem;

			public static Func<ItemData?, bool> <2>__IsSmoothbrainBackpackItem;

			public static Func<ItemData?, bool> <3>__IsRustyBagItem;

			public static Func<ItemData?, bool> <4>__IsRustyQuiverItem;

			public static CompatApiFactory<AdventureBackpacksApi> <5>__TryCreate;

			public static CompatApiFactory<SmoothbrainBackpacksApi> <6>__TryCreate;

			public static CompatApiFactory<RustyBagsApi> <7>__TryCreate;

			public static CompatApiFactory<BetterArcheryQuiverApi> <8>__TryCreate;

			public static TryGetContainerHoldContext <9>__TryGetContainerQuickStackHotkeyContext;

			public static Func<Player, Container, bool> <10>__TryQuickStackFromHoveredContainer;

			public static TryGetContainerHoldContext <11>__TryGetContainerRestockHotkeyContext;

			public static Func<Player, Container, bool> <12>__TryRestockFromHoveredContainer;

			public static Func<ItemData, SortKey> <13>__GetInventoryItemSortKey;

			public static Func<ItemData, bool> <14>__IsPendingUpgradeFavoriteItem;

			public static UnityAction<string> <15>__UpdateCraftingSearchQuery;

			public static Func<char, bool> <16>__IsDigit;

			public static UnityAction<float> <17>__OnCraftingRecipeScrollbarChanged;

			public static Func<TMP_Text, bool> <18>__IsKeyHintText;

			public static UnityAction <19>__TryClickInventoryTrashPanel;

			public static CompatApiFactory<ItemRequiresSkillLevelApi> <20>__TryCreate;

			public static Func<ItemData?, bool> <21>__IsJewelcraftingNecklaceItem;

			public static Func<ItemData?, bool> <22>__IsJewelcraftingRingItem;

			public static CompatApiFactory<JewelcraftingSlotApi> <23>__TryCreate;

			public static CompatApiFactory<JewelcraftingVisualApi> <24>__TryCreate;

			public static CompatApiFactory<JewelcraftingGemCuttingApi> <25>__TryCreate;

			public static CompatApiFactory<JewelcraftingCraftingSocketUiApi> <26>__TryCreate;

			public static CompatApiFactory<JewelcraftingEffectApi> <27>__TryCreate;

			public static CompatApiFactory<JewelcraftingTooltipApi> <28>__TryCreate;

			public static CompatApiFactory<JewelcraftingGemApi> <29>__TryCreate;

			public static Func<ItemData?, bool> <30>__IsMagicSupremacyBeltItem;

			public static CompatApiFactory<MagicSupremacyApi> <31>__TryCreate;

			public static Action<UIInputHandler> <32>__HandleInventoryGridTooltipPointerEnter;

			public static Action<UIInputHandler> <33>__HandleInventoryGridTooltipPointerExit;

			public static Action<ConfigEntryBase> <34>__DrawRestockTargetStackLimitsConfig;

			public static Action <35>__HandleLocalizationComplete;

			public static Action<ConfigEntryBase> <36>__DrawControllerHotkeyConfig;

			public static CompatApiFactory<RecycleNReclaimApi> <37>__TryCreate;

			public static Func<string, string> <38>__SanitizeRecycleNReclaimHudText;

			public static CompatApiFactory<VeiledRecipesApi> <39>__TryCreate;

			public static Func<string, string> <40>__NormalizeGroupId;

			public static Func<ItemData?, bool> <41>__QuickSlotAcceptsItem;
		}

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

			public static Func<ItemData?, bool> <>9__12_0;

			public static Func<ItemData?, bool> <>9__13_0;

			public static Func<ItemData?, bool> <>9__14_0;

			public static Func<ItemData?, bool> <>9__15_0;

			public static Comparison<(Container Container, float DistanceSq)> <>9__95_0;

			public static Func<Container, bool> <>9__96_0;

			public static Comparison<ItemData> <>9__157_1;

			public static Func<ItemData, bool> <>9__159_0;

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

			public static Comparison<ItemData> <>9__160_1;

			public static Comparison<ItemData> <>9__171_1;

			public static Func<ItemData, bool> <>9__194_0;

			public static Func<ItemData, ItemData> <>9__204_0;

			public static Func<ItemData, ItemData> <>9__204_1;

			public static Func<ItemData, bool> <>9__206_0;

			public static Func<ItemData, <>f__AnonymousType0<string, int, int>> <>9__206_1;

			public static Func<IGrouping<<>f__AnonymousType0<string, int, int>, ItemData>, List<ItemData>> <>9__206_2;

			public static Func<ItemData, int> <>9__206_3;

			public static Func<ItemData, bool> <>9__209_0;

			public static Comparison<ItemData> <>9__209_1;

			public static Func<ItemData, int> <>9__211_1;

			public static Func<ItemData, int> <>9__211_2;

			public static UnityAction<string> <>9__260_0;

			public static Func<TMP_Text, bool> <>9__292_0;

			public static Func<Text, bool> <>9__292_1;

			public static EventHandler <>9__303_0;

			public static EventHandler <>9__303_1;

			public static EventHandler <>9__303_2;

			public static EventHandler <>9__303_3;

			public static Func<string> <>9__366_0;

			public static Func<ItemData, bool> <>9__369_0;

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

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

			public static Func<string, string> <>9__371_0;

			public static Func<string, string> <>9__371_1;

			public static Action<UIInputHandler> <>9__400_0;

			public static Action<UIInputHandler> <>9__400_1;

			public static Action<UIInputHandler> <>9__400_2;

			public static Action<UIInputHandler> <>9__400_3;

			public static Action<UIInputHandler> <>9__419_0;

			public static Func<CraftingRecipeGroupFilter, bool> <>9__442_0;

			public static Action<UIInputHandler> <>9__453_0;

			public static Func<CraftingRecipeGroupFilter, string> <>9__471_0;

			public static Func<char, bool> <>9__536_0;

			public static Func<char, bool> <>9__537_0;

			public static Func<ItemData, bool> <>9__539_0;

			public static Func<CraftingRecipeGroupFilter, bool> <>9__570_0;

			public static Func<Image, Transform> <>9__644_0;

			public static Func<SlotDefinition, bool> <>9__831_0;

			public static Func<SlotDefinition, bool> <>9__832_0;

			public static Func<SlotDefinition, bool> <>9__840_0;

			public static Func<CustomEquipmentVisual, VisEquipment> <>9__842_0;

			public static Func<VisEquipment, bool> <>9__842_1;

			public static Func<SlotDefinition, bool> <>9__861_0;

			public static Func<SlotDefinition, bool> <>9__861_2;

			public static UnityAction <>9__983_0;

			public static UnityAction <>9__983_1;

			public static UnityAction <>9__985_0;

			public static UnityAction <>9__992_0;

			public static Func<Vector2i, int> <>9__1050_0;

			public static Func<Vector2i, int> <>9__1050_1;

			public static Func<Vector2i, InventorySlotsFavoriteSlot> <>9__1050_2;

			public static Func<TMP_FontAsset, bool> <>9__1076_0;

			public static Func<UITooltip, InventoryHoverTooltipItemSource, bool> <>9__1186_0;

			public static Func<TMP_Text, bool> <>9__1278_0;

			public static Func<int, int, bool> <>9__1356_0;

			public static Func<int, int, bool> <>9__1359_0;

			public static Func<int, int, bool> <>9__1367_0;

			public static Func<AnimationClip, bool> <>9__1412_0;

			public static Func<AnimationClip, bool> <>9__1412_1;

			public static Func<AnimationClip, float> <>9__1412_2;

			public static Action<UIInputHandler> <>9__1418_0;

			public static Action<UIInputHandler> <>9__1418_1;

			public static Action<UIInputHandler> <>9__1519_0;

			public static Action<UIInputHandler> <>9__1519_1;

			public static Action<UIInputHandler> <>9__1536_0;

			public static Action<UIInputHandler> <>9__1536_1;

			public static Func<MovedPlayerStatPanel, int> <>9__1618_0;

			public static Func<MovedPlayerStatPanel, PlayerStatPanelKind> <>9__1618_1;

			public static Func<SlotDefinition, bool> <>9__1760_0;

			public static Func<SlotDefinition, bool> <>9__1760_1;

			public static Func<SlotDefinition, bool> <>9__1782_0;

			public static Func<SlotDefinition, bool> <>9__1782_1;

			public static Func<Graphic, bool> <>9__1882_0;

			public static Func<TMP_Text, bool> <>9__1882_1;

			public static Func<LayoutGroup, bool> <>9__1882_2;

			public static Func<ContentSizeFitter, bool> <>9__1882_3;

			public static Func<SlotDefinition, bool> <>9__1910_0;

			public static Func<ItemData, bool> <>9__1923_0;

			public static Func<ItemData, int> <>9__1923_1;

			public static Func<ItemData, int> <>9__1923_2;

			public static Comparison<ItemData> <>9__1926_2;

			public static Comparison<ItemData> <>9__1927_1;

			public static Func<ItemData, bool> <>9__1948_0;

			public static Func<ItemData, int> <>9__1948_1;

			public static Func<ItemData, int> <>9__1948_2;

			public static Func<ItemData, bool> <>9__2026_0;

			public static Func<ItemData, int> <>9__2026_1;

			public static Func<ItemData, int> <>9__2026_2;

			public static Converter<ItemData, ItemData> <>9__2100_0;

			public static EventHandler <>9__2423_0;

			public static EventHandler <>9__2423_1;

			public static EventHandler <>9__2423_2;

			public static EventHandler <>9__2423_3;

			public static EventHandler <>9__2423_4;

			public static EventHandler <>9__2423_5;

			public static EventHandler <>9__2423_6;

			public static EventHandler <>9__2423_7;

			public static EventHandler <>9__2423_8;

			public static Func<RecycleNReclaimYieldTextEntry, string> <>9__2509_0;

			public static Func<RectTransform, bool> <>9__2510_0;

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

			public static Func<string, string> <>9__2511_1;

			public static Func<string, string> <>9__2512_0;

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

			public static Func<RestockTargetLimitEditorRow, bool> <>9__2522_0;

			public static Func<RestockTargetLimitEditorRow, string> <>9__2522_1;

			public static Func<ItemData, bool> <>9__2529_0;

			public static Func<ItemData, bool> <>9__2532_0;

			public static Action <>9__2674_0;

			public static Action <>9__2674_1;

			public static FileSystemEventHandler <>9__2677_0;

			public static RenamedEventHandler <>9__2677_1;

			public static ErrorEventHandler <>9__2677_2;

			public static Func<KeyValuePair<string, List<string>>, string> <>9__2690_0;

			public static Func<KeyValuePair<string, List<string>>, List<string>> <>9__2690_1;

			public static Func<KeyValuePair<string, List<string>>, string> <>9__2690_2;

			public static Func<KeyValuePair<string, List<string>>, List<string>> <>9__2690_3;

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

			public static Func<string, string> <>9__2696_1;

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

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

			public static Func<ItemData?, bool> <>9__2701_0;

			public static Func<ItemData?, bool> <>9__2701_1;

			public static Func<ItemData?, bool> <>9__2701_2;

			public static Func<ItemData?, bool> <>9__2701_3;

			public static Func<ItemData?, bool> <>9__2701_4;

			public static Func<ItemData?, bool> <>9__2701_5;

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

			public static Func<string, string> <>9__2706_1;

			internal bool <TryAddAdventureBackpackSlot>b__12_0(ItemData? item)
			{
				return IsAdventureBackpackItem(item);
			}

			internal bool <TryAddSmoothbrainBackpackSlot>b__13_0(ItemData? item)
			{
				return IsSmoothbrainBackpackItem(item);
			}

			internal bool <TryAddRustyBagSlot>b__14_0(ItemData? item)
			{
				return IsRustyBagItem(item);
			}

			internal bool <TryAddRustyQuiverSlot>b__15_0(ItemData? item)
			{
				return IsRustyQuiverItem(item);
			}

			internal int <GetActionContainers>b__95_0((Container Container, float DistanceSq) left, (Container Container, float DistanceSq) right)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				int num = left.DistanceSq.CompareTo(right.DistanceSq);
				if (num != 0)
				{
					return num;
				}
				ZNetView nview = left.Container.m_nview;
				ZDO val = ((nview != null) ? nview.GetZDO() : null);
				ZNetView nview2 = right.Container.m_nview;
				ZDO val2 = ((nview2 != null) ? nview2.GetZDO() : null);
				if (val == null || val2 == null)
				{
					return 0;
				}
				return ((ZDOID)(ref val.m_uid)).CompareTo(val2.m_uid);
			}

			internal bool <RunContainerTransferAcrossContainers>b__96_0(Container container)
			{
				if (!IsUnityNull((Object?)(object)container))
				{
					return container.m_inventory != null;
				}
				return false;
			}

			internal int <QuickStackIntoContainers>b__157_1(ItemData a, ItemData b)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return -CompareGridOrder(a.m_gridPos, b.m_gridPos);
			}

			internal bool <QuickStackItemsIntoContainer>b__159_0(ItemData item)
			{
				return item?.m_shared != null;
			}

			internal string <QuickStackItemsIntoContainer>b__159_1(ItemData item)
			{
				return item.m_shared.m_name;
			}

			internal int <StoreAllToCurrentContainer>b__160_1(ItemData a, ItemData b)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return CompareGridOrder(a.m_gridPos, b.m_gridPos);
			}

			internal int <RestockFromContainer>b__171_1(ItemData a, ItemData b)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return -CompareGridOrder(a.m_gridPos, b.m_gridPos);
			}

			internal bool <SortContainerInventory>b__194_0(ItemData item)
			{
				return item?.m_shared != null;
			}

			internal ItemData <SortInventoryInternal>b__204_0(ItemData item)
			{
				return item;
			}

			internal ItemData <SortInventoryInternal>b__204_1(ItemData item)
			{
				return item;
			}

			internal bool <MergeSortableStacks>b__206_0(ItemData item)
			{
				if (item?.m_shared != null && item.m_stack < item.m_shared.m_maxStackSize)
				{
					return CanUseContainerActionStacking(item);
				}
				return false;
			}

			internal <>f__AnonymousType0<string, int, int> <MergeSortableStacks>b__206_1(ItemData item)
			{
				return new
				{
					item.m_shared.m_name,
					item.m_quality,
					item.m_worldLevel
				};
			}

			internal List<ItemData> <MergeSortableStacks>b__206_2(IGrouping<<>f__AnonymousType0<string, int, int>, ItemData> grouping)
			{
				return grouping.ToList();
			}

			internal int <MergeSortableStacks>b__206_3(ItemData item)
			{
				return item.m_stack;
			}

			internal bool <SafeTakeAllItems>b__209_0(ItemData item)
			{
				return item?.m_shared != null;
			}

			internal int <SafeTakeAllItems>b__209_1(ItemData left, ItemData right)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return CompareGridOrder(left.m_gridPos, right.m_gridPos);
			}

			internal int <GetSafeTakeAllStackTargets>b__211_1(ItemData target)
			{
				return target.m_gridPos.y;
			}

			internal int <GetSafeTakeAllStackTargets>b__211_2(ItemData target)
			{
				return target.m_gridPos.x;
			}

			internal void <EnsureCraftingCountInput>b__260_0(string value)
			{
				SetCraftingCount(ParseCraftingCount(value));
			}

			internal bool <HasInvalidTextCache>b__292_0(TMP_Text text)
			{
				if (!((Object)(object)text == (Object)null))
				{
					return IsUnityNull((Object?)(object)text);
				}
				return true;
			}

			internal bool <HasInvalidTextCache>b__292_1(Text text)
			{
				if (!((Object)(object)text == (Object)null))
				{
					return IsUnityNull((Object?)(object)text);
				}
				return true;
			}

			internal void <BindCraftingClientConfigs>b__303_0(object _, EventArgs _)
			{
				CraftingController.MarkRecipeGridLayoutDirty();
			}

			internal void <BindCraftingClientConfigs>b__303_1(object _, EventArgs _)
			{
				CraftingController.MarkGroupRailDirty();
			}

			internal void <BindCraftingClientConfigs>b__303_2(object _, EventArgs _)
			{
				CraftingController.ResetSortModeButtonsStamp();
				InvalidateCraftingRecipeView();
			}

			internal void <BindCraftingClientConfigs>b__303_3(object _, EventArgs _)
			{
				CraftingController.MarkRecipeGridLayoutDirty();
			}

			internal string <GetOrCreateUpgradeFavoriteItemKey>b__366_0()
			{
				return Guid.NewGuid().ToString("N");
			}

			internal bool <RemoveUpgradeFavoriteItemKeysFromInventory>b__369_0(ItemData item)
			{
				return item?.m_customData != null;
			}

			internal bool <EnsureCraftingFavoritesLoaded>b__370_0(string recipe)
			{
				return !string.IsNullOrWhiteSpace(recipe);
			}

			internal bool <EnsureCraftingFavoritesLoaded>b__370_1(string itemId)
			{
				return !string.IsNullOrWhiteSpace(itemId);
			}

			internal string <SaveCraftingFavorites>b__371_0(string recipe)
			{
				return recipe;
			}

			internal string <SaveCraftingFavorites>b__371_1(string itemId)
			{
				return itemId;
			}

			internal void <ConfigureCraftingRecipeCell>b__400_0(UIInputHandler handler)
			{
				CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
				SetCraftingRecipeHover(component?.Index ?? (-1), component?.Tooltip);
			}

			internal void <ConfigureCraftingRecipeCell>b__400_1(UIInputHandler handler)
			{
				CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
				ClearCraftingRecipeHover(component?.Index ?? (-1), component?.Tooltip);
			}

			internal void <ConfigureCraftingRecipeCell>b__400_2(UIInputHandler handler)
			{
				CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
				int num = component?.Index ?? (-1);
				ClearCraftingRecipeHover(num, component?.Tooltip);
				if (!TryToggleCraftingRecipeFavorite(num))
				{
					SelectCraftingRecipeFromGrid(num);
				}
			}

			internal void <ConfigureCraftingRecipeCell>b__400_3(UIInputHandler handler)
			{
				CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
				int num = component?.Index ?? (-1);
				ClearCraftingRecipeHover(num, component?.Tooltip);
				if (!TryToggleCraftingRecipeFavorite(num))
				{
					SelectCraftingRecipeFromGrid(num);
				}
			}

			internal void <EnsureCraftingRecipeStyleButton>b__419_0(UIInputHandler handler)
			{
				ShowCraftingRecipeStyleDialog(((Component)handler).GetComponent<CraftingRecipeStyleButtonMarker>());
			}

			internal bool <UpdateCraftingGroupRail>b__442_0(CraftingRecipeGroupFilter filter)
			{
				return filter.Id != _selectedCraftingGroupId;
			}

			internal void <ConfigureCraftingGroupButton>b__453_0(UIInputHandler handler)
			{
				ToggleCraftingGroupFilter(((Component)handler).GetComponent<CraftingGroupButtonMarker>()?.FilterId ?? "");
			}

			internal string <StoreCraftingGroupAvailabilityCacheStamp>b__471_0(CraftingRecipeGroupFilter filter)
			{
				return filter.Id;
			}

			internal bool <NormalizeTooltipStatLabel>b__536_0(char c)
			{
				return !char.IsWhiteSpace(c);
			}

			internal bool <NormalizeTooltipStatValue>b__537_0(char c)
			{
				return !char.IsWhiteSpace(c);
			}

			internal bool <CreateCraftingRecipeGroupFilters>b__539_0(ItemData _)
			{
				return false;
			}

			internal bool <RecipeMatchesSelectedCraftingGroup>b__570_0(CraftingRecipeGroupFilter group)
			{
				return group.Id == _selectedCraftingGroupId;
			}

			internal Transform <CreateCraftingRecipeScrollbar>b__644_0(Image image)
			{
				return ((Component)image).transform;
			}

			internal bool <UpdateCustomEquipmentVisualsFromZdo>b__831_0(SlotDefinition slot)
			{
				return slot.Kind == SlotKind.CustomEquipment;
			}

			internal bool <BuildCustomEquipmentVisualStatesFromInventory>b__832_0(SlotDefinition slot)
			{
				return slot.Kind == SlotKind.CustomEquipment;
			}

			internal bool <ClearCustomEquipmentVisualZdoValues>b__840_0(SlotDefinition slot)
			{
				return slot.Kind == SlotKind.CustomEquipment;
			}

			internal VisEquipment <ClearCustomEquipmentVisuals>b__842_0(CustomEquipmentVisual visual)
			{
				return visual.Owner;
			}

			internal bool <ClearCustomEquipmentVisuals>b__842_1(VisEquipment owner)
			{
				return !IsUnityNull((Object?)(object)owner);
			}

			internal bool <RestoreKeepOnDeathItem>b__861_0(SlotDefinition slot)
			{
				return slot.Kind == SlotKind.Quick;
			}

			internal bool <RestoreKeepOnDeathItem>b__861_2(SlotDefinition slot)
			{
				return slot.Kind != SlotKind.Quick;
			}

			internal void <UpdateContainerActionPanel>b__983_0()
			{
				StoreAllToCurrentContainer(Player.m_localPlayer);
			}

			internal void <UpdateContainerActionPanel>b__983_1()
			{
				RestockFromCurrentContainer(Player.m_localPlayer);
			}

			internal void <UpdateInventorySortPanel>b__985_0()
			{
				SortPlayerInventory(Player.m_localPlayer);
			}

			internal void <EnsureContainerSortButton>b__992_0()
			{
				SortCurrentContainer(Player.m_localPlayer);
			}

			internal int <SaveFavorites>b__1050_0(Vector2i slot)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return slot.y;
			}

			internal int <SaveFavorites>b__1050_1(Vector2i slot)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return slot.x;
			}

			internal InventorySlotsFavoriteSlot <SaveFavorites>b__1050_2(Vector2i slot)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new InventorySlotsFavoriteSlot
				{
					X = slot.x,
					Y = slot.y
				};
			}

			internal bool <TryFindLoadedFontAsset>b__1076_0(TMP_FontAsset fontAsset)
			{
				if ((Object)(object)fontAsset != (Object)null && !IsUnityNull((Object?)(object)fontAsset))
				{
					return (((Object)fontAsset).name ?? "").IndexOf("LiberationSans", StringComparison.OrdinalIgnoreCase) < 0;
				}
				return false;
			}

			internal bool <PruneInventoryHoverTooltipSources>b__1186_0(UITooltip tooltip, InventoryHoverTooltipItemSource source)
			{
				return !IsInventoryHoverTooltipSourceValid(tooltip, source);
			}

			internal bool <SetKeyHintLabel>b__1278_0(TMP_Text text)
			{
				return !IsKeyHintText(text);
			}

			internal bool <FindTopFirstEmptySlot>b__1356_0(int _, int _)
			{
				return true;
			}

			internal bool <TryFindFreeRegularLoadPreservationCell>b__1359_0(int x, int y)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return !IsExternalReservedForCompat(new Vector2i(x, y));
			}

			internal bool <CountAllEmptyCells>b__1367_0(int _, int _)
			{
				return true;
			}

			internal bool <GetInventoryGuiAnimationDuration>b__1412_0(AnimationClip c)
			{
				if ((Object)(object)c != (Object)null && c.length > 0.05f)
				{
					return c.length < 2f;
				}
				return false;
			}

			internal bool <GetInventoryGuiAnimationDuration>b__1412_1(AnimationClip c)
			{
				return IsLikelyInventoryOpenClip(((Object)c).name);
			}

			internal float <GetInventoryGuiAnimationDuration>b__1412_2(AnimationClip c)
			{
				return Mathf.Abs(c.length - 0.25f);
			}

			internal void <EnsureQuickSlotsHotkeyBarElementCount>b__1418_0(UIInputHandler handler)
			{
				SelectQuickHudSlot(((Component)handler).GetComponentInParent<QuickHudSlotMarker>());
			}

			internal void <EnsureQuickSlotsHotkeyBarElementCount>b__1418_1(UIInputHandler handler)
			{
				UseQuickHudSlot(((Component)handler).GetComponentInParent<QuickHudSlotMarker>());
			}

			internal void <EnsureSlotPanel>b__1519_0(UIInputHandler handler)
			{
				StartInventoryPanelDrag(((Component)handler).GetComponent<InventoryPanelDragMarker>());
			}

			internal void <EnsureSlotPanel>b__1519_1(UIInputHandler _)
			{
				StopInventoryPanelDrag();
			}

			internal void <EnsureSlotPanelDragBorder>b__1536_0(UIInputHandler handler)
			{
				StartInventoryPanelDrag(((Component)handler).GetComponent<InventoryPanelDragMarker>());
			}

			internal void <EnsureSlotPanelDragBorder>b__1536_1(UIInputHandler _)
			{
				StopInventoryPanelDrag();
			}

			internal int <LayoutPlayerStatPanels>b__1618_0(MovedPlayerStatPanel panel)
			{
				return panel.SortOrder;
			}

			internal PlayerStatPanelKind <LayoutPlayerStatPanels>b__1618_1(MovedPlayerStatPanel panel)
			{
				return panel.Kind;
			}

			internal bool <AddJewelcraftingSlot>b__1760_0(SlotDefinition slot)
			{
				return slot.Id != "jewelcrafting.necklace";
			}

			internal bool <AddJewelcraftingSlot>b__1760_1(SlotDefinition slot)
			{
				return slot.Id != "jewelcrafting.ring";
			}

			internal bool <SuppressJewelcraftingNativeVisualSlots>b__1782_0(SlotDefinition slot)
			{
				if (slot.Id == "jewelcrafting.ring")
				{
					return slot.Kind == SlotKind.CustomEquipment;
				}
				return false;
			}

			internal bool <SuppressJewelcraftingNativeVisualSlots>b__1782_1(SlotDefinition slot)
			{
				if (slot.Id == "jewelcrafting.necklace")
				{
					return slot.Kind == SlotKind.CustomEquipment;
				}
				return false;
			}

			internal bool <HasInvalidJewelcraftingNativeComponentCache>b__1882_0(Graphic graphic)
			{
				if (!((Object)(object)graphic == (Object)null))
				{
					return IsUnityNull((Object?)(object)graphic);
				}
				return true;
			}

			internal bool <HasInvalidJewelcraftingNativeComponentCache>b__1882_1(TMP_Text text)
			{
				if (!((Object)(object)text == (Object)null))
				{
					return IsUnityNull((Object?)(object)text);
				}
				return true;
			}

			internal bool <HasInvalidJewelcraftingNativeComponentCache>b__1882_2(LayoutGroup group)
			{
				if (!((Object)(object)group == (Object)null))
				{
					return IsUnityNull((Object?)(object)group);
				}
				return true;
			}

			internal bool <HasInvalidJewelcraftingNativeComponentCache>b__1882_3(ContentSizeFitter fitter)
			{
				if (!((Object)(object)fitter == (Object)null))
				{
					return IsUnityNull((Object?)(object)fitter);
				}
				return true;
			}

			internal bool <TryAddMagicSupremacyCompatSlot>b__1910_0(SlotDefinition existing)
			{
				return existing.Id == "magicsupremacy.belt";
			}

			internal bool <TryStartMultiUserContainerTakeAllBatch>b__1923_0(ItemData item)
			{
				return item?.m_shared != null;
			}

			internal int <TryStartMultiUserContainerTakeAllBatch>b__1923_1(ItemData item)
			{
				return item.m_gridPos.y;
			}

			internal int <TryStartMultiUserContainerTakeAllBatch>b__1923_2(ItemData item)
			{
				return item.m_gridPos.x;
			}

			internal int <TryHandleMultiUserContainerAreaBatch>b__1926_2(ItemData left, ItemData right)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return -CompareGridOrder(left.m_gridPos, right.m_gridPos);
			}

			internal int <TryStartMultiUserContainerPlaceStacksBatch>b__1927_1(ItemData left, ItemData right)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return -CompareGridOrder(left.m_gridPos, right.m_gridPos);
			}

			internal bool <TryPlanNextMultiUserContainerPlaceStacksStep>b__1948_0(ItemData item)
			{
				return item?.m_shared != null;
			}

			internal int <TryPlanNextMultiUserContainerPlaceStacksStep>b__1948_1(ItemData item)
			{
				return item.m_gridPos.y;
			}

			internal int <TryPlanNextMultiUserContainerPlaceStacksStep>b__1948_2(ItemData item)
			{
				return item.m_gridPos.x;
			}

			internal bool <TryFindLocalMultiUserContainerDestination>b__2026_0(ItemData target)
			{
				return target?.m_shared != null;
			}

			internal int <TryFindLocalMultiUserContainerDestination>b__2026_1(ItemData target)
			{
				return target.m_gridPos.y;
			}

			internal int <TryFindLocalMultiUserContainerDestination>b__2026_2(ItemData target)
			{
				return target.m_gridPos.x;
			}

			internal ItemData <TryCaptureMultiUserContainerInventory>b__2100_0(ItemData item)
			{
				return item.Clone();
			}

			internal void <BindConfigs>b__2423_0(object _, EventArgs _)
			{
				RefreshRestockTargetStackLimits();
			}

			internal void <BindConfigs>b__2423_1(object _, EventArgs _)
			{
				InvalidatePinnedTooltipUi();
			}

			internal void <BindConfigs>b__2423_2(object _, EventArgs _)
			{
				RefreshPinnedTooltipBackgrounds();
			}

			internal void <BindConfigs>b__2423_3(object _, EventArgs _)
			{
				OnCraftingHoverTooltipConfigChanged();
			}

			internal void <BindConfigs>b__2423_4(object _, EventArgs _)
			{
				RefreshCraftingHoverTooltipBackground();
			}

			internal void <BindConfigs>b__2423_5(object _, EventArgs _)
			{
				RefreshInventoryContainerHoverTooltipBackground();
			}

			internal void <BindConfigs>b__2423_6(object _, EventArgs _)
			{
				OnInventoryTrashPanelConfigChanged();
			}

			internal void <BindConfigs>b__2423_7(object _, EventArgs _)
			{
				ApplyAutoFavoriteHotbarSwitchRowToLocalPlayer();
			}

			internal void <BindConfigs>b__2423_8(object _, EventArgs _)
			{
				OnQuickSlotHudFollowsPanelChanged();
			}

			internal string <BuildRecycleNReclaimYieldText>b__2509_0(RecycleNReclaimYieldTextEntry entry)
			{
				return $"{LocalizeUi(entry.Name, entry.Name)} x{entry.Amount}";
			}

			internal bool <HasVisibleRecycleNReclaimYieldIcons>b__2510_0(RectTransform slot)
			{
				if ((Object)(object)slot != (Object)null && !IsUnityNull((Object?)(object)slot))
				{
					return ((Component)slot).gameObject.activeSelf;
				}
				return false;
			}

			internal bool <JoinRecycleNReclaimTextParts>b__2511_0(string part)
			{
				return !string.IsNullOrWhiteSpace(part);
			}

			internal string <JoinRecycleNReclaimTextParts>b__2511_1(string part)
			{
				return part.Trim();
			}

			internal string <SanitizeRecycleNReclaimHudText>b__2512_0(string line)
			{
				return line.Trim();
			}

			internal bool <SanitizeRecycleNReclaimHudText>b__2512_1(string line)
			{
				return !string.IsNullOrWhiteSpace(line);
			}

			internal bool <SerializeRestockTargetLimitEditorRows>b__2522_0(RestockTargetLimitEditorRow row)
			{
				if (string.IsNullOrWhiteSpace(row.Item))
				{
					return !string.IsNullOrWhiteSpace(row.Amount);
				}
				return true;
			}

			internal string <SerializeRestockTargetLimitEditorRows>b__2522_1(RestockTargetLimitEditorRow row)
			{
				return row.Item.Trim() + ": " + row.Amount.Trim();
			}

			internal bool <CreateSlotBackup>b__2529_0(ItemData item)
			{
				if (item != null)
				{
					return item.m_gridPos.y >= GetFixedRegularRows();
				}
				return false;
			}

			internal bool <HasAnySlotTailItem>b__2532_0(ItemData item)
			{
				if (item != null)
				{
					return item.m_gridPos.y >= GetFixedRegularRows();
				}
				return false;
			}

			internal void <InitializeYamlSync>b__2674_0()
			{
				ApplyYaml(_syncedYaml.Value, fromSync: true);
			}

			internal void <InitializeYamlSync>b__2674_1()
			{
				ApplyResourceMapYaml(_syncedResourceMapYaml.Value, fromSync: true);
			}

			internal void <StartYamlWatcher>b__2677_0(object _, FileSystemEventArgs args)
			{
				QueueYamlReloadForFile(args.FullPath);
			}

			internal void <StartYamlWatcher>b__2677_1(object _, RenamedEventArgs args)
			{
				QueueYamlReloadForFile(args.OldFullPath);
				QueueYamlReloadForFile(args.FullPath);
			}

			internal void <StartYamlWatcher>b__2677_2(object _, ErrorEventArgs _)
			{
				QueueYamlReload(reloadYaml: true, reloadResourceMap: true);
			}

			internal string <CreateYamlApplySnapshot>b__2690_0(KeyValuePair<string, List<string>> entry)
			{
				return entry.Key;
			}

			internal List<string> <CreateYamlApplySnapshot>b__2690_1(KeyValuePair<string, List<string>> entry)
			{
				return entry.Value.ToList();
			}

			internal string <CreateYamlApplySnapshot>b__2690_2(KeyValuePair<string, List<string>> entry)
			{
				return entry.Key;
			}

			internal List<string> <CreateYamlApplySnapshot>b__2690_3(KeyValuePair<string, List<string>> entry)
			{
				return entry.Value.ToList();
			}

			internal bool <ApplyYamlGroups>b__2696_0(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal string <ApplyYamlGroups>b__2696_1(string value)
			{
				return value.Trim();
			}

			internal bool <ApplyYamlGroups>b__2696_2(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal bool <ApplyYamlGroups>b__2696_3(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal bool <RebuildSlotDefinitions>b__2701_0(ItemData? item)
			{
				//IL_001a: 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_002d: Invalid comparison between Unknown and I4
				if (item == null)
				{
					return false;
				}
				return (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 6;
			}

			internal bool <RebuildSlotDefinitions>b__2701_1(ItemData? item)
			{
				//IL_001a: 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_002d: Invalid comparison between Unknown and I4
				if (item == null)
				{
					return false;
				}
				return (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 7;
			}

			internal bool <RebuildSlotDefinitions>b__2701_2(ItemData? item)
			{
				//IL_001a: 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_002e: Invalid comparison between Unknown and I4
				if (item == null)
				{
					return false;
				}
				return (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 11;
			}

			internal bool <RebuildSlotDefinitions>b__2701_3(ItemData? item)
			{
				//IL_001a: 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_002e: Invalid comparison between Unknown and I4
				if (item == null)
				{
					return false;
				}
				return (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 17;
			}

			internal bool <RebuildSlotDefinitions>b__2701_4(ItemData? item)
			{
				//IL_0018: 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_002c: Invalid comparison between Unknown and I4
				if (item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 18 && !IsJewelcraftingDedicatedJewelryItem(item))
				{
					return !IsJewelcraftingUtilityGemBlocked(item);
				}
				return false;
			}

			internal bool <RebuildSlotDefinitions>b__2701_5(ItemData? item)
			{
				//IL_001a: 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_002e: Invalid comparison between Unknown and I4
				if (item == null)
				{
					return false;
				}
				return (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 24;
			}

			internal bool <GetSlotItems>b__2706_0(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal string <GetSlotItems>b__2706_1(string value)
			{
				return value.Trim();
			}

			internal bool <.cctor>b__2729_0(ItemData _)
			{
				return true;
			}

			internal bool <.cctor>b__2729_1(ItemData item)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Invalid comparison between Unknown and I4
				return (int)item.m_shared.m_itemType == 13;
			}

			internal bool <.cctor>b__2729_2(ItemData item)
			{
				return item.m_shared.m_value > 0;
			}
		}

		private static bool _adventureBackpacksPatchesApplied;

		private static ItemData? _lastAdventureBackpackCompatItem;

		private static ItemData? _lastSmoothbrainBackpackCompatItem;

		private static ItemData? _lastRustyBagCompatItem;

		private static ItemData? _lastRustyQuiverCompatItem;

		private static readonly CompatRuntimeState CompatRuntime = new CompatRuntimeState();

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

		private const string MultiUserChestGuid = "com.maxsch.valheim.MultiUserChest";

		private const string BetterArcheryGuid = "ishid4.mods.betterarchery";

		private const string AzuCraftyBoxesGuid = "Azumatt.AzuCraftyBoxes";

		private const string EpicLootGuid = "randyknapp.mods.epicloot";

		private const string TooltipExpansionGuid = "Azumatt.TooltipExpansion";

		private const string JewelcraftingGuid = "org.bepinex.plugins.jewelcrafting";

		private const string ItemRequiresSkillLevelGuid = "WackyMole.ItemRequiresSkillLevel";

		private const string AdventureBackpacksGuid = "vapok.mods.adventurebackpacks";

		private const string SmoothbrainBackpacksGuid = "org.bepinex.plugins.backpacks";

		private const string RustyBagsGuid = "RustyMods.RustyBags";

		private const string MagicSupremacyGuid = "Dreanegade.Magic_Supremacy";

		private const string CurrencyPocketGuid = "Azumatt.CurrencyPocket";

		private const string MyLittleUIGuid = "shudnal.MyLittleUI";

		private const string RecycleNReclaimGuid = "Azumatt.Recycle_N_Reclaim";

		private const string VeiledRecipesGuid = "sighsorry.VeiledRecipes";

		private const string ContentsWithinGuid = "com.maxsch.valheim.contentswithin";

		private const string ContainerActionSuccessFxPrefabName = "fx_HildirChest_Unlock";

		private const int ContainerActionSuccessVfxLimit = 10;

		private const float ContainerActionSuccessSfxLifetime = 5f;

		private const int ContainerPreviewHiddenFrames = 10;

		private const float ContainerPreviewFailureLogInterval = 5f;

		private static readonly Dictionary<GameObject, bool> ContainerPreviewHiddenObjects = new Dictionary<GameObject, bool>();

		private static bool _containerPreviewRealGuiVisible;

		private static bool _containerPreviewFrameOwned;

		private static bool _containerPreviewActive;

		private static bool _containerPreviewUiCaptured;

		private static bool _containerPreviewStandaloneWarningLogged;

		private static Container? _containerPreviewTarget;

		private static Inventory? _containerPreviewInventory;

		private static Inventory? _containerPreviewRenderedInventory;

		private static int _containerPreviewRenderedWidth = -1;

		private static int _containerPreviewRenderedHeight = -1;

		private static float _containerPreviewCloseAt;

		private static float _containerPreviewLastFailureAt = float.NegativeInfinity;

		private static string _containerPreviewLastFailure = "";

		private const string RpcRequestSort = "InventorySlots_RequestSortV2";

		private const string RpcSortResponse = "InventorySlots_SortResponseV2";

		private const float ContainerSortRequestTimeout = 2f;

		private static Container? _pendingSortContainer;

		private static int _pendingSortRequestId;

		private static int _nextSortRequestId = 1;

		private static long _pendingSortOwner;

		private static float _pendingSortStartedAt = -1f;

		private const float ControllerHotkeyCaptureSeconds = 8f;

		private static readonly HashSet<string> ExpandedControllerHotkeyPresetDrawers = new HashSet<string>();

		private static string _controllerHotkeyCaptureEntryKey = "";

		private static float _controllerHotkeyCaptureEndTime;

		private static readonly ControllerActionOption[] ControllerActionOptions = new ControllerActionOption[21]
		{
			new ControllerActionOption(ControllerHotkeyAction.Off, "Off"),
			new ControllerActionOption(ControllerHotkeyAction.JoyButtonA, "A"),
			new ControllerActionOption(ControllerHotkeyAction.JoyButtonB, "B"),
			new ControllerActionOption(ControllerHotkeyAction.JoyButtonX, "X"),
			new ControllerActionOption(ControllerHotkeyAction.JoyButtonY, "Y"),
			new ControllerActionOption(ControllerHotkeyAction.JoyLBumper, "LB"),
			new ControllerActionOption(ControllerHotkeyAction.JoyRBumper, "RB"),
			new ControllerActionOption(ControllerHotkeyAction.JoyLTrigger, "LT"),
			new ControllerActionOption(ControllerHotkeyAction.JoyRTrigger, "RT"),
			new ControllerActionOption(ControllerHotkeyAction.JoyBack, "Back"),
			new ControllerActionOption(ControllerHotkeyAction.JoyStart, "Start"),
			new ControllerActionOption(ControllerHotkeyAction.JoyLStick, "L Stick"),
			new ControllerActionOption(ControllerHotkeyAction.JoyRStick, "R Stick"),
			new ControllerActionOption(ControllerHotkeyAction.JoyDPadUp, "DPad Up"),
			new ControllerActionOption(ControllerHotkeyAction.JoyDPadDown, "DPad Down"),
			new ControllerActionOption(ControllerHotkeyAction.JoyDPadLeft, "DPad Left"),
			new ControllerActionOption(ControllerHotkeyAction.JoyDPadRight, "DPad Right"),
			new ControllerActionOption(ControllerHotkeyAction.JoyHotbarUse, "Hotbar Use"),
			new ControllerActionOption(ControllerHotkeyAction.JoyAltKeys, "Alt Keys"),
			new ControllerActionOption(ControllerHotkeyAction.AltPlace, "Alt Place"),
			new ControllerActionOption(ControllerHotkeyAction.JoyUse, "Use")
		};

		private static readonly Dictionary<int, ControllerHotkeyAction> UnityJoystickButtonToControllerAction = new Dictionary<int, ControllerHotkeyAction>
		{
			[0] = ControllerHotkeyAction.JoyButtonA,
			[1] = ControllerHotkeyAction.JoyButtonB,
			[2] = ControllerHotkeyAction.JoyButtonX,
			[3] = ControllerHotkeyAction.JoyButtonY,
			[4] = ControllerHotkeyAction.JoyLBumper,
			[5] = ControllerHotkeyAction.JoyRBumper,
			[6] = ControllerHotkeyAction.JoyBack,
			[7] = ControllerHotkeyAction.JoyStart,
			[8] = ControllerHotkeyAction.JoyLStick,
			[9] = ControllerHotkeyAction.JoyRStick,
			[10] = ControllerHotkeyAction.JoyDPadLeft,
			[11] = ControllerHotkeyAction.JoyDPadRight,
			[12] = ControllerHotkeyAction.JoyDPadUp,
			[13] = ControllerHotkeyAction.JoyDPadDown,
			[14] = ControllerHotkeyAction.JoyLTrigger,
			[15] = ControllerHotkeyAction.JoyRTrigger,
			[16] = ControllerHotkeyAction.JoyButtonA,
			[17] = ControllerHotkeyAction.JoyButtonB,
			[18] = ControllerHotkeyAction.JoyButtonX,
			[19] = ControllerHotkeyAction.JoyButtonY
		};

		private static ConfigEntry<int> _craftingRecipeGridSize = null;

		private static ConfigEntry<KeyboardShortcut> _craftingRecipeGridZoomModifier = null;

		private static ConfigEntry<KeyboardShortcut> _craftingClearFavoritesKey = null;

		private static ConfigEntry<Toggle> _showCraftingRecipeGridZoomHint = null;

		private static ConfigEntry<CraftingRecipeSortMode> _craftingRecipeSortMode = null;

		private static ConfigEntry<Color> _craftingRecipeCraftableBackgroundColor = null;

		private const string CraftingRecipeGridName = "InventorySlots_CraftingRecipeGrid";

		private const string CraftingPinnedTooltipNamePrefix = "InventorySlots_CraftingPinnedTooltip_";

		private const string CraftingGemIconRowName = "InventorySlots_CraftingGemIconRow";

		private const string CraftingTooltipRecipeOverlayName = "InventorySlots_CraftingTooltipRecipeOverlay";

		private const string CraftingCountInputName = "InventorySlots_CraftingCountInput";

		private const string CraftingUpgradeProgressionName = "InventorySlots_CraftingUpgradeProgression";

		private const string CraftingSearchInputName = "InventorySlots_CraftingSearchInput";

		private const string CraftingSortModeButtonGroupName = "InventorySlots_CraftingSortModeButtons";

		private const string CraftingGroupFirstSortButtonName = "InventorySlots_CraftingGroupFirstSortButton";

		private const string CraftingTierFirstSortButtonName = "InventorySlots_CraftingTierFirstSortButton";

		private const string CraftingRecipeScrollbarName = "InventorySlots_CraftingRecipeScrollbar";

		private const string CraftingControlsBackgroundName = "InventorySlots_CraftingControlsBackground";

		private const string CraftingGroupRailName = "InventorySlots_CraftingGroupRail";

		private const string CraftingGroupPanelNamePrefix = "InventorySlots_CraftingGroupPanel_";

		private const string CraftingGroupButtonNamePrefix = "InventorySlots_CraftingGroupButton_";

		private const string CraftingRecipeGridCellNamePrefix = "InventorySlots_CraftingRecipeCell_";

		private const string CraftingRecipeStyleButtonName = "InventorySlots_CraftingRecipeStyleButton";

		private const string CraftingCountWheelIconName = "InventorySlots_CraftingCountWheelIcon";

		private const string CraftingRequirementSlotNamePrefix = "InventorySlots_CraftingRequirementSlot_";

		private const string CraftingRequirementHitboxName = "InventorySlots_CraftingRequirementHitbox";

		private const string CraftingRequiredStationHitboxName = "InventorySlots_CraftingRequiredStationHitbox";

		private const string CraftingRecipeGridZoomHintName = "InventorySlots_CraftingRecipeGridZoomHint";

		private const string CraftingFavoriteBorderName = "InventorySlots_CraftingFavoriteBorder";

		private const string CraftingPinnedTooltipMarkerName = "InventorySlots_CraftingPinnedTooltipMarker";

		private const string CraftingSocketWarningName = "InventorySlots_CraftingSocketWarning";

		private const string CraftingBottomControlsHiddenSignature = "hidden";

		private const int CraftingRecipeGridMinDimension = 4;

		private const int CraftingRecipeGridMaxDimension = 8;

		private const int CraftingRecipeGridColumns = 8;

		private const int CraftingRecipeGridRows = 9;

		private const int CraftingRecipeIconRows = 8;

		private const int CraftingBottomControlRow = 8;

		private const int CraftingSocketWarningRow = 9;

		private const int CraftingVisibleRequirementSlots = 4;

		private const float CraftingRecipeGridCellSize = 64f;

		private const float CraftingRecipeGridCellSpace = 72f;

		private const float CraftingSocketWarningHeight = 58f;

		private const float CraftingRecipeGridZoomHintFixedSize = 16f;

		private const float CraftingRecipeGridZoomHintFixedTextIconGap = 0f;

		private const float CraftingSearchInputWidth = 136f;

		private const int CraftingTooltipRecipeSlotCount = 5;

		private const int CraftingQueueMaxCount = 99;

		private static readonly Vector2 CraftingRecipeGridFixedOffset = new Vector2(0f, -100f);

		private static readonly Vector2 CraftingRecipeGridZoomHintFixedOffset = new Vector2(256f, -16f);

		private const float CraftingPanelBottomFixedExtension = 84f;

		private static readonly Vector2 CraftingRecipeScrollbarFixedOffset = new Vector2(4f, 0f);

		private static readonly Vector2 CraftingGroupRailFixedOffset = new Vector2(-66f, -96f);

		private const float CraftingGroupIconBlockFixedSize = 60f;

		private const float CraftingGroupIconFixedPadding = 3f;

		private static readonly Vector2 CraftingSearchInputFixedOffset = new Vector2(0f, 3f);

		private const float CraftingSortModeButtonGap = 4f;

		private static readonly Vector2 CraftingSortModeButtonsFixedOffset = new Vector2(0f, 4f);

		private static readonly Vector2 CraftingBottomControlsFixedOffset = new Vector2(0f, 8f);

		private static readonly Vector2 CraftingCraftButtonFixedOffset = new Vector2(0f, -4f);

		private static readonly Vector2 CraftingCountInputFixedOffset = new Vector2(0f, -4f);

		private static readonly Color CraftingRecipeUnavailableBackgroundColor = new Color(0.055f, 0.035f, 0.025f, 0.42f);

		private static readonly Color CraftingRecipeDefaultCraftableBackgroundColor = new Color(1f, 0.58f, 0.16f, 0.44f);

		private static readonly Color CraftingRecipeSelectedBackgroundColor = new Color(0.42f, 0.68f, 0.92f, 0.62f);

		private static Sprite? _craftingFavoriteGroupIcon;

		private const float CraftingRequirementAvailabilityCacheSeconds = 0.25f;

		private static readonly CraftingRecipeRuntimeState CraftingRecipes = new CraftingRecipeRuntimeState();

		private static readonly CraftingRequirementRuntimeState CraftingRequirements = new CraftingRequirementRuntimeState();

		private static readonly CraftingGridRuntimeState CraftingGrid = new CraftingGridRuntimeState();

		private static readonly CraftingScrollbarRuntimeState CraftingScrollbar = new CraftingScrollbarRuntimeState();

		private static readonly CraftingQueueRuntimeState CraftingQueue = new CraftingQueueRuntimeState();

		private static readonly CraftingUiRuntimeState CraftingUi = new CraftingUiRuntimeState();

		private static readonly CraftingRefreshRuntimeState CraftingRefresh = new CraftingRefreshRuntimeState();

		private static readonly Dictionary<Image, bool> CraftingVanillaPanelBackgroundStates = new Dictionary<Image, bool>();

		private static readonly Dictionary<RectTransform, RectTransformSnapshot> CraftingPanelResizeProtectedSnapshots = new Dictionary<RectTransform, RectTransformSnapshot>();

		private static readonly List<CraftingRecipeGroupFilter> CraftingRecipeGroupFilters = CreateCraftingRecipeGroupFilters();

		private static readonly HashSet<string> FavoriteCraftingRecipeKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> FavoriteUpgradeItemKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool _craftingRedesignApplied;

		private static bool _craftingVanillaRecipeElementsHidden;

		private static bool _craftingVanillaDetailHidden;

		private static bool _craftingVanillaRecipeScrollbarsHidden;

		private static bool _craftingVanillaPanelBackgroundsHidden;

		private static bool _craftingEnglishLocalizationIndexBuilt;

		private static int _lastCraftingSelectedVariant = -1;

		private static int _craftingRecipeVariantVersion;

		private static int _craftingFavoritesVersion;

		private static int _craftingGroupAvailabilityVersion;

		private static int _craftingGroupAvailabilityBuiltVersion = -1;

		private static int _uiLocalizationVersion;

		private static string _loadedCraftingFavoritesPlayerId = "";

		private static string _selectedCraftingGroupId = "";

		private static string _craftingSearchQuery = "";

		private static string _craftingGroupAvailabilitySignature = "";

		private static string _craftingGroupAvailabilityContextSignature = "";

		private static string _craftingSelectableGroupFilterIdsSignature = "";

		private static string _craftingPanelExtensionSignature = "";

		private static string _pendingUpgradeFavoriteItemId = "";

		private static string _pendingUpgradeFavoritePrefab = "";

		private static int _pendingUpgradeFavoriteQuality = -1;

		private static int _pendingUpgradeFavoriteVariant = -1;

		private static int _visibleRecycleNReclaimTabFrame = -1;

		private static int _visibleRecycleNReclaimTabGuiId = -1;

		private static Vector2i _pendingUpgradeFavoriteGridPos = new Vector2i(-1, -1);

		private static bool _visibleRecycleNReclaimTabValue;

		private static Recipe? _lastCraftingSelectedRecipe;

		private static object? _craftingGroupAvailabilityRecipeListRef;

		private static int _craftingGroupAvailabilityRecipeCount = -1;

		private const float CraftingHoverTooltipScrollbarWidth = 3f;

		private const float CraftingHoverTooltipScrollbarOutsideOffset = 2f;

		private const float CraftingHoverTooltipScrollSensitivity = 96f;

		private const float CraftingHoverTooltipMinBodyHeight = 80f;

		private const float CraftingHoverTooltipMaxPanelHeight = 720f;

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

		private static readonly Dictionary<string, int> CustomEquipmentSetCountCache = new Dictionary<string, int>(StringComparer.Ordinal);

		private static Player? _customEquipmentCachePlayer;

		private static Inventory? _customEquipmentCacheInventory;

		private static string _customEquipmentCachePlayerId = "";

		private static int _customEquipmentCacheVersion;

		private static int _customEquipmentCacheBuiltVersion = -1;

		private static float _customEquipmentCacheWeight;

		private static float _customEquipmentCacheEitrRegen;

		private static float _customEquipmentCacheArmor;

		private static float[]? _customEquipmentModifierValuesCache;

		private const string CustomEquipmentVisualItemZdoPrefix = "InventorySlots_CustomEquipmentVisual_Item_";

		private const string CustomEquipmentVisualVariantZdoPrefix = "InventorySlots_CustomEquipmentVisual_Variant_";

		private static bool? _epicLootLoaded;

		private static int _epicLootInventoryGridTooltipUiPatchScope;

		private static GameObject? _epicLootSuppressedOnHoverTooltip;

		private static bool _epicLootComparisonTooltipReflectionResolved;

		private static FieldInfo? _epicLootComparisonTooltipField;

		private static FieldInfo? _epicLootComparisonAddedField;

		private static bool _epicLootEquipmentEffectCacheResetReflectionResolved;

		private static MethodInfo? _epicLootEquipmentEffectCacheResetMethod;

		private static bool _epicLootEquipmentEffectCacheResetWarningLogged;

		private static bool _epicLootRuntimeItemDataReflectionResolved;

		private static bool _epicLootRuntimeItemDataWarningLogged;

		private static MethodInfo? _epicLootItemDataMethod;

		private static MethodInfo? _epicLootItemInfoLoadAllMethod;

		private static MethodInfo? _epicLootItemInfoGetMethod;

		private static Type? _epicLootMagicItemComponentType;

		private static MethodInfo? _epicLootMagicItemComponentLoadMethod;

		private static int _lastEpicLootRespawnRuntimeReloadFrame = -1;

		private static float _lastEpicLootRespawnRuntimeReloadTime = -1000f;

		private const float HudStatBarPixelsPer25 = 32f;

		private const float HudAdrenalineBarPixelsPer25 = 64f;

		private const float HudStatBarLogBaseline = 100f;

		private const float InventoryHoverTooltipWidth = 410f;

		private const float InventoryHoverTooltipPadding = 8f;

		private const float InventoryHoverTooltipTopicGap = 6f;

		private const float InventoryHoverTooltipScrollbarWidth = 3f;

		private const float InventoryHoverTooltipScrollbarOutsideOffset = 2f;

		private const float InventoryHoverTooltipScrollSensitivity = 120f;

		private const float InventoryHoverTooltipMinBodyHeight = 80f;

		private const float InventoryHoverTooltipMaxPanelHeight = 720f;

		private const float InventoryHoverTooltipScrollbarThresholdHeight = 600f;

		private const int InventoryHoverTooltipSourceCacheLimit = 64;

		private static readonly InventoryHoverTooltipRuntimeState InventoryHoverTooltipRuntime = new InventoryHoverTooltipRuntimeState();

		private static string QuickSlotProgressionCachePlayerId = "";

		private static int QuickSlotProgressionCachedRows;

		private static string QuickSlotProgressionResetPendingPlayerId = "";

		private static string QuickSlotProgressionResetWarningPlayerId = "";

		private static readonly Dictionary<string, PlayerInventoryPanelBackgroundSnapshot> PlayerInventoryPanelBackgroundSnapshots = new Dictionary<string, PlayerInventoryPanelBackgroundSnapshot>(StringComparer.Ordinal);

		private static CustomSyncedValue<string> _syncedYaml = null;

		private static CustomSyncedValue<string> _syncedResourceMapYaml = null;

		private static FileSystemWatcher? _yamlWatcher;

		private static readonly object YamlReloadLock = new object();

		private static readonly InventoryPanelRuntimeState InventoryPanels = new InventoryPanelRuntimeState();

		private static readonly InventorySafetyRuntimeState InventorySafety = new InventorySafetyRuntimeState();

		private static readonly InventoryContainerRuntimeState InventoryContainers = new InventoryContainerRuntimeState();

		private static readonly InventoryDefinitionRuntimeState InventoryDefinitions = new InventoryDefinitionRuntimeState();

		private static readonly InventoryClientRuntimeState InventoryClient = new InventoryClientRuntimeState();

		private static readonly EquipmentVisualRuntimeState EquipmentVisuals = new EquipmentVisualRuntimeState();

		private static readonly InventorySortRuntimeState InventorySort = new InventorySortRuntimeState();

		private static readonly string[] PlayerStatPanelExtraNames = new string[2] { "Jewelcrafting Synergy", "Trash" };

		private static readonly string[] QuickStackStoreMiniButtonNames = new string[4] { "sortInventoryButton", "restockAreaButton", "quickStackAreaButton", "favoritingTogglingButton" };

		private float _nextRefreshTime;

		private float _nextLightAuditTime;

		private float _nextHeavyAuditTime;

		private static bool _yamlReloadQueued;

		private static bool _resourceMapReloadQueued;

		private static DateTime _yamlReloadAfterUtc;

		private const float InventoryTrashPanelGap = 8f;

		private const string InventoryTrashButtonName = "InventorySlots_TrashButton";

		private const string InventoryTrashIconName = "InventorySlots_TrashIcon";

		private const string InventoryTrashConfirmDialogName = "InventorySlots_TrashConfirmDialog";

		private static RectTransform? _inventoryTrashPanel;

		private static Sprite? _inventoryTrashIconSprite;

		private static GameObject? _inventoryTrashConfirmDialog;

		private static Inventory? _inventoryTrashPendingInventory;

		private static ItemData? _inventoryTrashPendingItem;

		private static int _inventoryTrashPendingAmount;

		private const int MaxItemClassifierCacheItems = 2048;

		private static readonly ItemClassifierRuntimeState ItemClassifierRuntime = new ItemClassifierRuntimeState();

		private static readonly Dictionary<string, Func<ItemData, bool>> BuiltInGroupMatchers = new Dictionary<string, Func<ItemData, bool>>(StringComparer.OrdinalIgnoreCase)
		{
			["all"] = (ItemData _) => true,
			["healthfood"] = MatchHealthFoodCategory,
			["staminafood"] = MatchStaminaFoodCategory,
			["eitrfood"] = MatchEitrFoodCategory,
			["consumable"] = MatchConsumableCategory,
			["mead"] = MatchMeadCategory,
			["potion"] = MatchPotionCategory,
			["meadbase"] = MatchMeadBaseCategory,
			["feast"] = MatchFeastCategory,
			["trophy"] = (ItemData item) => (int)item.m_shared.m_itemType == 13,
			["valuable"] = (ItemData item) => item.m_shared.m_value > 0,
			["melee"] = MatchMeleeCategory,
			["ranged"] = MatchRangedCategory,
			["magic"] = MatchMagicCategory,
			["armor"] = MatchArmorCategory,
			["equipment"] = MatchArmorCategory,
			["food"] = MatchFoodCategory,
			["misc"] = MatchMiscCategory,
			["legs"] = MatchLegsCategory,
			["chest"] = MatchChestCategory,
			["helmet"] = MatchHelmetCategory,
			["cape"] = MatchCapeCategory,
			["utility"] = MatchUtilityCategory,
			["trinket"] = MatchTrinketCategory,
			["shield"] = MatchShieldCategory,
			["axe"] = MatchAxeCategory,
			["club"] = MatchClubCategory,
			["knife"] = MatchKnifeCategory,
			["pickaxe"] = MatchPickaxeCategory,
			["polearm"] = MatchPolearmCategory,
			["spear"] = MatchSpearCategory,
			["sword"] = MatchSwordCategory,
			["fists"] = MatchFistsCategory,
			["bow"] = MatchBowWeaponCategory,
			["crossbow"] = MatchCrossbowWeaponCategory,
			["elementalmagic"] = MatchElementalMagicCategory,
			["bloodmagic"] = MatchBloodMagicCategory,
			["tool"] = MatchToolCategory,
			["bomb"] = MatchBombCategory,
			["arrow"] = MatchArrowAmmo,
			["bolt"] = MatchBoltAmmo,
			["ammo"] = MatchAmmoCategory
		};

		private const string JewelcraftingGemcutterStationPrefabName = "op_transmution_table";

		private static bool _jewelcraftingSlotStateInitialized;

		private static bool _lastJewelcraftingRingSlotEnabled;

		private static bool _lastJewelcraftingNecklaceSlotEnabled;

		private static bool _lastJewelcraftingWisplightGemEnabled;

		private static bool _lastJewelcraftingWishboneGemEnabled;

		private const float InventoryPinnedJewelcraftingScrollGap = 12f;

		private const float InventoryPinnedJewelcraftingRowPadding = 12f;

		private const float InventoryPinnedJewelcraftingIconGap = 8f;

		private const float InventoryPinnedJewelcraftingNativeIconSize = 42f;

		private const float InventoryPinnedJewelcraftingNativeIconInset = 4f;

		private const float InventoryPinnedJewelcraftingNativeRowGap = 10f;

		private const float InventoryPinnedJewelcraftingNativeInteractGap = 8f;

		private const float InventoryPinnedJewelcraftingNativeTextPadding = 4f;

		private const float InventoryPinnedJewelcraftingNativeBottomPadding = 32f;

		private static ItemData? _lastMagicSupremacyBeltCompatItem;

		private static MultiUserContainerBatchState? _multiUserContainerBatch;

		private const byte MultiUserContainerItemCodecVersion = 1;

		private const int MultiUserContainerMaxPrefabNameBytes = 1024;

		private const int MultiUserContainerMaxCrafterNameBytes = 4096;

		private const int MultiUserContainerMaxCustomDataEntries = 1024;

		private const int MultiUserContainerMaxCustomDataKeyBytes = 4096;

		private const int MultiUserContainerMaxCustomDataValueBytes = 40960;

		private const int MultiUserContainerMaxCustomDataBytes = 40960;

		private const int MultiUserContainerMaxStack = 1000000;

		private const int MultiUserContainerMaxQuality = 10000;

		private const int MultiUserContainerMaxVariant = 10000;

		private const int MultiUserContainerMaxWorldLevel = 10000;

		private const int MultiUserContainerMaxGridCoordinate = 4096;

		private static readonly Encoding MultiUserContainerUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		private const float MultiUserContainerRetryInterval = 0.75f;

		private const float MultiUserContainerRequestTimeout = 5f;

		private const float MultiUserContainerReceiptPollInterval = 0.25f;

		private const float MultiUserContainerCommittedProjectionTimeout = 5f;

		private const float MultiUserContainerLocalRecoveryRetryInterval = 1f;

		private const int MultiUserContainerMaximumSendAttempts = 5;

		private static PendingMultiUserContainerTransfer? _pendingMultiUserContainerTransfer;

		private static readonly List<PendingMultiUserContainerLocalRecovery> PendingMultiUserContainerLocalRecoveries = new List<PendingMultiUserContainerLocalRecovery>();

		private static int _nextMultiUserContainerRequestId = Math.Max(1, Guid.NewGuid().GetHashCode() & 0x7FFFFFFF);

		private const string MultiUserContainerRequestRpc = "InventorySlots_MUC_Request_v3";

		private const string MultiUserContainerResponseRpc = "InventorySlots_MUC_Response_v3";

		private const string MultiUserContainerAcknowledgeRpc = "InventorySlots_MUC_Ack_v3";

		private const string MultiUserContainerReceiptZdoKey = "sighsorry.InventorySlots.MUC.Receipts.v3";

		private const byte MultiUserContainerProtocolVersion = 3;

		private const int MultiUserContainerMaxRequestPackageBytes = 98304;

		private const int MultiUserContainerMaxResponsePackageBytes = 49152;

		private const int MultiUserContainerMaxDurableReceiptResponseBytes = 49152;

		private const int MultiUserContainerMaxDurableReceiptBlobBytes = 65536;

		private const int MultiUserContainerMaxDurableReceiptCount = 128;

		private const long MultiUserContainerAcknowledgedReceiptLifetimeTicks = 300000000L;

		private const int MultiUserContainerOwnerResponseCacheLimit = 128;

		private const int MultiUserContainerOwnerResponseCacheByteLimit = 33554432;

		private const float MultiUserContainerOwnerResponseCacheLifetime = 30f;

		private const float MultiUserContainerMaximumInteractionDistance = 10f;

		private static readonly Dictionary<Container, MultiUserContainerOwnerState> MultiUserContainerOwnerStates = new Dictionary<Container, MultiUserContainerOwnerState>();

		private const float MyLittleUICraftingObjectScanInterval = 0.5f;

		private static readonly string[] MyLittleUIConflictingPatchTypeNames = new string[19]
		{
			"MyLittleUI.CraftFilter+StoreGui_Awake_InitializePanel", "MyLittleUI.CraftFilter+InventoryGui_Show_ClearCache", "MyLittleUI.CraftFilter+InventoryGui_OnDestroy_ClearCache", "MyLittleUI.CraftFilter+Chat_HasFocus_FocusOverride", "MyLittleUI.CraftFilter+Player_GetAvailableRecipes_FilterRecipeList", "MyLittleUI.CraftFilter+InventoryGui_UpdateRecipe_HandleFieldFocus", "MyLittleUI.CraftSort+Game_SpawnPlayer_InitializePanel", "MyLittleUI.CraftSort+InventoryGui_Update_SortingPanelVisibility", "MyLittleUI.CraftSort+InventoryGui_UpdateCraftingPanel_HideWithOtherMods", "MyLittleUI.CraftSort+InventoryGui_Update_HideWithOtherMods",
			"MyLittleUI.CraftSort+InventoryGui_UpdateRecipeList_FilteringAndSorting", "MyLittleUI.CraftSort+InventoryGui_Update_GamepadControls", "MyLittleUI.MultiCraft+InventoryGui_UpdateRecipe_MulticraftShowButtons", "MyLittleUI.MultiCraft+InventoryGui_Awake_MulticraftCreateButtons", "MyLittleUI.MultiCraft+InventoryGui_SetRecipe_ResetMulticraftAfterRecipeChange", "MyLittleUI.Crafting.CraftNew+InventoryGui_UpdateRecipeList_CraftNewRecipeMark", "MyLittleUI.MyLittleUI+InventoryGui_SetupRequirement_AddAvailableAmount", "MyLittleUI.ItemTooltip+ItemDropItemData_GetTooltip_ItemTooltip", "MyLittleUI.ItemTooltip+InventoryGui_Awake_ItemTooltipCraftingFontSize"
		};

		private static readonly string[] MyLittleUICraftingObjectNames = new string[3] { "MLUI_FilterField", "MLUI_SortingPanels", "MLUI_Multicraft" };

		private static readonly string[] MyLittleUICraftingObjectPrefixes = new string[2] { "MLUI_SortingPanel_", "selected (MLUI_SortingPanel_" };

		private static readonly List<Transform> CachedMyLittleUICraftingObjects = new List<Transform>();

		private static int _myLittleUICraftingObjectRootSignature;

		private static float _nextMyLittleUICraftingObjectScanTime;

		private static bool _myLittleUIInventoryVisibleLastFrame;

		private static bool _myLittleUIPluginPresenceResolved;

		private static bool _myLittleUIPluginDetected;

		private static bool _myLittleUICraftingSuppressionActive;

		private static bool _myLittleUICraftingCompatibilityApplied;

		private static string _myLittleUICraftingSuppressionSignature = "";

		private const float PinnedTooltipScrollbarWidth = 3f;

		private const float PinnedTooltipScrollbarOutsideOffset = 2f;

		private const float PinnedTooltipScrollSensitivity = 240f;

		private const float CraftingPinnedTooltipTextScrollPadding = 0f;

		private const float PinnedTooltipScrollOverflowThreshold = 8f;

		private const float PinnedTooltipTopOffset = -12f;

		private const float PinnedTooltipBottomOffset = 60f;

		private const float PinnedTooltipInventoryStartOffset = 6f;

		private const float PinnedTooltipCraftingStartOffset = -80f;

		private const int BaseRows = 4;

		private const int InventoryWidth = 8;

		private const int MaxSupportedExtraRows = 5;

		private const string SlotIdKey = "InventorySlotsSlotId";

		private const string EquippedByKey = "InventorySlotsEquippedBy";

		private const string BackupKey = "InventorySlotsBackup";

		private const string UpgradeFavoriteItemIdKey = "InventorySlotsUpgradeFavoriteId";

		private const string ExtraSlotsEquippedByKey = "ExtraSlotsEquippedBy";

		private const string ExtraSlotsEquippedSlotKey = "ExtraSlotsEquippedSlot";

		private const string ExtraSlotsEquippedWeaponShieldKey = "ExtraSlotsEquippedWeaponShield";

		private const string JewelcraftingRingSlotId = "jewelcrafting.ring";

		private const string JewelcraftingNecklaceSlotId = "jewelcrafting.necklace";

		private const string AdventureBackpackSlotId = "adventurebackpacks.backpack";

		private const string SmoothbrainBackpackSlotId = "smoothbrainbackpacks.backpack";

		private const string RustyBagSlotId = "rustybags.bag";

		private const string RustyQuiverSlotId = "rustybags.quiver";

		private const string MagicSupremacyBeltSlotId = "magicsupremacy.belt";

		private const string MagicSupremacyNativeBeltSlotId = "belt";

		private const string MultiUserChestIgnoreZdoKey = "MUC_Ignore";

		private const string ConfigDirectoryName = "InventorySlots";

		private const string YamlFileName = "InventorySlots.yml";

		private const string ResourceMapFileName = "ResourceMap.yml";

		private const string ClientStateFileName = "ClientState.yml";

		private const string CustomSlotPanelName = "InventorySlots_CustomSlotPanel";

		private const string QuickSlotPanelName = "InventorySlots_QuickSlotPanel";

		private const string SlotPanelDragBorderName = "InventorySlots_DragBorder";

		private const string PlayerStatPanelHostName = "InventorySlots_PlayerStatPanelHost";

		private const string InventorySortPanelName = "InventorySlots_InventorySortPanel";

		private const string InventoryTrashPanelName = "InventorySlots_TrashPanel";

		private const string CurrencyPocketPanelName = "CoinPocketUI";

		private const int CurrencyPocketInventoryRow = 4;

		private const float CurrencyPocketOutsideGap = 6f;

		private const string QuickSlotsHotkeyBarName = "InventorySlots_QuickSlotsHotKeyBar";

		private const string FavoriteKeyHintName = "InventorySlots_FavoriteKeyHint";

		private const string PinnedTooltipKeyHintName = "InventorySlots_PinnedTooltipKeyHint";

		private const string InventoryPinnedTooltipNamePrefix = "InventorySlots_InventoryPinnedTooltip_";

		private const string InventoryPinnedJewelcraftingTooltipRootName = "InventorySlots_JewelcraftingTooltipRoot";

		private const string InventoryPinnedTooltipMarkerName = "InventorySlots_PinnedTooltipMarker";

		private const string FavoriteBorderName = "InventorySlots_FavoriteBorder";

		private const float FavoriteBorderThickness = 2f;

		private const float QuickSlotsHudSlotBackgroundAlpha = 0.25f;

		private const int CustomSlotPanelRows = 3;

		private const int QuickSlotPanelColumns = 3;

		private const int QuickSlotPanelRows = 3;

		private const float EquipmentPanelGapRows = 0.35f;

		private const float SidePanelGapColumns = 1.45f;

		private const float SidePanelBackgroundPadding = 16f;

		private const float PlayerStatPanelGap = -8f;

		private const int HotbarRowsToSwitch = 2;

		private const int HotbarSwitchFavoriteRow = 1;

		private const float ContainerActionPairButtonWidthMultiplier = 1f;

		private const float SortButtonOutsideGap = 1f;

		private const float QuickSlotPanelIntroFallbackDuration = 0.25f;

		private const float ContainerHoverHoldDuration = 0.5f;

		private const int PinnedTooltipSlotCount = 3;

		private const float PinnedTooltipFixedPanelGap = 15f;

		private const float InventoryMaintenanceInterval = 1f;

		private const float LightSafetyAuditInterval = 5f;

		private const float HeavySafetyAuditInterval = 30f;

		private const float HeavySafetyAuditActivityDelay = 2f;

		private const float PendingSlotActionTimeout = 30f;

		private const float InventoryPinnedJewelcraftingReservedHeight = 190f;

		private const string ProgressiveSlotsConfigSection = "2 - Progressive Slots";

		private const string RestockConfigSection = "3 - Restock";

		private const string ClientConfigSection = "4 - Client";

		private const string ClientUiConfigSection = "5 - Client UI";

		private const string ClientKeysConfigSection = "6 - Client Keys";

		private const string ControllerInputConfigSection = "7 - Controller Input";

		private static readonly Vector2 HotbarSwitchHintOffset = new Vector2(-50f, -32f);

		private static readonly Color HotbarSwitchHintColor = new Color(58f / 85f, 0.8784314f, 1f, 1f);

		private const float HotbarSwitchHintSize = 64f;

		private const float HotbarSwitchHintFontSize = 16f;

		private static readonly Vector2 InventoryWheelHintOffset = new Vector2(0f, -32f);

		private static readonly Color InventoryWheelHintColor = new Color(58f / 85f, 0.8784314f, 1f, 1f);

		private const float InventoryWheelHintSize = 0f;

		private static readonly Vector2 PinnedTooltipFixedPanelSize = new Vector2(345f, 600f);

		private static readonly Vector2 InventoryPinnedTooltipFixedOffset = new Vector2(828f, -384f);

		private static readonly Vector2 CraftingPinnedTooltipFixedOffset = new Vector2(-900f, 0f);

		private static readonly Vector2 QuickSlotsPanelFixedOffset = new Vector2(-80f, -552f);

		private static readonly Vector2 QuickSlotsHudFallbackPosition = new Vector2(64f, -520f);

		private static readonly Vector2 EquipmentSlotsPanelFixedOffset = new Vector2(-80f, 0f);

		private static readonly Vector2 PlayerStatPanelsFixedOffset = Vector2.zero;

		private static readonly Vector2 ArmorPanelFixedOffset = new Vector2(-5f, 15f);

		private static readonly Vector2 WeightPanelFixedOffset = new Vector2(-5f, -5f);

		private static readonly Vector2 SynergyPanelFixedOffset = new Vector2(-5f, -25f);

		private static readonly Vector2 InventorySortButtonFixedOffset = new Vector2(2f, 2f);

		private static readonly Vector2 ContainerSortButtonFixedOffset = Vector2.zero;

		private const float ContainerWeightPanelFixedYOffset = 200f;

		internal static readonly ManualLogSource Log = Logger.CreateLogSource("InventorySlots");

		private readonly Harmony _harmony = new Harmony("sighsorry.InventorySlots");

		private static InventorySlotsPlugin _instance = null;

		private static readonly ConfigSync ConfigSync = new ConfigSync("sighsorry.InventorySlots")
		{
			DisplayName = "InventorySlots",
			CurrentVersion = "1.3.3",
			MinimumRequiredVersion = "1.3.3",
			ModRequired = true
		};

		private static ConfigEntry<Toggle> _serverConfigLocked = null;

		private static ConfigEntry<Toggle> _progressiveRowsEnabled = null;

		private static ConfigEntry<int> _maxExtraRows = null;

		private static ConfigEntry<string>[] _rowUnlockItems = null;

		private static ConfigEntry<int> _quickSlotRows = null;

		private static ConfigEntry<Toggle> _quickSlotProgressionEnabled = null;

		private static ConfigEntry<string>[] _quickSlotRowUnlockItems = null;

		private static ConfigEntry<Toggle> _equipmentSlotProgressionEnabled = null;

		private static ConfigEntry<Toggle> _deathKeepRulesEnabled = null;

		private static ConfigEntry<float> _areaQuickStackRange = null;

		private static ConfigEntry<float> _areaRestockRange = null;

		private static ConfigEntry<string> _restockTargetStackLimitsConfig = null;

		private static ConfigEntry<KeyboardShortcut> _hotbarSwitchKey = null;

		private static ConfigEntry<KeyboardShortcut> _containerRestockKey = null;

		private static ConfigEntry<Toggle> _showHotbarSwitchHint = null;

		private static ConfigEntry<Toggle> _quickSlotHudFollowsPanel = null;

		private static ConfigEntry<InventoryRowsDisplayMode> _inventoryRowsDisplayMode = null;

		private static ConfigEntry<Toggle> _showInventoryWheelButton = null;

		private static ConfigEntry<Toggle> _enableInventoryTrashPanel = null;

		private static ConfigEntry<PinnedTooltipSlotMode> _pinnedTooltipSlots = null;

		private static ConfigEntry<KeyboardShortcut> _pinnedTooltipKey = null;

		private static ConfigEntry<float> _pinnedTooltipBackgroundAlpha = null;

		private static ConfigEntry<CraftingHoverTooltipMode> _showCraftingHoverTooltip = null;

		private static ConfigEntry<float> _craftingHoverTooltipBackgroundAlpha = null;

		private static ConfigEntry<float> _inventoryContainerHoverTooltipBackgroundAlpha = null;

		private static ConfigEntry<PlayerStatBarLengthScaling> _playerStatBarLengthScaling = null;

		private static ConfigEntry<Toggle> _containerActionSuccessFx = null;

		private static ConfigEntry<CraftingRecipeSortMode> _inventorySortMode = null;

		private static ConfigEntry<Toggle> _autoFavoriteHotbarSwitchRow = null;

		private static ConfigEntry<float> _mouseUiScrollMultiplier = null;

		private static ConfigEntry<Toggle> _enableGamepadUiScroll = null;

		private static ConfigEntry<GamepadUiScrollSource> _gamepadUiScrollSource = null;

		private static ConfigEntry<float> _gamepadUiScrollSensitivity = null;

		private static ConfigEntry<float> _gamepadUiScrollRepeatDelay = null;

		private static ConfigEntry<float> _gamepadUiScrollDeadzone = null;

		private static ConfigEntry<Toggle> _enableControllerHotkeys = null;

		private static ConfigEntry<ControllerDPadHotkeyMode> _controllerDPadHotkeyMode = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerDPadModifierButton = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerCraftingGridZoomModifierButton = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerPinnedTooltipButton = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerFavoriteModifierButton = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerClearCraftingFavoritesButton = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerHotbarSwitchButton = null;

		private static ConfigEntry<ControllerHotkeyAction> _controllerContainerRestockButton = null;

		private static ConfigEntry<ControllerHotkeyAction>[] _controllerQuickSlotButtons = null;

		private static ConfigEntry<float> _containerPreviewCloseDelay = null;

		private static ConfigEntry<KeyboardShortcut> _favoriteModifierKey = null;

		private static ConfigEntry<KeyboardShortcut>[] _quickSlotHotkeys = null;

		private static ConfigEntry<Toggle> _enableBuiltInMultiUserChest = null;

		internal const string ModName = "InventorySlots";

		internal const string ModVersion = "1.3.3";

		internal const string Author = "sighsorry";

		internal const string ModGUID = "sighsorry.InventorySlots";

		private const string RecycleNReclaimCompatibilityCapability = "Recycle_N_Reclaim reclaim tab";

		private const float RecycleNReclaimSignatureCacheSeconds = 0.1f;

		private static int _recycleNReclaimActiveFrame = -1;

		private static bool _recycleNReclaimActiveFrameValue;

		private static float _recycleNReclaimContextSignatureExpiresAt;

		private static string _recycleNReclaimContextSignature = "";

		private const string RecycleNReclaimHudName = "InventorySlots_RecycleNReclaimHud";

		private const int RecycleNReclaimYieldColumn = 2;

		private const int RecycleNReclaimYieldColumns = 6;

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

		private static readonly List<RecycleNReclaimYieldTextEntry> RecycleNReclaimHudYields = new List<RecycleNReclaimYieldTextEntry>();

		private static RectTransform? _recycleNReclaimHudRect;

		private static TMP_Text? _recycleNReclaimHudText;

		private static string _recycleNReclaimHudSignature = "";

		private static object? _recycleNReclaimRecipeListSignatureListRef;

		private static int _recycleNReclaimRecipeListSignatureCount = -1;

		private static float _recycleNReclaimRecipeListSignatureExpiresAt;

		private static string _recycleNReclaimRecipeListSignature = "";

		private static readonly List<RestockTargetLimitEditorRow> RestockTargetLimitEditorRows = new List<RestockTargetLimitEditorRow>();

		private static string _restockTargetLimitEditorLastValue = "";

		private static readonly List<CookingStation> StationTokenCookingStations = new List<CookingStation>();

		private static readonly List<Fermenter> StationTokenFermenters = new List<Fermenter>();

		private static readonly Dictionary<GameObject, TooltipCanvasGroupVisualSnapshot> VanillaTooltipVisualSnapshots = new Dictionary<GameObject, TooltipCanvasGroupVisualSnapshot>();

		private static readonly Dictionary<CanvasGroup, TooltipCanvasGroupVisualSnapshot> VanillaTooltipChildCanvasGroupSnapshots = new Dictionary<CanvasGroup, TooltipCanvasGroupVisualSnapshot>();

		private static readonly PinnedTooltipRuntimeState PinnedTooltips = new PinnedTooltipRuntimeState();

		private static readonly TooltipUiRuntimeState TooltipUi = new TooltipUiRuntimeState();

		private static float _nextGamepadUiScrollStepTime;

		private static YamlRoot _yamlConfig = new YamlRoot();

		private const string DefaultYamlResourceName = "InventorySlots.Default.yml";

		private const string DefaultResourceMapYamlResourceName = "InventorySlots.ResourceMap.Default.yml";

		private static readonly Lazy<string> DefaultYamlResource = new Lazy<string>(LoadDefaultYaml);

		private static readonly Lazy<string> DefaultResourceMapYamlResource = new Lazy<string>(LoadDefaultResourceMapYaml);

		private static bool HasServerCharactersActive
		{
			get
			{
				if (!ZNet.IsSinglePlayer)
				{
					return HasPlugin("org.bepinex.plugins.servercharacters");
				}
				return false;
			}
		}

		private static bool HasExternalMultiUserChestActive => HasPlugin("com.maxsch.valheim.MultiUserChest");

		private static bool IsBuiltInMultiUserChestEnabled
		{
			get
			{
				if (!HasExternalMultiUserChestActive)
				{
					ConfigEntry<Toggle> enableBuiltInMultiUserChest = _enableBuiltInMultiUserChest;
					if (enableBuiltInMultiUserChest == null)
					{
						return false;
					}
					return enableBuiltInMultiUserChest.Value == Toggle.On;
				}
				return false;
			}
		}

		private static bool HasJewelcraftingActive => HasPlugin("org.bepinex.plugins.jewelcrafting");

		private static RectTransform? _craftingRecipeGrid
		{
			get
			{
				return CraftingGrid.RecipeGrid;
			}
			set
			{
				CraftingGrid.RecipeGrid = value;
			}
		}

		private static RectTransform? _craftingRecipeScrollbar
		{
			get
			{
				return CraftingScrollbar.RecipeScrollbar;
			}
			set
			{
				CraftingScrollbar.RecipeScrollbar = value;
			}
		}

		private static RectTransform? _craftingGroupRail
		{
			get
			{
				return CraftingUi.GroupRail;
			}
			set
			{
				CraftingUi.GroupRail = value;
			}
		}

		private static TMP_InputField? _craftingCountInput
		{
			get
			{
				return CraftingUi.CountInput;
			}
			set
			{
				CraftingUi.CountInput = value;
			}
		}

		private static RectTransform? _craftingCountInputRect
		{
			get
			{
				return CraftingUi.CountInputRect;
			}
			set
			{
				CraftingUi.CountInputRect = value;
			}
		}

		private static RectTransform? _craftingUpgradeProgressionRect
		{
			get
			{
				return CraftingUi.UpgradeProgressionRect;
			}
			set
			{
				CraftingUi.UpgradeProgressionRect = value;
			}
		}

		private static RectTransform? _craftingSortModeButtonGroup
		{
			get
			{
				return CraftingUi.SortModeButtonGroup;
			}
			set
			{
				CraftingUi.SortModeButtonGroup = value;
			}
		}

		private static RectTransform? _craftingControlsBackground
		{
			get
			{
				return CraftingUi.ControlsBackground;
			}
			set
			{
				CraftingUi.ControlsBackground = value;
			}
		}

		private static RectTransformSnapshot? _craftingPanelRootSnapshot
		{
			get
			{
				return CraftingUi.PanelRootSnapshot;
			}
			set
			{
				CraftingUi.PanelRootSnapshot = value;
			}
		}

		private static Vector2 _craftingPanelOriginalSizeDelta
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				return CraftingUi.PanelOriginalSizeDelta;
			}
			set
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				CraftingUi.PanelOriginalSizeDelta = value;
			}
		}

		private static int _craftingRecipePage
		{
			get
			{
				return CraftingGrid.RecipePage;
			}
			set
			{
				CraftingGrid.RecipePage = value;
			}
		}

		private static GameObject? _inventoryHoverTooltip
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltip;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltip = value;
			}
		}

		private static RectTransform? _inventoryHoverTooltipPanel
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipPanel;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipPanel = value;
			}
		}

		private static TMP_Text? _inventoryHoverTooltipTopic
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipTopic;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipTopic = value;
			}
		}

		private static TMP_Text? _inventoryHoverTooltipText
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipText;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipText = value;
			}
		}

		private static ScrollableTooltipBodyState InventoryHoverTooltipTextScroll => InventoryHoverTooltipRuntime.HoverTooltipTextScroll;

		private static TooltipSourceCacheCore<UITooltip, InventoryHoverTooltipItemSource> InventoryHoverTooltipItems => InventoryHoverTooltipRuntime.HoverTooltipItems;

		private static string _inventoryHoverTooltipSignature
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipSignature;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipSignature = value;
			}
		}

		private static string _inventoryHoverTooltipLayoutSignature
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipLayoutSignature;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipLayoutSignature = value;
			}
		}

		private static float _inventoryHoverTooltipScrollOffset
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipScrollOffset;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipScrollOffset = value;
			}
		}

		private static float _inventoryHoverTooltipMaxScroll
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipMaxScroll;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipMaxScroll = value;
			}
		}

		private static bool _inventoryHoverTooltipNeedsScroll
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverTooltipNeedsScroll;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverTooltipNeedsScroll = value;
			}
		}

		private static RectTransform? _inventoryHoverJewelcraftingTooltipRoot
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverJewelcraftingTooltipRoot;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverJewelcraftingTooltipRoot = value;
			}
		}

		private static string _inventoryHoverJewelcraftingTooltipSignature
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverJewelcraftingTooltipSignature;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverJewelcraftingTooltipSignature = value;
			}
		}

		private static int _inventoryHoverJewelcraftingTooltipLayoutRefreshFrames
		{
			get
			{
				return InventoryHoverTooltipRuntime.HoverJewelcraftingTooltipLayoutRefreshFrames;
			}
			set
			{
				InventoryHoverTooltipRuntime.HoverJewelcraftingTooltipLayoutRefreshFrames = value;
			}
		}

		private static GameObject? _inventorySimpleNameTooltip
		{
			get
			{
				return InventoryHoverTooltipRuntime.SimpleNameTooltip;
			}
			set
			{
				InventoryHoverTooltipRuntime.SimpleNameTooltip = value;
			}
		}

		private static RectTransform? _inventorySimpleNameTooltipRect
		{
			get
			{
				return InventoryHoverTooltipRuntime.SimpleNameTooltipRect;
			}
			set
			{
				InventoryHoverTooltipRuntime.SimpleNameTooltipRect = value;
			}
		}

		private static TMP_Text? _inventorySimpleNameTooltipText
		{
			get
			{
				return InventoryHoverTooltipRuntime.SimpleNameTooltipText;
			}
			set
			{
				InventoryHoverTooltipRuntime.SimpleNameTooltipText = value;
			}
		}

		private static string _inventorySimpleNameTooltipValue
		{
			get
			{
				return InventoryHoverTooltipRuntime.SimpleNameTooltipValue;
			}
			set
			{
				InventoryHoverTooltipRuntime.SimpleNameTooltipValue = value;
			}
		}

		private static SimpleNameTooltipPlacement _inventorySimpleNameTooltipPlacement
		{
			get
			{
				return InventoryHoverTooltipRuntime.SimpleNameTooltipPlacement;
			}
			set
			{
				InventoryHoverTooltipRuntime.SimpleNameTooltipPlacement = value;
			}
		}

		private static SimpleTooltipOwnershipCore InventorySimpleNameTooltipOwner => InventoryHoverTooltipRuntime.SimpleNameTooltipOwner;

		private static object InventorySimpleNameTooltipFallbackOwner => InventoryHoverTooltipRuntime.SimpleNameTooltipFallbackOwner;

		private static object? _pinnedGemNameTooltipOwner
		{
			get
			{
				return InventoryHoverTooltipRuntime.PinnedGemNameTooltipOwner;
			}
			set
			{
				InventoryHoverTooltipRuntime.PinnedGemNameTooltipOwner = value;
			}
		}

		private static float _pinnedGemNameTooltipHoldUntil
		{
			get
			{
				return InventoryHoverTooltipRuntime.PinnedGemNameTooltipHoldUntil;
			}
			set
			{
				InventoryHoverTooltipRuntime.PinnedGemNameTooltipHoldUntil = value;
			}
		}

		private static UITooltip? _inventoryContainerHoverTooltipSource
		{
			get
			{
				return InventoryHoverTooltipRuntime.ContainerHoverTooltipSource;
			}
			set
			{
				InventoryHoverTooltipRuntime.ContainerHoverTooltipSource = value;
			}
		}

		private static UITooltip? _inventorySlotsOwnedHoverTooltipSource
		{
			get
			{
				return InventoryHoverTooltipRuntime.OwnedHoverTooltipSource;
			}
			set
			{
				InventoryHoverTooltipRuntime.OwnedHoverTooltipSource = value;
			}
		}

		private static bool _tooltipLateUpdateExceptionLogged
		{
			get
			{
				return InventoryHoverTooltipRuntime.LateUpdateExceptionLogged;
			}
			set
			{
				InventoryHoverTooltipRuntime.LateUpdateExceptionLogged = value;
			}
		}

		private static List<SlotDefinition> SlotDefinitions => InventoryDefinitions.SlotDefinitions;

		private static Dictionary<string, List<string>> PredefinedGroupDefinitions => InventoryDefinitions.PredefinedGroupDefinitions;

		private static List<string> PredefinedGroupOrder => InventoryDefinitions.PredefinedGroupOrder;

		private static Dictionary<string, List<string>> PredefinedGroupOrders => InventoryDefinitions.PredefinedGroupOrders;

		private static Dictionary<string, int> InventoryLimits => InventoryDefinitions.InventoryLimits;

		private static Dictionary<string, int> ResourceTierByToken => InventoryDefinitions.ResourceTierByToken;

		private static HashSet<string> CookingStationInputTokens => InventoryDefinitions.CookingStationInputTokens;

		private static HashSet<string> CraftingRecipeFoodInputTokens => InventoryDefinitions.CraftingRecipeFoodInputTokens;

		private static HashSet<string> CookingStationFoodInputTokens => InventoryDefinitions.CookingStationFoodInputTokens;

		private static HashSet<string> FermenterInputTokens => InventoryDefinitions.FermenterInputTokens;

		private static HashSet<string> FermenterOutputTokens => InventoryDefinitions.FermenterOutputTokens;

		private static HashSet<string> FermenterFoodInputTokens => InventoryDefinitions.FermenterFoodInputTokens;

		private static Dictionary<string, string> ItemNameTokens => InventoryDefinitions.ItemNameTokens;

		private static HashSet<Vector2i> FavoriteSlots => InventoryClient.FavoriteSlots;

		internal static bool IsCompletingSlotUnequip => InventorySafety.SlotUnequipInProgress;

		internal static bool IsHandlingSlotDropOutside => InventorySafety.HandlingSlotDropOutside;

		internal static IReadOnlyList<SlotDefinition> Slots => SlotDefinitions;

		internal static bool IsDedicatedServer
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				if ((int)SystemInfo.graphicsDeviceType != 4)
				{
					if (Application.isBatchMode)
					{
						return string.Equals(Paths.ProcessName, "valheim_server", StringComparison.OrdinalIgnoreCase);
					}
					return false;
				}
				return true;
			}
		}

		private static string ConfigDirectoryPath => Path.Combine(Paths.ConfigPath, "InventorySlots");

		private static string YamlFilePath => Path.Combine(ConfigDirectoryPath, "InventorySlots.yml");

		private static string ResourceMapFilePath => Path.Combine(ConfigDirectoryPath, "ResourceMap.yml");

		private static string ClientStateFilePath => Path.Combine(ConfigDirectoryPath, "ClientState.yml");

		internal static string DefaultYaml => DefaultYamlResource.Value;

		internal static string DefaultResourceMapYaml => DefaultResourceMapYamlResource.Value;

		private static int GetAzuCraftyBoxesAvailableCraftingRequirementAmount(Requirement requirement, string sharedName)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)requirement.m_resItem == (Object)null || !TryGetAzuCraftyBoxesApi(out AzuCraftyBoxesApi api) || api == null || api.ShouldPrevent())
			{
				return 0;
			}
			try
			{
				IEnumerable nearbyContainers = api.GetNearbyContainers(localPlayer, api.GetRange());
				if (nearbyContainers == null)
				{
					return 0;
				}
				string prefabNameForAzuCraftyBoxes = GetPrefabNameForAzuCraftyBoxes(((Object)requirement.m_resItem).name);
				bool leaveOne = api.GetLeaveOne();
				int num = 0;
				foreach (object item in nearbyContainers)
				{
					if (item == null)
					{
						continue;
					}
					string text = api.InvokeString(item, "GetPrefabName");
					if (!string.IsNullOrWhiteSpace(text) && api.CanItemBePulled(text, prefabNameForAzuCraftyBoxes))
					{
						int num2 = api.InvokeInt(item, "ItemCount", sharedName);
						if (leaveOne && num2 > 0)
						{
							num2--;
						}
						if (num2 > 0)
						{
							num += num2;
						}
					}
				}
				return num;
			}
			catch (Exception)
			{
				return 0;
			}
		}

		private static bool TryGetAzuCraftyBoxesApi(out AzuCraftyBoxesApi? api)
		{
			return TryGetCompatApi("Azumatt.AzuCraftyBoxes", "AzuCraftyBoxes", CompatRuntime.AzuCraftyBoxes, AzuCraftyBoxesApi.TryCreate, "AzuCraftyBoxes compatibility disabled", out api);
		}

		private static bool TryGetAzuCraftyBoxesRequirementFlashColor(out Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			color = default(Color);
			if (!TryGetAzuCraftyBoxesApi(out AzuCraftyBoxesApi api) || api == null || api.ShouldPrevent())
			{
				return false;
			}
			return api.TryGetRequirementFlashColor(out color);
		}

		private static string GetPrefabNameForAzuCraftyBoxes(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return "";
			}
			int num = name.IndexOfAny(new char[2] { '(', ' ' });
			if (num < 0)
			{
				return name;
			}
			return name.Substring(0, num);
		}

		private static void InitializeBackpackCompatibility()
		{
			if (!_adventureBackpacksPatchesApplied && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) && api != null)
			{
				api.ApplyPatches(_instance._harmony);
				_adventureBackpacksPatchesApplied = true;
			}
			TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi _);
			TryGetRustyBagsApi(out RustyBagsApi _);
		}

		private static bool TryAddBackpackCompatSlot(YamlSlot slot, string id)
		{
			return NormalizeSlotId(id) switch
			{
				"adventurebackpacks.backpack" => TryAddAdventureBackpackSlot(slot), 
				"smoothbrainbackpacks.backpack" => TryAddSmoothbrainBackpackSlot(slot), 
				"rustybags.bag" => TryAddRustyBagSlot(slot), 
				"rustybags.quiver" => TryAddRustyQuiverSlot(slot), 
				_ => false, 
			};
		}

		private static bool TryAddAdventureBackpackSlot(YamlSlot slot)
		{
			AdventureBackpacksApi api;
			bool hasApi = TryGetAdventureBackpacksApi(out api) && api != null;
			return TryAddBackpackCompatSlot(slot, "adventurebackpacks.backpack", "Backpack", hasApi, (ItemData? item) => IsAdventureBackpackItem(item));
		}

		private static bool TryAddSmoothbrainBackpackSlot(YamlSlot slot)
		{
			SmoothbrainBackpacksApi api;
			bool hasApi = TryGetSmoothbrainBackpacksApi(out api) && api != null;
			return TryAddBackpackCompatSlot(slot, "smoothbrainbackpacks.backpack", "Backpack", hasApi, (ItemData? item) => IsSmoothbrainBackpackItem(item));
		}

		private static bool TryAddRustyBagSlot(YamlSlot slot)
		{
			RustyBagsApi api;
			bool hasApi = TryGetRustyBagsApi(out api) && api != null;
			return TryAddBackpackCompatSlot(slot, "rustybags.bag", "Bag", hasApi, (ItemData? item) => IsRustyBagItem(item));
		}

		private static bool TryAddRustyQuiverSlot(YamlSlot slot)
		{
			RustyBagsApi api;
			bool hasApi = TryGetRustyBagsApi(out api) && api != null;
			return TryAddBackpackCompatSlot(slot, "rustybags.quiver", "Quiver", hasApi, (ItemData? item) => IsRustyQuiverItem(item));
		}

		private static bool TryAddBackpackCompatSlot(YamlSlot slot, string id, string fallbackName, bool hasApi, Func<ItemData?, bool> accepts)
		{
			if (SlotDefinitions.Any((SlotDefinition existing) => existing.Id == id))
			{
				return true;
			}
			List<string> items = GetSlotItems(slot);
			if (!hasApi && items.Count == 0)
			{
				return true;
			}
			string name = (string.IsNullOrWhiteSpace(slot.Name) ? fallbackName : slot.Name.Trim());
			SlotDefinitions.Add(new SlotDefinition(id, name, SlotKind.CustomEquipment, (ItemData? item) => accepts(item) || (items.Count > 0 && ItemMatchesSlotItems(item, items))));
			return true;
		}

		private static bool IsAdventureBackpackItem(ItemData? item)
		{
			if (item != null && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) && api != null)
			{
				return api.IsBackpack(item);
			}
			return false;
		}

		private static bool IsSmoothbrainBackpackItem(ItemData? item)
		{
			if (item != null && TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi api) && api != null)
			{
				return api.IsBackpack(item);
			}
			return false;
		}

		private static bool IsRustyBagItem(ItemData? item)
		{
			if (item != null && TryGetRustyBagsApi(out RustyBagsApi api) && api != null && api.IsBag(item))
			{
				return !api.IsQuiver(item);
			}
			return false;
		}

		private static bool IsRustyQuiverItem(ItemData? item)
		{
			if (item != null && TryGetRustyBagsApi(out RustyBagsApi api) && api != null)
			{
				return api.IsQuiver(item);
			}
			return false;
		}

		private static void SyncBackpackCompatState(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				SyncAdventureBackpackCompatState(player);
				SyncSmoothbrainBackpackCompatState(player);
				SyncRustyBagsCompatState(player);
			}
		}

		private static void OnCustomEquipmentCompatEquipped(Player player, ItemData item)
		{
			if ((Object)(object)player == (Object)null || item == null)
			{
				return;
			}
			if (IsAdventureBackpackItem(item) && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) && api != null)
			{
				if (_lastAdventureBackpackCompatItem != item || !api.IsBackpackEquippedFlagSet())
				{
					api.OnCustomBackpackEquipped(player, item);
				}
				_lastAdventureBackpackCompatItem = item;
			}
			if (IsSmoothbrainBackpackItem(item) && TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi api2) && api2 != null)
			{
				api2.SyncEquippedBackpack(player, item);
				_lastSmoothbrainBackpackCompatItem = item;
			}
			if (TryGetRustyBagsApi(out RustyBagsApi api3) && api3 != null)
			{
				if (IsRustyBagItem(item))
				{
					api3.SyncBag(player, item);
					_lastRustyBagCompatItem = item;
				}
				else if (IsRustyQuiverItem(item))
				{
					api3.SyncQuiver(player, item);
					_lastRustyQuiverCompatItem = item;
				}
			}
			OnMagicSupremacyBeltEquipped(player, item);
		}

		private static void OnCustomEquipmentCompatUnequipping(Player? player, ItemData item)
		{
			if (player == null)
			{
				player = Player.m_localPlayer;
			}
			if ((Object)(object)player == (Object)null || item == null)
			{
				return;
			}
			if ((_lastAdventureBackpackCompatItem == item || IsAdventureBackpackItem(item)) && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) && api != null)
			{
				api.OnCustomBackpackUnequipping(player, item);
				if (_lastAdventureBackpackCompatItem == item)
				{
					_lastAdventureBackpackCompatItem = null;
				}
			}
			if ((_lastSmoothbrainBackpackCompatItem == item || IsSmoothbrainBackpackItem(item)) && TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi api2) && api2 != null)
			{
				api2.SyncEquippedBackpack(player, null);
				if (_lastSmoothbrainBackpackCompatItem == item)
				{
					_lastSmoothbrainBackpackCompatItem = null;
				}
			}
			if (TryGetRustyBagsApi(out RustyBagsApi api3) && api3 != null)
			{
				if (_lastRustyBagCompatItem == item || IsRustyBagItem(item))
				{
					api3.ClearBagIfCurrent(player, item);
					if (_lastRustyBagCompatItem == item)
					{
						_lastRustyBagCompatItem = null;
					}
				}
				if (_lastRustyQuiverCompatItem == item || IsRustyQuiverItem(item))
				{
					api3.ClearQuiverIfCurrent(player, item);
					if (_lastRustyQuiverCompatItem == item)
					{
						_lastRustyQuiverCompatItem = null;
					}
				}
			}
			OnMagicSupremacyBeltUnequipping(player, item);
		}

		private static void SyncAdventureBackpackCompatState(Player player)
		{
			if (!TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) || api == null)
			{
				_lastAdventureBackpackCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsAdventureBackpackItem);
			if (val != _lastAdventureBackpackCompatItem)
			{
				if (_lastAdventureBackpackCompatItem != null)
				{
					api.OnCustomBackpackUnequipping(player, _lastAdventureBackpackCompatItem);
				}
				_lastAdventureBackpackCompatItem = val;
				if (val != null)
				{
					api.OnCustomBackpackEquipped(player, val);
				}
			}
			else if (val != null && !api.IsBackpackEquippedFlagSet())
			{
				api.OnCustomBackpackEquipped(player, val);
			}
		}

		private static void SyncSmoothbrainBackpackCompatState(Player player)
		{
			if (!TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi api) || api == null)
			{
				_lastSmoothbrainBackpackCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsSmoothbrainBackpackItem);
			api.SyncEquippedBackpack(player, val);
			_lastSmoothbrainBackpackCompatItem = val;
		}

		private static void SyncRustyBagsCompatState(Player player)
		{
			if (!TryGetRustyBagsApi(out RustyBagsApi api) || api == null)
			{
				_lastRustyBagCompatItem = null;
				_lastRustyQuiverCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsRustyBagItem);
			ItemData val2 = FindCustomEquippedItem(player, IsRustyQuiverItem);
			api.SyncBag(player, val);
			api.SyncQuiver(player, val2);
			_lastRustyBagCompatItem = val;
			_lastRustyQuiverCompatItem = val2;
		}

		private static ItemData? FindCustomEquippedItem(Player player, Func<ItemData?, bool> predicate)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			return ((IEnumerable<ItemData>)GetCustomEquippedItems(player)).FirstOrDefault((Func<ItemData, bool>)((ItemData item) => item != null && predicate(item)));
		}

		private static bool TryGetAdventureBackpacksApi(out AdventureBackpacksApi? api)
		{
			return TryGetCompatApi("vapok.mods.adventurebackpacks", "AdventureBackpacks", CompatRuntime.AdventureBackpacks, AdventureBackpacksApi.TryCreate, "AdventureBackpacks compatibility disabled", out api);
		}

		private static bool TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.backpacks", "Smoothbrain Backpacks", CompatRuntime.SmoothbrainBackpacks, SmoothbrainBackpacksApi.TryCreate, "Smoothbrain Backpacks compatibility disabled", out api);
		}

		private static bool TryGetRustyBagsApi(out RustyBagsApi? api)
		{
			return TryGetCompatApi("RustyMods.RustyBags", "RustyBags", CompatRuntime.RustyBags, RustyBagsApi.TryCreate, "RustyBags compatibility disabled", out api);
		}

		private static void AdventureBackpackIsBackpackEquippedPostfix(Player player, ref bool __result)
		{
			if (!__result && (Object)(object)player != (Object)null && FindCustomEquippedItem(player, IsAdventureBackpackItem) != null)
			{
				__result = true;
			}
		}

		private static void AdventureBackpackIsThisBackpackEquippedPostfix(Player player, ItemData itemData, ref bool __result)
		{
			if (!__result && !((Object)(object)player == (Object)null) && itemData != null && IsAdventureBackpackItem(itemData))
			{
				__result = GetCustomEquippedItems(player).Any((ItemData item) => item == itemData);
			}
		}

		private static void AdventureBackpackGetEquippedBackpackPrefix(Player player, ref ItemData? __state)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			__state = ((Humanoid)player).m_shoulderItem;
			if (!IsAdventureBackpackItem(((Humanoid)player).m_shoulderItem))
			{
				ItemData val = FindCustomEquippedItem(player, IsAdventureBackpackItem);
				if (val != null)
				{
					((Humanoid)player).m_shoulderItem = val;
				}
			}
		}

		private static void AdventureBackpackGetEquippedBackpackPostfix(Player player, ItemData? __state)
		{
			if ((Object)(object)player != (Object)null)
			{
				((Humanoid)player).m_shoulderItem = __state;
			}
		}

		private static bool IsBetterArcheryQuiverCell(Vector2i pos, bool includeRestockableSlots)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetBetterArcheryQuiverApi(out BetterArcheryQuiverApi api) || api == null)
			{
				return false;
			}
			try
			{
				return api.IsQuiverCell(pos, includeRestockableSlots);
			}
			catch (Exception ex)
			{
				return MarkCompatReflectionFailed(CompatRuntime.BetterArcheryQuiver, ex.Message, "BetterArchery quiver compatibility disabled");
			}
		}

		private static bool TryGetBetterArcheryQuiverApi(out BetterArcheryQuiverApi? api)
		{
			return TryGetCompatApi("ishid4.mods.betterarchery", "BetterArchery quiver", CompatRuntime.BetterArcheryQuiver, BetterArcheryQuiverApi.TryCreate, "BetterArchery quiver compatibility disabled", out api);
		}

		private static bool TryGetCompatApi<TApi>(string guid, string capability, CompatApiRuntimeState<TApi> runtime, CompatApiFactory<TApi> factory, string warningPrefix, out TApi? api) where TApi : class
		{
			api = runtime.Api;
			if (api != null)
			{
				return true;
			}
			if (!TryGetCompatAssembly(guid, capability, runtime, out Assembly assembly))
			{
				api = null;
				return false;
			}
			try
			{
				if (!factory(assembly, out api, out var detail) || api == null)
				{
					runtime.ReflectionFailed = true;
					Log.LogWarning((object)(warningPrefix + ": " + detail + "."));
					return false;
				}
				runtime.Api = api;
				return true;
			}
			catch (Exception ex)
			{
				api = null;
				return MarkCompatReflectionFailed(runtime, ex.Message, warningPrefix);
			}
		}

		private static bool TryGetCompatAssembly<TApi>(string guid, string capability, CompatApiRuntimeState<TApi> runtime, out Assembly? assembly) where TApi : class
		{
			assembly = null;
			if (!HasPlugin(guid))
			{
				return false;
			}
			if (runtime.ReflectionFailed)
			{
				return false;
			}
			try
			{
				assembly = ((object)Chainloader.PluginInfos[guid].Instance).GetType().Assembly;
				return true;
			}
			catch (Exception ex)
			{
				return MarkCompatReflectionFailed(runtime, ex.Message, capability + " compatibility disabled");
			}
		}

		private static bool MarkCompatReflectionFailed<TApi>(CompatApiRuntimeState<TApi> runtime, string detail, string warningPrefix) where TApi : class
		{
			runtime.ReflectionFailed = true;
			Log.LogWarning((object)(warningPrefix + ": " + detail));
			return false;
		}

		private static bool GetCompatConfigEntryToggleOn(FieldInfo field, ref ConfigEntryBase? config)
		{
			try
			{
				if (config == null)
				{
					object? value = field.GetValue(null);
					config = (ConfigEntryBase?)((value is ConfigEntryBase) ? value : null);
				}
				ConfigEntryBase? obj = config;
				object obj2 = ((obj != null) ? obj.BoxedValue : null);
				return obj2 != null && (string.Equals(obj2.ToString(), Toggle.On.ToString(), StringComparison.OrdinalIgnoreCase) || string.Equals(obj2.ToString(), bool.TrueString, StringComparison.OrdinalIgnoreCase));
			}
			catch
			{
				return false;
			}
		}

		private static bool HasPlugin(string guid)
		{
			if (!string.IsNullOrWhiteSpace(guid))
			{
				return Chainloader.PluginInfos.ContainsKey(guid);
			}
			return false;
		}

		internal static bool TryGetCurrencyPocketOverlapDetectionMethod(out MethodBase? method)
		{
			method = null;
			if (!Chainloader.PluginInfos.TryGetValue("Azumatt.CurrencyPocket", out var value) || (Object)(object)value.Instance == (Object)null)
			{
				return false;
			}
			MethodInfo methodInfo = ((object)value.Instance).GetType().Assembly.GetType("CurrencyPocket.MiscFunctions")?.GetMethod("IsOverlappingUIModInstalled", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (methodInfo == null || methodInfo.ReturnType != typeof(bool))
			{
				return false;
			}
			method = methodInfo;
			return true;
		}

		private static bool CanHandleContainerRestock(Player player, Container container)
		{
			if ((Object)(object)player != (Object)null && !player.m_isLoading && (Object)(object)container != (Object)null && container.m_inventory != null && CanHandleContainerAreaAction(player, container))
			{
				return HasContainerPlayerAccess(player, container, flashGuardStone: false);
			}
			return false;
		}

		private static bool IsAreaContainerAllowed(Player player, Container container, Container? currentContainer, Vector3 playerPosition, float rangeSq, bool includeBuiltInRemote, out float distanceSq)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (!IsAreaContainerCandidate(player, container, currentContainer, playerPosition, rangeSq, out distanceSq) || !HasContainerPlayerAccess(player, container, flashGuardStone: true))
			{
				return false;
			}
			ContainerAccessMode containerAccessMode = GetContainerAccessMode(container);
			bool num = containerAccessMode == ContainerAccessMode.DirectOwner;
			bool flag = includeBuiltInRemote && containerAccessMode == ContainerAccessMode.MultiUserChestRemote && CanUseBuiltInRemoteAreaContainer(player, container);
			if (!num && !flag)
			{
				return false;
			}
			if ((Object)(object)container.m_piece != (Object)null && !container.m_piece.IsPlacedByPlayer())
			{
				return false;
			}
			if (flag)
			{
				return true;
			}
			if (!HasExternalMultiUserChestActive && (!IsBuiltInMultiUserChestEnabled || !IsBuiltInMultiUserContainerEligible(container)))
			{
				return !IsContainerInUse(container);
			}
			return true;
		}

		private static bool IsAreaContainerCandidate(Player player, Container container, Container? currentContainer, Vector3 playerPosition, float rangeSq, out float distanceSq)
		{
			//IL_0043: 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_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)
			distanceSq = float.MaxValue;
			if ((Object)(object)player == (Object)null || (Object)(object)container == (Object)null || (Object)(object)container == (Object)(object)currentContainer || container.m_inventory == null || (Object)(object)container.m_nview == (Object)null)
			{
				return false;
			}
			Vector3 val = ((Component)container).transform.position - playerPosition;
			distanceSq = ((Vector3)(ref val)).sqrMagnitude;
			if (distanceSq > rangeSq)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponent<TombStone>() == (Object)null && (Object)(object)((Component)container).GetComponentInParent<TombStone>() == (Object)null && (Object)(object)((Component)container.m_nview).GetComponent<Player>() == (Object)null)
			{
				return (Object)(object)((Component)((Component)container).transform.root).GetComponentInChildren<Ship>() == (Object)null;
			}
			return false;
		}

		private static bool HasContainerPlayerAccess(Player player, Container container, bool flashGuardStone)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)container == (Object)null)
			{
				return false;
			}
			if (container.m_checkGuardStone && !PrivateArea.CheckAccess(((Component)container).transform.position, 0f, flashGuardStone, false))
			{
				return false;
			}
			return container.CheckAccess(player.GetPlayerID());
		}

		private static bool IsContainerInUse(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return true;
			}
			if (container.IsInUse() || ((Object)(object)container.m_wagon != (Object)null && container.m_wagon.InUse()))
			{
				return true;
			}
			ZDO val = (((Object)(object)container.m_nview != (Object)null) ? container.m_nview.GetZDO() : null);
			if (val != null)
			{
				return val.GetInt("InUse", 0) == 1;
			}
			return false;
		}

		private static ContainerAccessMode GetContainerAccessMode(Container container, bool allowLocalWithoutZNetView = false)
		{
			if ((Object)(object)container == (Object)null)
			{
				return ContainerAccessMode.Unavailable;
			}
			if ((Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				if (!allowLocalWithoutZNetView)
				{
					return ContainerAccessMode.Unavailable;
				}
				return ContainerAccessMode.DirectOwner;
			}
			if (container.m_nview.IsOwner())
			{
				return ContainerAccessMode.DirectOwner;
			}
			if (!CanUseMultiUserChestRemote(container))
			{
				return ContainerAccessMode.Unavailable;
			}
			return ContainerAccessMode.MultiUserChestRemote;
		}

		private static bool CanMutateContainerDirectly(Container container, bool allowLocalWithoutZNetView = false)
		{
			return GetContainerAccessMode(container, allowLocalWithoutZNetView) == ContainerAccessMode.DirectOwner;
		}

		private static bool CanHandleContainerAreaAction(Player player, Container container)
		{
			return GetContainerAccessMode(container, (Object)(object)container.m_nview == (Object)null) switch
			{
				ContainerAccessMode.MultiUserChestRemote => CanUseBuiltInRemoteAreaContainer(player, container), 
				ContainerAccessMode.DirectOwner => true, 
				_ => false, 
			};
		}

		private static bool CanUseBuiltInRemoteAreaContainer(Player player, Container container)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)container == (Object)null || !IsBuiltInMultiUserChestEnabled || !IsBuiltInMultiUserContainerEligible(container))
			{
				return false;
			}
			float num = 10f;
			Vector3 val = ((Component)player).transform.position - ((Component)container).transform.position;
			return ((Vector3)(ref val)).sqrMagnitude <= num * num;
		}

		private static bool CanProcessContainerSortRpc(Container container, long sender, long requesterPlayerId)
		{
			if (sender != 0L && requesterPlayerId != 0L && CanUseMultiUserChestRemote(container) && IsRpcSenderForPlayer(sender, requesterPlayerId) && CanMutateContainerDirectly(container))
			{
				return container.CheckAccess(requesterPlayerId);
			}
			return false;
		}

		private static bool CanUseMultiUserChestRemote(Container container)
		{
			if ((Object)(object)container == (Object)null || IsMultiUserChestIgnored(container))
			{
				return false;
			}
			if (!HasExternalMultiUserChestActive)
			{
				if (IsBuiltInMultiUserChestEnabled)
				{
					return IsBuiltInMultiUserContainerEligible(container);
				}
				return false;
			}
			return true;
		}

		private static bool IsRpcSenderForPlayer(long sender, long requesterPlayerId)
		{
			Player requester;
			return TryGetRpcSenderPlayer(sender, requesterPlayerId, out requester);
		}

		private static bool TryGetRpcSenderPlayer(long sender, long requesterPlayerId, out Player? requester)
		{
			requester = null;
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (!((Object)(object)allPlayer == (Object)null) && allPlayer.GetPlayerID() == requesterPlayerId && !((Object)(object)((Character)allPlayer).m_nview == (Object)null) && ((Character)allPlayer).m_nview.IsValid())
				{
					ZDO zDO = ((Character)allPlayer).m_nview.GetZDO();
					if (zDO != null && zDO.GetOwner() == sender)
					{
						requester = allPlayer;
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsMultiUserChestIgnored(Container container)
		{
			ZDO val = (((Object)(object)container?.m_nview != (Object)null) ? container.m_nview.GetZDO() : null);
			if (val != null)
			{
				return val.GetBool("MUC_Ignore", false);
			}
			return false;
		}

		private static List<Container> GetActionContainers(Player player, Container currentContainer, bool areaForQuickStack, bool includeBuiltInRemote = false)
		{
			//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_00ee: Unknown result type (might be due to invalid IL or missing references)
			List<Container> list = new List<Container>();
			HashSet<Container> hashSet = new HashSet<Container>();
			if ((Object)(object)currentContainer != (Object)null && currentContainer.m_inventory != null && hashSet.Add(currentContainer))
			{
				list.Add(currentContainer);
			}
			float num = ((!areaForQuickStack) ? (_areaRestockRange?.Value ?? 0f) : (_areaQuickStackRange?.Value ?? 0f));
			if (num <= 0f)
			{
				return list;
			}
			if ((Object)(object)currentContainer == (Object)null || IsUnityNull((Object?)(object)currentContainer))
			{
				return list;
			}
			Vector3 position = ((Component)currentContainer).transform.position;
			float rangeSq = num * num;
			List<(Container, float)> list2 = new List<(Container, float)>();
			for (int num2 = InventoryContainers.KnownContainers.Count - 1; num2 >= 0; num2--)
			{
				Container val = InventoryContainers.KnownContainers[num2];
				float distanceSq;
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
				{
					InventoryContainers.KnownContainers.RemoveAt(num2);
				}
				else if (!hashSet.Contains(val) && IsAreaContainerAllowed(player, val, currentContainer, position, rangeSq, includeBuiltInRemote, out distanceSq))
				{
					list2.Add((val, distanceSq));
					hashSet.Add(val);
				}
			}
			list2.Sort(delegate((Container Container, float DistanceSq) left, (Container Container, float DistanceSq) right)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				int num3 = left.DistanceSq.CompareTo(right.DistanceSq);
				if (num3 != 0)
				{
					return num3;
				}
				ZNetView nview = left.Container.m_nview;
				ZDO val2 = ((nview != null) ? nview.GetZDO() : null);
				ZNetView nview2 = right.Container.m_nview;
				ZDO val3 = ((nview2 != null) ? nview2.GetZDO() : null);
				return (val2 != null && val3 != null) ? ((ZDOID)(ref val2.m_uid)).CompareTo(val3.m_uid) : 0;
			});
			foreach (var item2 in list2)
			{
				Container item = item2.Item1;
				list.Add(item);
			}
			return list;
		}

		private static int RunContainerTransferAcrossContainers(Player localPlayer, Container anchorContainer, bool includeArea, bool areaForQuickStack, Func<Container, int> transfer, Action onMoved)
		{
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)anchorContainer == (Object)null || transfer == null)
			{
				return 0;
			}
			int vfxLimit = ((includeArea && IsContainerActionSuccessFxEnabled()) ? 10 : 0);
			int changedContainerVfxCount = 0;
			return ContainerTransferCore.Run((IEnumerable<Container?>?)(includeArea ? ((IList)GetActionContainers(localPlayer, anchorContainer, areaForQuickStack)) : ((IList)new List<Container> { anchorContainer })), (Container container) => !IsUnityNull((Object?)(object)container) && container.m_inventory != null, transfer, delegate(Container container, int _)
			{
				changedContainerVfxCount = TryPlayChangedContainerActionSuccessVfx(container, vfxLimit, changedContainerVfxCount);
			}, delegate
			{
				onMoved?.Invoke();
				if (vfxLimit > 0)
				{
					PlayContainerActionSuccessSfx(anchorContainer);
				}
			});
		}

		private static void ShowContainerActionResult(Player player, string actionToken, string actionFallback, int moved)
		{
			if (!((Object)(object)player == (Object)null))
			{
				string newValue = LocalizeUi(actionToken, actionFallback);
				string text = LocalizeUi("$inventoryslots_action_result_format", "{action}: {count}").Replace("{action}", newValue).Replace("{count}", moved.ToString());
				((Character)player).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static List<Vector2i> GetPlayerActionSlots(Player player, Inventory inventory, bool includeHotbar, bool blockFavorites = false)
		{
			//IL_003d: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2i> list = new List<Vector2i>();
			int num = Math.Min(GetFixedRegularRows(), inventory.GetHeight());
			HashSet<Vector2i> hashSet = (blockFavorites ? GetFavoriteBlockedSlots(player, inventory) : new HashSet<Vector2i>());
			Vector2i val = default(Vector2i);
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					((Vector2i)(ref val))..ctor(j, i);
					if (!hashSet.Contains(val) && InventoryActionCellPolicyCore.CanUseContainerActionSource(GetInventoryCellKind(player, inventory, val), includeHotbar))
					{
						list.Add(val);
					}
				}
			}
			return list;
		}

		private static HashSet<Vector2i> GetFavoriteBlockedSlots(Player player, Inventory inventory)
		{
			//IL_0036: 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)
			HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
			EnsureFavoritesLoaded(player);
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item?.m_shared != null && FavoriteSlots.Contains(item.m_gridPos))
				{
					hashSet.Add(item.m_gridPos);
				}
			}
			return hashSet;
		}

		private static bool TryGetActionContext(Player? player, out Player localPlayer, out Inventory playerInventory, out Container container, out Inventory containerInventory)
		{
			localPlayer = null;
			playerInventory = null;
			container = null;
			containerInventory = null;
			if ((Object)(object)player == (Object)null || player.m_isLoading || (Object)(object)InventoryGui.instance == (Object)null)
			{
				return false;
			}
			if (IsMultiUserContainerAreaBatchActive())
			{
				ShowMultiUserContainerNotReady();
				return false;
			}
			Container currentContainer = InventoryGui.instance.m_currentContainer;
			if ((Object)(object)currentContainer == (Object)null || currentContainer.m_inventory == null)
			{
				return false;
			}
			if (!CanMutateContainerDirectly(currentContainer, allowLocalWithoutZNetView: true))
			{
				((Character)player).Message((MessageType)2, LocalizeUi("$inventoryslots_container_not_ready", "Container is not ready."), 0, (Sprite)null);
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			localPlayer = player;
			playerInventory = inventory;
			container = currentContainer;
			containerInventory = currentContainer.m_inventory;
			return true;
		}

		private static bool HasNoCustomData(ItemData item)
		{
			if (item.m_customData != null)
			{
				return item.m_customData.Count == 0;
			}
			return true;
		}

		private static bool CanUseContainerActionStacking(ItemData item)
		{
			if (item?.m_shared != null)
			{
				if (!HasNoCustomData(item))
				{
					return IsTrustedCustomDataStackingItem(item);
				}
				return true;
			}
			return false;
		}

		private static bool IsTrustedCustomDataStackingItem(ItemData? item)
		{
			if (!IsJewelcraftingOrbItem(item))
			{
				return IsEpicLootStackableMaterial(item);
			}
			return true;
		}

		private static bool IsJewelcraftingOrbItem(ItemData? item)
		{
			if (item?.m_shared == null || !HasPlugin("org.bepinex.plugins.jewelcrafting"))
			{
				return false;
			}
			string itemPrefabName = GetItemPrefabName(item);
			if (itemPrefabName.StartsWith("JC_Orb_", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string text = item.m_shared.m_name ?? "";
			if (!text.StartsWith("$jc_orb_", StringComparison.OrdinalIgnoreCase))
			{
				if (text.IndexOf("orb_of_", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return itemPrefabName.StartsWith("JC_", StringComparison.OrdinalIgnoreCase);
				}
				return false;
			}
			return true;
		}

		private static bool IsEpicLootStackableMaterial(ItemData? item)
		{
			if (item?.m_shared == null || !HasPlugin("randyknapp.mods.epicloot"))
			{
				return false;
			}
			if (IsEpicLootStackableMaterialToken(GetItemPrefabName(item)))
			{
				return true;
			}
			if (!IsUnityNull((Object?)(object)item.m_dropPrefab) && IsEpicLootStackableMaterialToken(((Object)item.m_dropPrefab).name))
			{
				return true;
			}
			return IsEpicLootStackableMaterialToken(item.m_shared.m_name ?? "");
		}

		private static bool IsEpicLootStackableMaterialToken(string token)
		{
			if (!token.StartsWith("Shard", StringComparison.OrdinalIgnoreCase) && !token.StartsWith("Essence", StringComparison.OrdinalIgnoreCase) && !token.StartsWith("Dust", StringComparison.OrdinalIgnoreCase))
			{
				return token.StartsWith("Reagent", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static int CountMovedFromContainerSource(Inventory sourceInventory, ItemData sourceItem, int before, int requestedAmount, bool moveSucceeded)
		{
			int after = (sourceInventory.m_inventory.Contains(sourceItem) ? sourceItem.m_stack : 0);
			return ContainerActionCore.CountMovedAmount(before, after, requestedAmount, moveSucceeded, useMoveSucceededFallback: false);
		}

		private static void RemoveItemIfStillOwned(Inventory inventory, ItemData item)
		{
			if (inventory != null && item != null && inventory.m_inventory.Contains(item))
			{
				inventory.RemoveItem(item);
			}
		}

		private static int CompareGridOrder(Vector2i a, Vector2i b)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return ContainerActionCore.CompareGridOrder(a.x, a.y, b.x, b.y);
		}

		private static bool IsContainerActionSuccessFxEnabled()
		{
			if (_containerActionSuccessFx != null)
			{
				return _containerActionSuccessFx.Value == Toggle.On;
			}
			return true;
		}

		private static void HandleContainerHoldHotkey(Player player, ContainerHoldActionState hold, TryGetContainerHoldContext tryGetContext, Func<Player, Container, bool> executeAction)
		{
			if (!tryGetContext(player, out var container))
			{
				ResetContainerHold(hold);
				return;
			}
			if (IsUnityNull((Object?)(object)hold.Container) || (Object)(object)hold.Container != (Object)(object)container)
			{
				hold.Container = container;
				hold.StartTime = Time.time;
				hold.Triggered = false;
			}
			if (!hold.Triggered && !(Time.time - hold.StartTime < 0.5f))
			{
				if (executeAction(player, container))
				{
					hold.Triggered = true;
				}
				else
				{
					ResetContainerHold(hold);
				}
			}
		}

		private static void ResetContainerHold(ContainerHoldActionState hold)
		{
			hold.Container = null;
			hold.StartTime = -1f;
			hold.Triggered = false;
		}

		private static int TryPlayChangedContainerActionSuccessVfx(Container container, int limit, int played)
		{
			if (limit <= 0 || played >= limit)
			{
				return played;
			}
			PlayContainerActionSuccessVfx(container);
			return played + 1;
		}

		private static void PlayContainerActionSuccessVfx(Container container)
		{
			//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)
			//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_0066: 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)
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("fx_HildirChest_Unlock");
			if ((Object)(object)prefab == (Object)null || IsUnityNull((Object?)(object)prefab))
			{
				return;
			}
			Vector3 position = ((Component)container).transform.position;
			Quaternion rotation = ((Component)container).transform.rotation;
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			GameObject val;
			try
			{
				ZNetView.m_forceDisableInit = true;
				val = Object.Instantiate<GameObject>(prefab, position, rotation);
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			Object.Destroy((Object)(object)val, 5f);
			ZSFX[] componentsInChildren = val.GetComponentsInChildren<ZSFX>(true);
			foreach (ZSFX val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					val2.Stop();
					((Component)val2).gameObject.SetActive(false);
				}
			}
		}

		private static void PlayContainerActionSuccessSfx(Container container)
		{
			//IL_0070: 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)
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("fx_HildirChest_Unlock");
			if (!((Object)(object)prefab == (Object)null) && !IsUnityNull((Object?)(object)prefab))
			{
				Transform val = prefab.transform.Find("SFX");
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					Object.Destroy((Object)(object)Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)container).transform.position, ((Component)container).transform.rotation), 5f);
				}
			}
		}

		internal static void OnRealInventoryGuiShown()
		{
			_containerPreviewRealGuiVisible = true;
			RestoreContainerPreviewUi();
			EndContainerPreview(InventoryGui.instance, keepRealGuiVisible: true);
		}

		internal static void BeforeRealInventoryGuiShown()
		{
			RestoreContainerPreviewUi();
		}

		internal static void OnInventoryGuiHidden()
		{
			_containerPreviewRealGuiVisible = false;
			EndContainerPreview(InventoryGui.instance, keepRealGuiVisible: false);
		}

		private static void ShutdownContainerPreview()
		{
			_containerPreviewRealGuiVisible = false;
			EndContainerPreview(InventoryGui.instance, keepRealGuiVisible: false);
			RestoreContainerPreviewUi();
		}

		internal static bool ShouldBlockContainerPreviewInteraction(InventoryGui? gui)
		{
			if ((Object)(object)gui != (Object)null && !IsUnityNull((Object?)(object)gui) && (Object)(object)gui == (Object)(object)InventoryGui.instance && !_containerPreviewRealGuiVisible)
			{
				if (!_containerPreviewActive && !_containerPreviewFrameOwned)
				{
					return _containerPreviewUiCaptured;
				}
				return true;
			}
			return false;
		}

		private static ContainerPreviewPhase GetContainerPreviewPhase()
		{
			if (_containerPreviewActive || _containerPreviewFrameOwned || (Object)(object)_containerPreviewTarget != (Object)null || _containerPreviewInventory != null || _containerPreviewRenderedInventory != null)
			{
				return ContainerPreviewPhase.PreviewVisible;
			}
			if (_containerPreviewRealGuiVisible)
			{
				return ContainerPreviewPhase.RealInventoryVisible;
			}
			if (!_containerPreviewUiCaptured)
			{
				return ContainerPreviewPhase.Hidden;
			}
			return ContainerPreviewPhase.RestorePending;
		}

		internal static void BeforeContainerPreviewGuiUpdate(InventoryGui gui)
		{
			_containerPreviewFrameOwned = false;
			if (IsDedicatedServer || (Object)(object)gui == (Object)null || IsUnityNull((Object?)(object)gui))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			bool inputBlocked = (Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || ShouldBlockGlobalHotkeys(localPlayer);
			if (_containerPreviewRealGuiVisible)
			{
				return;
			}
			if (!CanRunContainerPreview(localPlayer, inputBlocked))
			{
				EndContainerPreview(gui, keepRealGuiVisible: false);
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (TryGetContainerPreviewTarget(localPlayer, out Container container, out Inventory inventory))
			{
				_containerPreviewTarget = container;
				_containerPreviewInventory = inventory;
				_containerPreviewCloseAt = unscaledTime + Mathf.Max(0f, _containerPreviewCloseDelay.Value);
			}
			else
			{
				if (GetContainerPreviewPhase() == ContainerPreviewPhase.RestorePending)
				{
					return;
				}
				if (!_containerPreviewActive || _containerPreviewInventory == null || unscaledTime > _containerPreviewCloseAt || !IsContainerPreviewInventoryValid(_containerPreviewInventory, out var _, out var _))
				{
					EndContainerPreview(gui, keepRealGuiVisible: false);
					return;
				}
			}
			_containerPreviewFrameOwned = _containerPreviewInventory != null;
			if (_containerPreviewFrameOwned)
			{
				if ((Object)(object)gui.m_animator != (Object)null)
				{
					gui.m_animator.SetBool("visible", false);
				}
				CaptureAndHideContainerPreviewUi(gui);
			}
		}

		internal static void AfterContainerPreviewGuiUpdate(InventoryGui gui)
		{
			if (_containerPreviewFrameOwned && !_containerPreviewRealGuiVisible)
			{
				RenderContainerPreview(gui);
			}
		}

		private static bool CanRunContainerPreview(Player? player, bool inputBlocked)
		{
			if (_containerPreviewCloseDelay.Value <= 0f || inputBlocked || (Object)(object)player == (Object)null || IsUnityNull((Object?)(object)player) || player.m_isLoading || ((Character)player).IsDead() || ((Character)player).InCutscene() || ((Character)player).IsTeleporting())
			{
				return false;
			}
			if (!HasPlugin("com.maxsch.valheim.contentswithin"))
			{
				return true;
			}
			if (!_containerPreviewStandaloneWarningLogged)
			{
				_containerPreviewStandaloneWarningLogged = true;
				Log.LogWarning((object)"InventorySlots container preview is disabled because standalone ContentsWithin is installed.");
			}
			return false;
		}

		private static bool TryGetContainerPreviewTarget(Player player, out Container? container, out Inventory? inventory)
		{
			container = GetHoveredContainer(player);
			inventory = null;
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || !HasContainerPlayerAccess(player, container, flashGuardStone: false))
			{
				return false;
			}
			inventory = container.GetInventory();
			if (inventory == null || !IsContainerPreviewInventoryValid(inventory, out var _, out var _))
			{
				inventory = null;
				return false;
			}
			return true;
		}

		private static bool IsContainerPreviewInventoryValid(Inventory inventory, out int width, out int height)
		{
			width = ((inventory != null) ? inventory.GetWidth() : 0);
			height = ((inventory != null) ? inventory.GetHeight() : 0);
			if (inventory == null || width <= 0 || height <= 0 || (long)width * (long)height > int.MaxValue)
			{
				return false;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem == null || allItem.m_gridPos.x < 0 || allItem.m_gridPos.y < 0 || allItem.m_gridPos.x >= width || allItem.m_gridPos.y >= height)
				{
					return false;
				}
			}
			return true;
		}

		private static void RenderContainerPreview(InventoryGui gui)
		{
			Inventory containerPreviewInventory = _containerPreviewInventory;
			if (containerPreviewInventory == null || !IsContainerPreviewInventoryValid(containerPreviewInventory, out var width, out var height) || (Object)(object)gui.m_containerGrid == (Object)null || (Object)(object)gui.m_container == (Object)null)
			{
				EndContainerPreview(gui, keepRealGuiVisible: false);
				return;
			}
			try
			{
				CaptureAndHideContainerPreviewUi(gui);
				gui.m_animator.SetBool("visible", true);
				gui.m_hiddenFrames = 10;
				((Component)gui.m_container).gameObject.SetActive(true);
				InventoryGrid containerGrid = gui.m_containerGrid;
				containerGrid.m_inventory = containerPreviewInventory;
				containerGrid.m_selected.x = Mathf.Clamp(containerGrid.m_selected.x, 0, width - 1);
				containerGrid.m_selected.y = Mathf.Clamp(containerGrid.m_selected.y, 0, height - 1);
				int num = width * height;
				if (containerGrid.m_elements == null || containerGrid.m_elements.Count != num)
				{
					containerGrid.m_width = -1;
					containerGrid.m_height = -1;
				}
				containerGrid.UpdateGui((Player)null, (ItemData)null);
				if (_containerPreviewRenderedInventory != containerPreviewInventory || _containerPreviewRenderedWidth != width || _containerPreviewRenderedHeight != height)
				{
					containerGrid.ResetView();
					_containerPreviewRenderedInventory = containerPreviewInventory;
					_containerPreviewRenderedWidth = width;
					_containerPreviewRenderedHeight = height;
				}
				string name = containerPreviewInventory.GetName();
				gui.m_containerName.text = ((Localization.instance != null) ? Localization.instance.Localize(name) : name);
				gui.m_containerWeight.text = Mathf.CeilToInt(containerPreviewInventory.GetTotalWeight()).ToString();
				_containerPreviewActive = true;
			}
			catch (Exception exception)
			{
				LogContainerPreviewFailure(exception);
				EndContainerPreview(gui, keepRealGuiVisible: false);
			}
		}

		private static void CaptureAndHideContainerPreviewUi(InventoryGui gui)
		{
			if (!_containerPreviewUiCaptured)
			{
				ContainerPreviewHiddenObjects.Clear();
				_containerPreviewUiCaptured = true;
				RestoreContainerUiState();
				HideInventoryPinnedTooltips();
				HideInventoryOwnedHoverTooltips();
				ClearInventoryHoverTooltipSources();
			}
			CaptureAndHideContainerPreviewObject(((Object)(object)gui.m_player != (Object)null) ? ((Component)gui.m_player).gameObject : null);
			CaptureAndHideContainerPreviewObject(((Object)(object)gui.m_crafting != (Object)null) ? ((Component)gui.m_crafting).gameObject : null);
			CaptureAndHideContainerPreviewObject(((Object)(object)gui.m_info != (Object)null) ? ((Component)gui.m_info).gameObject : null);
			CaptureAndHideContainerPreviewObject(((Object)(object)gui.m_infoPanel != (Object)null) ? ((Component)gui.m_infoPanel).gameObject : null);
			CaptureAndHideContainerPreviewObject(((Object)(object)gui.m_takeAllButton != (Object)null) ? ((Component)gui.m_takeAllButton).gameObject : null);
			CaptureAndHideContainerPreviewObject(((Object)(object)gui.m_stackAllButton != (Object)null) ? ((Component)gui.m_stackAllButton).gameObject : null);
			Transform inventoryRoot = gui.m_inventoryRoot;
			object target;
			if (inventoryRoot == null)
			{
				target = null;
			}
			else
			{
				Transform obj = inventoryRoot.Find("Crafting");
				target = ((obj != null) ? ((Component)obj).gameObject : null);
			}
			CaptureAndHideContainerPreviewObject((GameObject?)target);
			Transform inventoryRoot2 = gui.m_inventoryRoot;
			object target2;
			if (inventoryRoot2 == null)
			{
				target2 = null;
			}
			else
			{
				Transform obj2 = inventoryRoot2.Find("RightPanel");
				target2 = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			}
			CaptureAndHideContainerPreviewObject((GameObject?)target2);
			HideInventoryActionPanels();
		}

		private static void CaptureAndHideContainerPreviewObject(GameObject? target)
		{
			if (!((Object)(object)target == (Object)null) && !IsUnityNull((Object?)(object)target))
			{
				if (!ContainerPreviewHiddenObjects.ContainsKey(target))
				{
					ContainerPreviewHiddenObjects.Add(target, target.activeSelf);
				}
				if (target.activeSelf)
				{
					target.SetActive(false);
				}
			}
		}

		private static void EndContainerPreview(InventoryGui? gui, bool keepRealGuiVisible)
		{
			if (GetContainerPreviewPhase() != ContainerPreviewPhase.PreviewVisible)
			{
				return;
			}
			_containerPreviewFrameOwned = false;
			_containerPreviewActive = false;
			_containerPreviewTarget = null;
			_containerPreviewInventory = null;
			_containerPreviewRenderedInventory = null;
			_containerPreviewRenderedWidth = -1;
			_containerPreviewRenderedHeight = -1;
			_containerPreviewCloseAt = 0f;
			if (!((Object)(object)gui == (Object)null) && !IsUnityNull((Object?)(object)gui))
			{
				if (!keepRealGuiVisible && (Object)(object)gui.m_animator != (Object)null)
				{
					gui.m_animator.SetBool("visible", false);
				}
				if (keepRealGuiVisible && (Object)(object)gui.m_currentContainer == (Object)null && (Object)(object)gui.m_container != (Object)null)
				{
					((Component)gui.m_container).gameObject.SetActive(false);
				}
			}
		}

		private static void RestoreContainerPreviewUi()
		{
			if (!_containerPreviewUiCaptured)
			{
				return;
			}
			foreach (KeyValuePair<GameObject, bool> containerPreviewHiddenObject in ContainerPreviewHiddenObjects)
			{
				if ((Object)(object)containerPreviewHiddenObject.Key != (Object)null && !IsUnityNull((Object?)(object)containerPreviewHiddenObject.Key))
				{
					containerPreviewHiddenObject.Key.SetActive(containerPreviewHiddenObject.Value);
				}
			}
			ContainerPreviewHiddenObjects.Clear();
			_containerPreviewUiCaptured = false;
		}

		private static void LogContainerPreviewFailure(Exception exception)
		{
			string text = exception.GetType().Name + ": " + exception.Message;
			float unscaledTime = Time.unscaledTime;
			if (!string.Equals(text, _containerPreviewLastFailure, StringComparison.Ordinal) || !(unscaledTime - _containerPreviewLastFailureAt < 5f))
			{
				_containerPreviewLastFailure = text;
				_containerPreviewLastFailureAt = unscaledTime;
				Log.LogWarning((object)("Container preview was closed after a UI update failed: " + text));
			}
		}

		internal static bool TryHandleVanillaPlaceStacks(InventoryGui gui)
		{
			if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_currentContainer == (Object)null)
			{
				return false;
			}
			if (IsMultiUserContainerAreaBatchActive())
			{
				ShowMultiUserContainerNotReady();
				return true;
			}
			ContainerAccessMode containerAccessMode = GetContainerAccessMode(gui.m_currentContainer, allowLocalWithoutZNetView: true);
			if (containerAccessMode == ContainerAccessMode.MultiUserChestRemote && IsBuiltInMultiUserChestEnabled)
			{
				if (!TryStartMultiUserContainerPlaceStacksBatch(gui.m_currentContainer))
				{
					ShowMultiUserContainerNotReady();
				}
				return true;
			}
			if (containerAccessMode != ContainerAccessMode.DirectOwner)
			{
				return false;
			}
			QuickStackCurrentContainer(Player.m_localPlayer);
			return true;
		}

		internal static bool TryHandleContainerStackAll(Container container)
		{
			if (ShouldSuppressContainerStackAllForRestock(container))
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.m_isLoading || (Object)(object)container == (Object)null || container.m_inventory == null)
			{
				return false;
			}
			ContainerAccessMode containerAccessMode = GetContainerAccessMode(container, allowLocalWithoutZNetView: true);
			if (IsBuiltInMultiUserChestEnabled && TryHandleMultiUserContainerAreaQuickStack(container))
			{
				return true;
			}
			if (containerAccessMode == ContainerAccessMode.MultiUserChestRemote && IsBuiltInMultiUserChestEnabled)
			{
				ShowMultiUserContainerNotReady();
				return true;
			}
			if (containerAccessMode != ContainerAccessMode.DirectOwner)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			QuickStackIntoContainers(localPlayer, inventory, container, includeArea: true);
			return true;
		}

		private static void HandleContainerQuickStackHotkey(Player player)
		{
			HandleContainerHoldHotkey(player, InventoryPanels.ContainerQuickStackHold, TryGetContainerQuickStackHotkeyContext, TryQuickStackFromHoveredContainer);
		}

		private static bool TryGetContainerQuickStackHotkeyContext(Player player, out Container container)
		{
			container = null;
			if ((Object)(object)player == (Object)null || InventoryGui.IsVisible() || ShouldBlockGlobalHotkeys(player) || IsContainerRestockShortcutHeld() || !IsContainerQuickStackShortcutHeld())
			{
				return false;
			}
			Container hoveredContainer = GetHoveredContainer(player);
			if ((Object)(object)hoveredContainer == (Object)null || player.m_isLoading || hoveredContainer.m_inventory == null || !CanHandleContainerAreaAction(player, hoveredContainer))
			{
				return false;
			}
			container = hoveredContainer;
			return true;
		}

		private static bool IsContainerQuickStackShortcutHeld()
		{
			if (!ZInput.GetButton("Use"))
			{
				return ZInput.GetButton("JoyUse");
			}
			return true;
		}

		private static bool TryQuickStackFromHoveredContainer(Player player, Container container)
		{
			if ((Object)(object)container == (Object)null || container.m_inventory == null || !CanHandleContainerAreaAction(player, container))
			{
				return false;
			}
			if (TryHandleMultiUserContainerAreaQuickStack(container))
			{
				return true;
			}
			if (!CanMutateContainerDirectly(container, allowLocalWithoutZNetView: true))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			QuickStackIntoContainers(player, inventory, container, includeArea: true);
			return true;
		}

		internal static void QuickStackCurrentContainer(Player? player)
		{
			if (TryGetActionContext(player, out Player localPlayer, out Inventory playerInventory, out Container container, out Inventory _))
			{
				QuickStackIntoContainers(localPlayer, playerInventory, container, includeArea: false);
			}
		}

		private static void QuickStackIntoContainers(Player localPlayer, Inventory playerInventory, Container container, bool includeArea)
		{
			List<ItemData> candidates = playerInventory.m_inventory.Where((ItemData item) => ShouldQuickStackItem(localPlayer, playerInventory, item, includeHotbar: false)).ToList();
			candidates.Sort((ItemData a, ItemData b) => -CompareGridOrder(a.m_gridPos, b.m_gridPos));
			InventoryGui instance = InventoryGui.instance;
			if (instance != null)
			{
				instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
			}
			int moved = RunContainerTransferAcrossContainers(localPlayer, container, includeArea, areaForQuickStack: true, (Container targetContainer) => QuickStackItemsIntoContainer(playerInventory, targetContainer.m_inventory, candidates), delegate
			{
				playerInventory.Changed();
				ClearCraftingRequirementAvailabilityCache();
			});
			ShowContainerActionResult(localPlayer, "$inventoryslots_action_stack", "Stack", moved);
		}

		private static bool ShouldQuickStackItem(Player player, Inventory inventory, ItemData item, bool includeHotbar)
		{
			if (item?.m_shared != null && item.m_shared.m_maxStackSize > 1 && IsRegularActionItem(player, inventory, item, includeHotbar) && !IsFavoriteProtected(player, inventory, item))
			{
				return CanUseContainerActionStacking(item);
			}
			return false;
		}

		private static int QuickStackItemsIntoContainer(Inventory playerInventory, Inventory containerInventory, List<ItemData> candidates)
		{
			if (containerInventory == null || candidates.Count == 0)
			{
				return 0;
			}
			HashSet<string> hashSet = new HashSet<string>(from item in containerInventory.m_inventory
				where item?.m_shared != null
				select item.m_shared.m_name, StringComparer.OrdinalIgnoreCase);
			if (hashSet.Count == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData candidate in candidates)
			{
				if (playerInventory.m_inventory.Contains(candidate) && candidate?.m_shared != null && hashSet.Contains(candidate.m_shared.m_name) && containerInventory.AddItem(candidate))
				{
					RemoveItemIfStillOwned(playerInventory, candidate);
					num++;
				}
			}
			if (num > 0)
			{
				containerInventory.Changed();
			}
			return num;
		}

		private static void StoreAllToCurrentContainer(Player? player)
		{
			if (!TryGetActionContext(player, out Player localPlayer, out Inventory playerInventory, out Container _, out Inventory containerInventory))
			{
				return;
			}
			List<ItemData> list = playerInventory.m_inventory.Where((ItemData item) => ShouldStoreAllItem(localPlayer, playerInventory, item, includeHotbar: false, includeEquipped: false)).ToList();
			list.Sort((ItemData a, ItemData b) => CompareGridOrder(a.m_gridPos, b.m_gridPos));
			InventoryGui.instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
			int num = 0;
			foreach (ItemData item in list)
			{
				if (playerInventory.m_inventory.Contains(item) && containerInventory.AddItem(item))
				{
					RemoveItemIfStillOwned(playerInventory, item);
					num++;
					if (item.m_equipped)
					{
						((Humanoid)localPlayer).RemoveEquipAction(item);
						((Humanoid)localPlayer).UnequipItem(item, false);
					}
				}
			}
			if (num > 0)
			{
				playerInventory.Changed();
				containerInventory.Changed();
				ClearCraftingRequirementAvailabilityCache();
			}
		}

		private static bool ShouldStoreAllItem(Player player, Inventory inventory, ItemData item, bool includeHotbar, bool includeEquipped)
		{
			if (item?.m_shared != null && IsRegularActionItem(player, inventory, item, includeHotbar) && !IsFavoriteProtected(player, inventory, item))
			{
				if (!includeEquipped)
				{
					return !item.m_equipped;
				}
				return true;
			}
			return false;
		}

		private static void RefreshRestockTargetStackLimits()
		{
			InventoryDefinitions.RestockTargetStackLimits = RestockTargetLimitCore.Parse(_restockTargetStackLimitsConfig?.Value);
		}

		private static void RestockFromCurrentContainer(Player? player)
		{
			if (TryGetActionContext(player, out Player localPlayer, out Inventory playerInventory, out Container container, out Inventory _))
			{
				RestockFromContainer(localPlayer, playerInventory, container, ContainerTakeStacksMode.CurrentContainerMatchingStacks);
			}
		}

		private static void HandleContainerRestockHotkey(Player player)
		{
			HandleContainerHoldHotkey(player, InventoryPanels.ContainerRestockHold, TryGetContainerRestockHotkeyContext, TryRestockFromHoveredContainer);
		}

		internal static bool ShouldSuppressContainerInteractForRestock(Container container, Humanoid character)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)character != (Object)(object)localPlayer || InventoryGui.IsVisible() || !IsContainerRestockShortcutHeld())
			{
				return false;
			}
			if ((Object)(object)GetHoveredContainer(localPlayer) == (Object)(object)container)
			{
				return CanHandleContainerRestock(localPlayer, container);
			}
			return false;
		}

		private static bool ShouldSuppressContainerStackAllForRestock(Container container)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.m_isLoading || InventoryGui.IsVisible() || !IsContainerRestockShortcutHeld())
			{
				return false;
			}
			return (Object)(object)GetHoveredContainer(localPlayer) == (Object)(object)container;
		}

		internal static void AppendContainerRestockHoverText(Container container, ref string text)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.m_isLoading || string.IsNullOrWhiteSpace(text) || !IsContainerRestockKeyConfigured() || !CanHandleContainerRestock(localPlayer, container))
			{
				return;
			}
			string text2 = LocalizeUi("$inventoryslots_hold_to_restock", "Hold to restock");
			if (text.IndexOf("Hold to restock", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf(text2, StringComparison.OrdinalIgnoreCase) < 0)
			{
				string containerRestockKeyDisplayText = GetContainerRestockKeyDisplayText();
				if (!string.IsNullOrWhiteSpace(containerRestockKeyDisplayText))
				{
					text = text + "\n[<color=yellow><b>" + containerRestockKeyDisplayText + "</b></color>] (" + text2 + ")";
				}
			}
		}

		private static bool TryGetContainerRestockHotkeyContext(Player player, out Container container)
		{
			container = null;
			if ((Object)(object)player == (Object)null || InventoryGui.IsVisible() || ShouldBlockGlobalHotkeys(player) || !IsContainerRestockShortcutHeld())
			{
				return false;
			}
			Container hoveredContainer = GetHoveredContainer(player);
			if ((Object)(object)hoveredContainer == (Object)null || !CanHandleContainerRestock(player, hoveredContainer))
			{
				return false;
			}
			container = hoveredContainer;
			return true;
		}

		private static bool TryRestockFromHoveredContainer(Player player, Container container)
		{
			if (!CanHandleContainerRestock(player, container))
			{
				return false;
			}
			if (TryHandleMultiUserContainerAreaRestock(container))
			{
				return true;
			}
			if (!CanMutateContainerDirectly(container, allowLocalWithoutZNetView: true))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			RestockFromContainer(player, inventory, container, ContainerTakeStacksMode.AreaFavoriteRestock);
			return true;
		}

		private static void RestockFromContainer(Player localPlayer, Inventory playerInventory, Container container, ContainerTakeStacksMode mode)
		{
			if (!((Object)(object)localPlayer == (Object)null) && playerInventory != null && !((Object)(object)container == (Object)null) && container.m_inventory != null)
			{
				bool includeArea = mode == ContainerTakeStacksMode.AreaFavoriteRestock;
				List<ItemData> targets = playerInventory.m_inventory.Where((ItemData item) => ShouldTakeStacksTarget(localPlayer, playerInventory, item, includeHotbar: false, mode)).ToList();
				targets.Sort((ItemData a, ItemData b) => -CompareGridOrder(a.m_gridPos, b.m_gridPos));
				InventoryGui instance = InventoryGui.instance;
				if (instance != null)
				{
					instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
				}
				int moved = RunContainerTransferAcrossContainers(localPlayer, container, includeArea, areaForQuickStack: false, (Container sourceContainer) => RestockTargetsFromContainer(playerInventory, sourceContainer.m_inventory, targets, mode), delegate
				{
					playerInventory.Changed();
					ClearCraftingRequirementAvailabilityCache();
				});
				ShowContainerActionResult(localPlayer, "$inventoryslots_action_take_stacks", "Take stacks", moved);
			}
		}

		private static Container? GetHoveredContainer(Player player)
		{
			GameObject val = (((Object)(object)player != (Object)null) ? ((Humanoid)player).GetHoverObject() : null);
			if (!IsUnityNull((Object?)(object)val))
			{
				return val.GetComponentInParent<Container>();
			}
			return null;
		}

		private static bool IsContainerRestockKeyConfigured()
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			if (_containerRestockKey != null)
			{
				KeyboardShortcut value = _containerRestockKey.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					return true;
				}
			}
			return IsControllerHotkeyConfigured(_controllerContainerRestockButton);
		}

		private static bool IsContainerRestockShortcutHeld()
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (_containerRestockKey != null)
			{
				KeyboardShortcut value = _containerRestockKey.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0 && IsShortcutHeldAllowingAltPair(_containerRestockKey.Value))
				{
					return true;
				}
			}
			return IsControllerHotkeyHeld(_controllerContainerRestockButton);
		}

		private static string GetContainerRestockKeyDisplayText()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return JoinShortcutDisplayTexts((_containerRestockKey != null) ? _containerRestockKey.Value.GetCompactDisplayText() : "", GetControllerHotkeyDisplayText(_controllerContainerRestockButton));
		}

		private static bool ShouldTakeStacksTarget(Player player, Inventory inventory, ItemData item, bool includeHotbar, ContainerTakeStacksMode mode)
		{
			if (mode != ContainerTakeStacksMode.AreaFavoriteRestock)
			{
				return ShouldTakeMatchingStackItem(player, inventory, item, includeHotbar);
			}
			return ShouldRestockItem(player, inventory, item);
		}

		private static bool ShouldRestockItem(Player player, Inventory inventory, ItemData item)
		{
			if (item?.m_shared == null || !IsFavoriteRestockActionItem(player, inventory, item) || !IsFavoriteRestockTarget(player, item) || !CanUseContainerActionStacking(item))
			{
				return false;
			}
			int maxStackSize = item.m_shared.m_maxStackSize;
			int restockTargetStack = GetRestockTargetStack(item);
			if (maxStackSize > 1)
			{
				return item.m_stack < restockTargetStack;
			}
			return false;
		}

		private static bool ShouldTakeMatchingStackItem(Player player, Inventory inventory, ItemData item, bool includeHotbar)
		{
			if (item?.m_shared != null && IsRegularActionItem(player, inventory, item, includeHotbar) && !IsFavoriteRestockTarget(player, item) && CanUseContainerActionStacking(item) && item.m_shared.m_maxStackSize > 1)
			{
				return item.m_stack < item.m_shared.m_maxStackSize;
			}
			return false;
		}

		private static bool IsFavoriteRestockActionItem(Player player, Inventory inventory, ItemData item)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return InventoryActionCellPolicyCore.CanUseFavoriteRestockTarget(GetInventoryCellKind(player, inventory, item.m_gridPos));
		}

		private static bool IsFavoriteRestockTarget(Player player, ItemData item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return IsFavoriteSlot(player, item.m_gridPos);
		}

		private static int GetRestockTargetStack(ItemData item)
		{
			if (item?.m_shared != null)
			{
				return RestockTargetLimitCore.ResolveTargetStackLimit(InventoryDefinitions.RestockTargetStackLimits, GetRestockTargetLookupTokens(item), item.m_shared.m_maxStackSize);
			}
			return 0;
		}

		private static IEnumerable<string?> GetRestockTargetLookupTokens(ItemData item)
		{
			if (item != null)
			{
				yield return GetItemPrefabName(item);
				if (!IsUnityNull((Object?)(object)item.m_dropPrefab))
				{
					yield return ((Object)item.m_dropPrefab).name;
				}
				string sharedName = item.m_shared?.m_name ?? "";
				yield return sharedName;
				yield return StripLocalizationToken(sharedName);
				if (Localization.instance != null && !string.IsNullOrWhiteSpace(sharedName))
				{
					yield return Localization.instance.Localize(sharedName);
				}
			}
		}

		private static bool CanRestockFromContainerItem(ItemData target, ItemData source)
		{
			if (target?.m_shared != null && source?.m_shared != null && CanUseContainerActionStacking(target) && CanUseContainerActionStacking(source))
			{
				return CanShareInventoryStack(target, source);
			}
			return false;
		}

		private static int RestockTargetsFromContainer(Inventory playerInventory, Inventory containerInventory, List<ItemData> targets, ContainerTakeStacksMode mode)
		{
			if (containerInventory == null || targets.Count == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData target in targets)
			{
				if (!playerInventory.m_inventory.Contains(target))
				{
					continue;
				}
				int num2 = ((mode == ContainerTakeStacksMode.AreaFavoriteRestock) ? GetRestockTargetStack(target) : target.m_shared.m_maxStackSize);
				int num3 = target.m_stack;
				int num4 = containerInventory.m_inventory.Count - 1;
				while (num4 >= 0 && num3 < num2)
				{
					ItemData val = containerInventory.m_inventory[num4];
					if (CanRestockFromContainerItem(target, val))
					{
						int num5 = Math.Min(num2 - num3, val.m_stack);
						if (num5 > 0)
						{
							int stack = val.m_stack;
							bool moveSucceeded = playerInventory.MoveItemToThis(containerInventory, val, num5, target.m_gridPos.x, target.m_gridPos.y);
							int num6 = CountMovedFromContainerSource(containerInventory, val, stack, num5, moveSucceeded);
							num3 += num6;
							num += num6;
						}
					}
					num4--;
				}
			}
			if (num > 0)
			{
				containerInventory.Changed();
			}
			return num;
		}

		private static void SortCurrentContainer(Player? player)
		{
			if ((Object)(object)player == (Object)null || player.m_isLoading || (Object)(object)InventoryGui.instance == (Object)null)
			{
				return;
			}
			if (IsMultiUserContainerAreaBatchActive())
			{
				ShowMultiUserContainerNotReady();
				return;
			}
			Container currentContainer = InventoryGui.instance.m_currentContainer;
			if ((Object)(object)currentContainer == (Object)null || currentContainer.m_inventory == null)
			{
				return;
			}
			switch (GetContainerAccessMode(currentContainer, allowLocalWithoutZNetView: true))
			{
			case ContainerAccessMode.DirectOwner:
				SortContainerInventory(currentContainer);
				break;
			case ContainerAccessMode.MultiUserChestRemote:
				if (!IsContainerSortRequestPending(currentContainer))
				{
					ZDO zDO = currentContainer.m_nview.GetZDO();
					long num = ((zDO != null) ? zDO.GetOwner() : 0);
					if (num != 0L)
					{
						int nextContainerSortRequestId = GetNextContainerSortRequestId();
						_pendingSortContainer = currentContainer;
						_pendingSortRequestId = nextContainerSortRequestId;
						_pendingSortOwner = num;
						_pendingSortStartedAt = Time.unscaledTime;
						currentContainer.m_nview.InvokeRPC("InventorySlots_RequestSortV2", new object[2]
						{
							nextContainerSortRequestId,
							player.GetPlayerID()
						});
					}
				}
				break;
			}
		}

		private static int SortContainerInventory(Container container)
		{
			if ((Object)(object)container == (Object)null || container.m_inventory == null)
			{
				return 0;
			}
			List<Vector2i> allInventorySlots = GetAllInventorySlots(container.m_inventory);
			return SortInventoryInternal(container.m_inventory, allInventorySlots, (ItemData item) => item?.m_shared != null);
		}

		internal static void RegisterContainer(Container container)
		{
			if (!((Object)(object)container == (Object)null))
			{
				if (!InventoryContainers.KnownContainers.Contains(container))
				{
					InventoryContainers.KnownContainers.Add(container);
				}
				RegisterContainerRpcs(container);
				RegisterMultiUserContainerRpcs(container);
			}
		}

		internal static void UnregisterContainer(Container container)
		{
			if ((Object)(object)container != (Object)null)
			{
				UnregisterMultiUserContainerRpcs(container);
				ClearPendingContainerSortRequest(container);
				InventoryContainers.KnownContainers.Remove(container);
			}
		}

		private static void RegisterContainerRpcs(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			if ((Object)(object)container.m_nview == (Object)null)
			{
				container.m_nview = (((Object)(object)container.m_rootObjectOverride != (Object)null) ? ((Component)container.m_rootObjectOverride).GetComponent<ZNetView>() : ((Component)container).GetComponent<ZNetView>());
			}
			if (!((Object)(object)container.m_nview == (Object)null))
			{
				container.m_nview.Unregister("InventorySlots_RequestSortV2");
				container.m_nview.Unregister("InventorySlots_SortResponseV2");
				container.m_nview.Register<int, long>("InventorySlots_RequestSortV2", (Action<long, int, long>)delegate(long sender, int requestId, long requesterPlayerId)
				{
					RPC_RequestSort(container, sender, requestId, requesterPlayerId);
				});
				container.m_nview.Register<int, bool>("InventorySlots_SortResponseV2", (Action<long, int, bool>)delegate(long sender, int requestId, bool success)
				{
					RPC_SortResponse(container, sender, requestId, success);
				});
			}
		}

		private static void RPC_RequestSort(Container container, long sender, int requestId, long requesterPlayerId)
		{
			bool flag = CanProcessContainerSortRpc(container, sender, requesterPlayerId);
			if (flag)
			{
				SortContainerInventory(container);
			}
			if (sender != 0L && (Object)(object)container?.m_nview != (Object)null && container.m_nview.IsValid())
			{
				container.m_nview.InvokeRPC(sender, "InventorySlots_SortResponseV2", new object[2] { requestId, flag });
			}
		}

		private static void RPC_SortResponse(Container container, long sender, int requestId, bool success)
		{
			if (!((Object)(object)container == (Object)null) && !((Object)(object)_pendingSortContainer != (Object)(object)container) && _pendingSortRequestId == requestId && _pendingSortOwner == sender)
			{
				ClearPendingContainerSortRequest();
				if (!success && !IsUnityNull((Object?)(object)Player.m_localPlayer))
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, LocalizeUi("$inventoryslots_container_not_ready", "Container is not ready."), 0, (Sprite)null);
				}
			}
		}

		private static bool IsContainerSortRequestPending(Container container)
		{
			if ((Object)(object)_pendingSortContainer == (Object)null)
			{
				ClearPendingContainerSortRequest();
				return false;
			}
			if (Time.unscaledTime - _pendingSortStartedAt >= 2f)
			{
				ClearPendingContainerSortRequest();
				return false;
			}
			return (Object)(object)_pendingSortContainer == (Object)(object)container;
		}

		private static int GetNextContainerSortRequestId()
		{
			if (_nextSortRequestId <= 0)
			{
				_nextSortRequestId = 1;
			}
			return _nextSortRequestId++;
		}

		private static void ClearPendingContainerSortRequest(Container? container = null)
		{
			if (!((Object)(object)container != (Object)null) || !((Object)(object)_pendingSortContainer != (Object)(object)container))
			{
				_pendingSortContainer = null;
				_pendingSortRequestId = 0;
				_pendingSortOwner = 0L;
				_pendingSortStartedAt = -1f;
			}
		}

		private static void SortPlayerInventory(Player? player)
		{
			if ((Object)(object)player == (Object)null || player.m_isLoading)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory != null)
			{
				List<Vector2i> playerActionSlots = GetPlayerActionSlots(player, inventory, includeHotbar: false, blockFavorites: true);
				HashSet<Vector2i> allowedSet = new HashSet<Vector2i>(playerActionSlots);
				InventoryGui.instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
				SortInventoryInternal(inventory, playerActionSlots, (ItemData item) => item?.m_shared != null && allowedSet.Contains(item.m_gridPos) && !IsFavoriteProtected(player, inventory, item));
			}
		}

		private static int SortInventoryInternal(Inventory inventory, List<Vector2i> allowedSlots, Func<ItemData, bool> shouldSort)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null || allowedSlots.Count == 0)
			{
				return 0;
			}
			List<ItemData> list = inventory.m_inventory.Where(shouldSort).ToList();
			if (list.Count == 0)
			{
				return 0;
			}
			bool flag = MergeSortableStacks(list, inventory);
			Dictionary<ItemData, SortKey> sortKeys = list.ToDictionary((ItemData item) => item, GetInventoryItemSortKey);
			int inventoryWidth = Mathf.Max(1, inventory.GetWidth());
			Dictionary<ItemData, int> originalIndices = list.ToDictionary((ItemData item) => item, (ItemData item) => GetInventoryOriginalSortIndex(item, inventoryWidth));
			list.Sort((ItemData a, ItemData b) => CompareItemsForSort(a, b, sortKeys[a], sortKeys[b], originalIndices[a], originalIndices[b]));
			int num = 0;
			int num2 = Math.Min(list.Count, allowedSlots.Count);
			for (int num3 = 0; num3 < num2; num3++)
			{
				if (list[num3].m_gridPos != allowedSlots[num3])
				{
					num++;
					flag = true;
					list[num3].m_gridPos = allowedSlots[num3];
				}
			}
			if (flag)
			{
				inventory.Changed();
			}
			return num;
		}

		private static int GetInventoryOriginalSortIndex(ItemData item, int inventoryWidth)
		{
			return item.m_gridPos.y * inventoryWidth + item.m_gridPos.x;
		}

		private static bool MergeSortableStacks(List<ItemData> toMerge, Inventory inventory)
		{
			bool result = false;
			foreach (List<ItemData> item in (from item in toMerge
				where item?.m_shared != null && item.m_stack < item.m_shared.m_maxStackSize && CanUseContainerActionStacking(item)
				group item by new
				{
					item.m_shared.m_name,
					item.m_quality,
					item.m_worldLevel
				} into grouping
				select grouping.ToList()).ToList())
			{
				if (item.Count <= 1)
				{
					continue;
				}
				int num = item.Sum((ItemData item) => item.m_stack);
				int maxStackSize = item[0].m_shared.m_maxStackSize;
				foreach (ItemData item2 in item)
				{
					if (num <= 0)
					{
						if (item2.m_stack != 0)
						{
							item2.m_stack = 0;
							result = true;
						}
						inventory.RemoveItem(item2);
						toMerge.Remove(item2);
						result = true;
					}
					else
					{
						int num2 = Math.Min(maxStackSize, num);
						if (item2.m_stack != num2)
						{
							item2.m_stack = num2;
							result = true;
						}
						num -= item2.m_stack;
					}
				}
			}
			return result;
		}

		private static List<Vector2i> GetAllInventorySlots(Inventory inventory)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2i> list = new List<Vector2i>();
			for (int i = 0; i < inventory.GetHeight(); i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					list.Add(new Vector2i(j, i));
				}
			}
			return list;
		}

		internal static bool TryHandleSafeTakeAll(InventoryGui gui)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.m_isLoading || (Object)(object)gui == (Object)null || (Object)(object)gui.m_currentContainer == (Object)null || gui.m_currentContainer.m_inventory == null)
			{
				return false;
			}
			if (IsMultiUserContainerAreaBatchActive())
			{
				ShowMultiUserContainerNotReady();
				return true;
			}
			Container currentContainer = gui.m_currentContainer;
			switch (GetContainerAccessMode(currentContainer, allowLocalWithoutZNetView: true))
			{
			case ContainerAccessMode.MultiUserChestRemote:
				if (IsBuiltInMultiUserChestEnabled)
				{
					if (!TryStartMultiUserContainerTakeAllBatch(currentContainer))
					{
						ShowMultiUserContainerNotReady();
					}
					return true;
				}
				return false;
			default:
				((Character)localPlayer).Message((MessageType)2, LocalizeUi("$inventoryslots_container_not_ready", "Container is not ready."), 0, (Sprite)null);
				return true;
			case ContainerAccessMode.DirectOwner:
			{
				Inventory inventory = ((Humanoid)localPlayer).GetInventory();
				Inventory inventory2 = currentContainer.m_inventory;
				if (inventory == null || inventory2 == null)
				{
					return false;
				}
				TombStone component = ((Component)currentContainer).GetComponent<TombStone>();
				bool num = (Object)(object)component != (Object)null;
				gui.SetupDragItem((ItemData)null, (Inventory)null, 0);
				if (SafeTakeAllItems(localPlayer, inventory, inventory2, includeHotbar: false) > 0)
				{
					inventory.Changed();
					inventory2.Changed();
					ClearCraftingRequirementAvailabilityCache();
				}
				if (num && inventory2.NrOfItems() == 0)
				{
					component.OnTakeAllSuccess();
				}
				return true;
			}
			}
		}

		private static int SafeTakeAllItems(Player player, Inventory playerInventory, Inventory containerInventory, bool includeHotbar)
		{
			List<Vector2i> playerActionSlots = GetPlayerActionSlots(player, playerInventory, includeHotbar, blockFavorites: true);
			HashSet<Vector2i> allowedSlots = new HashSet<Vector2i>(playerActionSlots);
			List<Vector2i> safeTakeAllEmptySlots = GetSafeTakeAllEmptySlots(playerInventory, playerActionSlots);
			List<ItemData> list = containerInventory.m_inventory.Where((ItemData item) => item?.m_shared != null).ToList();
			list.Sort((ItemData left, ItemData right) => CompareGridOrder(left.m_gridPos, right.m_gridPos));
			int num = 0;
			foreach (ItemData item in list)
			{
				if (containerInventory.m_inventory.Contains(item))
				{
					int stack = item.m_stack;
					if (MoveContainerItemSafelyToPlayer(playerInventory, containerInventory, item, safeTakeAllEmptySlots, allowedSlots) > 0 && (!containerInventory.m_inventory.Contains(item) || item.m_stack < stack))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static int MoveContainerItemSafelyToPlayer(Inventory playerInventory, Inventory containerInventory, ItemData source, List<Vector2i> emptySlots, HashSet<Vector2i> allowedSlots)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			if (source.m_shared != null && source.m_shared.m_maxStackSize > 1 && CanUseContainerActionStacking(source))
			{
				foreach (ItemData safeTakeAllStackTarget in GetSafeTakeAllStackTargets(playerInventory, source, allowedSlots))
				{
					if (!containerInventory.m_inventory.Contains(source) || source.m_stack <= 0)
					{
						break;
					}
					int num2 = Math.Min(safeTakeAllStackTarget.m_shared.m_maxStackSize - safeTakeAllStackTarget.m_stack, source.m_stack);
					if (num2 > 0)
					{
						int stack = source.m_stack;
						bool moveSucceeded = playerInventory.MoveItemToThis(containerInventory, source, num2, safeTakeAllStackTarget.m_gridPos.x, safeTakeAllStackTarget.m_gridPos.y);
						int num3 = CountMovedFromContainerSource(containerInventory, source, stack, num2, moveSucceeded);
						num += num3;
					}
				}
			}
			while (containerInventory.m_inventory.Contains(source) && source.m_stack > 0 && emptySlots.Count > 0)
			{
				Vector2i val = emptySlots[0];
				emptySlots.RemoveAt(0);
				int stack2 = source.m_stack;
				int stack3 = source.m_stack;
				bool moveSucceeded2 = playerInventory.MoveItemToThis(containerInventory, source, stack3, val.x, val.y);
				int num4 = CountMovedFromContainerSource(containerInventory, source, stack2, stack3, moveSucceeded2);
				num += num4;
				if (num4 == 0)
				{
					break;
				}
			}
			return num;
		}

		private static List<ItemData> GetSafeTakeAllStackTargets(Inventory playerInventory, ItemData source, HashSet<Vector2i> allowedSlots)
		{
			return (from target in playerInventory.m_inventory
				where target?.m_shared != null && allowedSlots.Contains(target.m_gridPos) && target.m_shared.m_maxStackSize > 1 && CanUseContainerActionStacking(target) && CanShareInventoryStack(target, source) && target.m_stack < target.m_shared.m_maxStackSize
				orderby target.m_gridPos.y, target.m_gridPos.x
				select target).ToList();
		}

		private static List<Vector2i> GetSafeTakeAllEmptySlots(Inventory playerInventory, List<Vector2i> actionSlots)
		{
			return actionSlots.Where((Vector2i slot) => playerInventory.GetItemAt(slot.x, slot.y) == null).ToList();
		}

		private static void DrawControllerHotkeyConfig(ConfigEntryBase entry)
		{
			string configDrawerEntryKey = GetConfigDrawerEntryKey(entry);
			ControllerHotkeyAction controllerHotkeyAction = GetControllerHotkeyConfigValue(entry);
			bool flag = IsCapturingControllerHotkey(configDrawerEntryKey);
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			string controllerHotkeyDisplayText = GetControllerHotkeyDisplayText(controllerHotkeyAction);
			GUILayout.Label("Current: " + (string.IsNullOrWhiteSpace(controllerHotkeyDisplayText) ? "Off" : controllerHotkeyDisplayText), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (GUILayout.Button(flag ? "Stop" : "Capture", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) }))
			{
				if (flag)
				{
					StopControllerHotkeyCapture();
				}
				else
				{
					StartControllerHotkeyCapture(configDrawerEntryKey);
				}
			}
			if (GUILayout.Button("Clear", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(48f) }))
			{
				SetControllerHotkeyConfigValue(entry, ControllerHotkeyAction.Off);
				controllerHotkeyAction = ControllerHotkeyAction.Off;
			}
			GUILayout.EndHorizontal();
			DrawControllerHotkeyStatus(entry, controllerHotkeyAction, flag);
			if (GUILayout.Button(ExpandedControllerHotkeyPresetDrawers.Contains(configDrawerEntryKey) ? "Hide Presets" : "Presets", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }) && !ExpandedControllerHotkeyPresetDrawers.Add(configDrawerEntryKey))
			{
				ExpandedControllerHotkeyPresetDrawers.Remove(configDrawerEntryKey);
			}
			if (ExpandedControllerHotkeyPresetDrawers.Contains(configDrawerEntryKey))
			{
				DrawControllerHotkeyPresetButtons(entry, controllerHotkeyAction);
			}
			GUILayout.EndVertical();
		}

		private static void DrawControllerHotkeyStatus(ConfigEntryBase entry, ControllerHotkeyAction currentValue, bool isCapturing)
		{
			if (IsControllerDPadAction(currentValue))
			{
				ConfigEntry<ControllerDPadHotkeyMode> controllerDPadHotkeyMode = _controllerDPadHotkeyMode;
				if (controllerDPadHotkeyMode == null || controllerDPadHotkeyMode.Value == ControllerDPadHotkeyMode.InventoryNavigation)
				{
					GUILayout.Label("DPad actions are ignored until Controller DPad Hotkey Mode allows hotkeys.", Array.Empty<GUILayoutOption>());
				}
			}
			if (isCapturing)
			{
				ControllerHotkeyAction controllerHotkeyAction = TryCaptureControllerHotkeyAction();
				if (controllerHotkeyAction != ControllerHotkeyAction.Off)
				{
					SetControllerHotkeyConfigValue(entry, controllerHotkeyAction);
					StopControllerHotkeyCapture();
				}
				else
				{
					float num = Mathf.Max(0f, _controllerHotkeyCaptureEndTime - Time.unscaledTime);
					GUILayout.Label($"Listening for controller input... {num:0.0}s", Array.Empty<GUILayoutOption>());
				}
			}
		}

		private static void DrawControllerHotkeyPresetButtons(ConfigEntryBase entry, ControllerHotkeyAction currentValue)
		{
			for (int i = 0; i < ControllerActionOptions.Length; i++)
			{
				if (i % 4 == 0)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				}
				ControllerActionOption controllerActionOption = ControllerActionOptions[i];
				if (GUILayout.Button((currentValue == controllerActionOption.Action) ? ("* " + controllerActionOption.Label) : controllerActionOption.Label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(88f) }))
				{
					SetControllerHotkeyConfigValue(entry, controllerActionOption.Action);
				}
				if (i % 4 == 3 || i == ControllerActionOptions.Length - 1)
				{
					GUILayout.EndHorizontal();
				}
			}
		}

		private static ControllerHotkeyAction TryCaptureControllerHotkeyAction()
		{
			for (int i = 0; i < ControllerActionOptions.Length; i++)
			{
				ControllerHotkeyAction action = ControllerActionOptions[i].Action;
				if (action == ControllerHotkeyAction.Off)
				{
					continue;
				}
				try
				{
					if (ZInput.GetButtonDown(GetControllerHotkeyActionName(action)))
					{
						return action;
					}
				}
				catch
				{
				}
			}
			for (int j = 0; j <= 19; j++)
			{
				try
				{
					if (Input.GetKeyDown((KeyCode)(330 + j)) && UnityJoystickButtonToControllerAction.TryGetValue(j, out var value))
					{
						return value;
					}
				}
				catch
				{
					return ControllerHotkeyAction.Off;
				}
			}
			return ControllerHotkeyAction.Off;
		}

		private static ControllerHotkeyAction GetControllerHotkeyConfigValue(ConfigEntryBase entry)
		{
			object boxedValue = entry.BoxedValue;
			if (boxedValue is ControllerHotkeyAction)
			{
				return (ControllerHotkeyAction)boxedValue;
			}
			return ControllerHotkeyAction.Off;
		}

		private static void SetControllerHotkeyConfigValue(ConfigEntryBase entry, ControllerHotkeyAction value)
		{
			if (!object.Equals(entry.BoxedValue, value))
			{
				entry.BoxedValue = value;
			}
		}

		private static bool IsCapturingControllerHotkey(string entryKey)
		{
			if (!string.Equals(_controllerHotkeyCaptureEntryKey, entryKey, StringComparison.Ordinal))
			{
				return false;
			}
			if (Time.unscaledTime <= _controllerHotkeyCaptureEndTime)
			{
				return true;
			}
			StopControllerHotkeyCapture();
			return false;
		}

		private static void StartControllerHotkeyCapture(string entryKey)
		{
			_controllerHotkeyCaptureEntryKey = entryKey;
			_controllerHotkeyCaptureEndTime = Time.unscaledTime + 8f;
		}

		private static void StopControllerHotkeyCapture()
		{
			_controllerHotkeyCaptureEntryKey = "";
			_controllerHotkeyCaptureEndTime = 0f;
		}

		private static string GetConfigDrawerEntryKey(ConfigEntryBase entry)
		{
			return entry.Definition.Section + "\n" + entry.Definition.Key;
		}

		private static bool IsControllerHotkeyDown(ConfigEntry<ControllerHotkeyAction>? entry)
		{
			return IsControllerHotkeyActive(entry, down: true, respectDPadMode: true);
		}

		private static bool IsControllerHotkeyHeld(ConfigEntry<ControllerHotkeyAction>? entry)
		{
			return IsControllerHotkeyActive(entry, down: false, respectDPadMode: true);
		}

		private static bool IsControllerHotkeyConfigured(ConfigEntry<ControllerHotkeyAction>? entry)
		{
			if (entry != null && entry.Value != ControllerHotkeyAction.Off)
			{
				return IsControllerActionAllowedByDPadMode(entry.Value, forDisplay: true);
			}
			return false;
		}

		private static bool IsControllerHotkeyActive(ConfigEntry<ControllerHotkeyAction>? entry, bool down, bool respectDPadMode)
		{
			if (_enableControllerHotkeys == null || _enableControllerHotkeys.Value.IsOff() || entry == null || entry.Value == ControllerHotkeyAction.Off || !IsGamepadActiveSafe())
			{
				return false;
			}
			ControllerHotkeyAction value = entry.Value;
			if (respectDPadMode && !IsControllerActionAllowedByDPadMode(value, forDisplay: false))
			{
				return false;
			}
			string controllerHotkeyActionName = GetControllerHotkeyActionName(value);
			if (string.IsNullOrWhiteSpace(controllerHotkeyActionName))
			{
				return false;
			}
			try
			{
				return down ? ZInput.GetButtonDown(controllerHotkeyActionName) : ZInput.GetButton(controllerHotkeyActionName);
			}
			catch
			{
				return false;
			}
		}

		private static string GetControllerHotkeyDisplayText(ConfigEntry<ControllerHotkeyAction>? entry)
		{
			return GetControllerHotkeyDisplayText(entry, respectDPadMode: true);
		}

		private static string GetControllerHotkeyDisplayText(ConfigEntry<ControllerHotkeyAction>? entry, bool respectDPadMode)
		{
			if (entry == null || entry.Value == ControllerHotkeyAction.Off)
			{
				return "";
			}
			ControllerHotkeyAction value = entry.Value;
			if (respectDPadMode && !IsControllerActionAllowedByDPadMode(value, forDisplay: true))
			{
				return "";
			}
			string text = GetControllerHotkeyDisplayText(value);
			if (respectDPadMode && IsControllerDPadAction(value) && (_controllerDPadHotkeyMode?.Value ?? ControllerDPadHotkeyMode.InventoryNavigation) == ControllerDPadHotkeyMode.HotkeysWhileHoldingModifier)
			{
				string controllerHotkeyDisplayText = GetControllerHotkeyDisplayText(_controllerDPadModifierButton, respectDPadMode: false);
				if (!string.IsNullOrWhiteSpace(controllerHotkeyDisplayText))
				{
					text = controllerHotkeyDisplayText + " + " + text;
				}
			}
			return text;
		}

		private static string GetControllerHotkeyDisplayText(ControllerHotkeyAction action)
		{
			if (action != ControllerHotkeyAction.Off)
			{
				return GetControllerActionDisplayText(GetControllerHotkeyActionName(action));
			}
			return "";
		}

		private static string GetControllerActionDisplayText(string action)
		{
			if (string.IsNullOrWhiteSpace(action))
			{
				return "";
			}
			try
			{
				string text = ((ZInput.instance != null) ? ZInput.instance.GetBoundKeyString(action, true) : "");
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
			}
			catch
			{
			}
			return action;
		}

		private static string GetControllerHotkeyActionName(ControllerHotkeyAction action)
		{
			if (action != ControllerHotkeyAction.Off)
			{
				return action.ToString();
			}
			return "";
		}

		private static bool IsControllerActionAllowedByDPadMode(ControllerHotkeyAction action, bool forDisplay)
		{
			if (!IsControllerDPadAction(action))
			{
				return true;
			}
			return (_controllerDPadHotkeyMode?.Value ?? ControllerDPadHotkeyMode.InventoryNavigation) switch
			{
				ControllerDPadHotkeyMode.Hotkeys => true, 
				ControllerDPadHotkeyMode.HotkeysWhileHoldingModifier => forDisplay ? IsControllerHotkeyConfiguredIgnoringDPadMode(_controllerDPadModifierButton) : IsControllerHotkeyActive(_controllerDPadModifierButton, down: false, respectDPadMode: false), 
				_ => false, 
			};
		}

		private static bool IsControllerHotkeyConfiguredIgnoringDPadMode(ConfigEntry<ControllerHotkeyAction>? entry)
		{
			if (entry != null)
			{
				return entry.Value != ControllerHotkeyAction.Off;
			}
			return false;
		}

		private static bool IsControllerDPadAction(ControllerHotkeyAction action)
		{
			if ((uint)(action - 13) <= 3u)
			{
				return true;
			}
			return false;
		}

		private static void UpdateCraftingActionControls(InventoryGui gui, RectTransform? countRect, RectTransform? upgradeProgressionRect, Vector2 craftPosition, Vector2 countPosition, Vector2 craftButtonSize, Vector2 countInputSize, bool updateLayout)
		{
			//IL_00cb: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00a2: Expected O, but got Unknown
			//IL_00a9: 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_0151: 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)
			if ((Object)(object)_craftingCountInputRect != (Object)null && (Object)(object)countRect == (Object)null)
			{
				((Component)_craftingCountInputRect).gameObject.SetActive(false);
			}
			if ((Object)(object)_craftingUpgradeProgressionRect != (Object)null && (Object)(object)upgradeProgressionRect == (Object)null)
			{
				((Component)_craftingUpgradeProgressionRect).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_craftButton != (Object)null)
			{
				((Component)gui.m_craftButton).gameObject.SetActive((Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe != (Object)null && gui.m_craftTimer < 0f);
				if (updateLayout)
				{
					RectTransform rect = (RectTransform)((Component)gui.m_craftButton).transform;
					SetCraftingTopLeftRect(gui.m_crafting, rect, craftPosition, craftButtonSize);
				}
			}
			Transform craftProgressPanel = gui.m_craftProgressPanel;
			RectTransform val = (RectTransform)(object)((craftProgressPanel is RectTransform) ? craftProgressPanel : null);
			if (val != null && updateLayout)
			{
				SetCraftingTopLeftRect(gui.m_crafting, val, craftPosition, craftButtonSize);
				GuiBar craftProgressBar = gui.m_craftProgressBar;
				if (craftProgressBar != null)
				{
					craftProgressBar.SetWidth(craftButtonSize.x);
				}
			}
			if ((Object)(object)countRect != (Object)null)
			{
				if (updateLayout)
				{
					SetCraftingTopLeftRect(gui.m_crafting, countRect, countPosition, countInputSize);
				}
				((Component)countRect).gameObject.SetActive((Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe != (Object)null && ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null);
				UpdateCraftingCountInputState(gui);
			}
			if ((Object)(object)upgradeProgressionRect != (Object)null)
			{
				if (updateLayout)
				{
					SetCraftingTopLeftRect(gui.m_crafting, upgradeProgressionRect, countPosition, countInputSize);
				}
				UpdateCraftingUpgradeProgression(gui);
			}
			UpdateCraftingCraftButtonLabel(gui);
			UpdateJewelcraftingSocketCraftButtonState(gui);
			UpdateCraftingProgressLabel(gui);
		}

		private static void UpdateCraftingStationAndWarningControls(InventoryGui gui, RectTransform grid, Vector2 requiredStationPosition, bool updateLayout)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (ShouldShowCraftingStatusHud(gui))
			{
				LayoutCraftingStatusHud(gui, grid, updateLayout);
			}
			else
			{
				HideCraftingSocketWarning();
			}
			UpdateCraftingRequiredStationLevel(gui, requiredStationPosition, updateLayout);
		}

		private static void UpdateCraftingRequirementStrip(InventoryGui gui, Vector2 requirementPosition, List<Requirement> visibleRequirements, bool updateLayout)
		{
			//IL_00b5: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			int selectedCraftingQuality = GetSelectedCraftingQuality(gui);
			int effectiveCraftingCount = GetEffectiveCraftingCount(gui);
			HideCraftingVanillaRequirementSlots(gui);
			int num = Mathf.Max(4, CraftingRequirements.OwnedSlots.Count);
			for (int i = 0; i < num; i++)
			{
				if (i >= 4 || i >= visibleRequirements.Count)
				{
					if (i < CraftingRequirements.OwnedSlots.Count)
					{
						RectTransform val = CraftingRequirements.OwnedSlots[i];
						if (val != null && !IsUnityNull((Object?)(object)val))
						{
							((Component)val).gameObject.SetActive(false);
						}
					}
				}
				else
				{
					RectTransform val2 = EnsureOwnedCraftingRequirementSlot(gui, i);
					if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
					{
						((Component)val2).gameObject.SetActive(true);
						SetCraftingTopLeftRect(gui.m_crafting, val2, requirementPosition + new Vector2((float)i * 72f, 0f), new Vector2(64f, 64f));
						ConfigureCompactCraftingRequirement(gui, val2, visibleRequirements[i], selectedCraftingQuality, effectiveCraftingCount);
					}
				}
			}
		}

		private static void LayoutCraftingBottomControls(InventoryGui gui, RectTransform grid)
		{
			//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_0089: 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_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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_011f: 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_0122: 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_012d: 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)
			HideRecycleNReclaimHud();
			if (CraftingRecipes.View.Count == 0 || FindCraftingRecipeViewIndex(gui.GetSelectedRecipeIndex(false)) < 0)
			{
				HideCraftingRedesignBottomControls(gui);
				HideCraftingSocketWarning();
				if ((Object)(object)_craftingCountInputRect != (Object)null)
				{
					((Component)_craftingCountInputRect).gameObject.SetActive(false);
				}
				CraftingController.StoreBottomControlsSignature("hidden");
				return;
			}
			bool num = IsJewelcraftingSocketTabActive(gui);
			Vector2 craftingBottomControlsFixedOffset = CraftingBottomControlsFixedOffset;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(136f, 42f);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(64f, 42f);
			Vector2 craftPosition = GetCraftingGridCenteredPosition(grid, 0, 8, val, 2) + craftingBottomControlsFixedOffset + CraftingCraftButtonFixedOffset;
			Vector2 countPosition = GetCraftingGridCenteredPosition(grid, 2, 8, val2) + craftingBottomControlsFixedOffset + CraftingCountInputFixedOffset;
			Vector2 requirementPosition = GetCraftingGridCellPosition(grid, 3, 8) + craftingBottomControlsFixedOffset;
			Vector2 requiredStationPosition = GetCraftingGridCellPosition(grid, 7, 8) + craftingBottomControlsFixedOffset;
			RectTransform countRect = (num ? null : EnsureCraftingCountInput(gui));
			RectTransform upgradeProgressionRect = (num ? null : EnsureCraftingUpgradeProgression(gui));
			List<Requirement> visibleCraftingRequirements = GetVisibleCraftingRequirements(gui);
			string craftingBottomControlsLayoutSignature = GetCraftingBottomControlsLayoutSignature(gui, grid, countRect, upgradeProgressionRect, visibleCraftingRequirements.Count);
			bool updateLayout = CraftingController.NeedsBottomControlsLayout(craftingBottomControlsLayoutSignature);
			UpdateCraftingActionControls(gui, countRect, upgradeProgressionRect, craftPosition, countPosition, val, val2, updateLayout);
			UpdateCraftingStationAndWarningControls(gui, grid, requiredStationPosition, updateLayout);
			UpdateCraftingRequirementStrip(gui, requirementPosition, visibleCraftingRequirements, updateLayout);
			CraftingController.StoreBottomControlsSignature(craftingBottomControlsLayoutSignature);
		}

		private static void HideCraftingRedesignBottomControls(InventoryGui gui)
		{
			SuppressCraftingRequiredStationLevelOriginalBackground(gui);
			if ((Object)(object)gui.m_craftButton != (Object)null)
			{
				((Component)gui.m_craftButton).gameObject.SetActive(false);
			}
			Transform craftProgressPanel = gui.m_craftProgressPanel;
			RectTransform val = (RectTransform)(object)((craftProgressPanel is RectTransform) ? craftProgressPanel : null);
			if (val != null)
			{
				((Component)val).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_minStationLevelIcon != (Object)null)
			{
				((Component)gui.m_minStationLevelIcon).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_minStationLevelText != (Object)null)
			{
				((Component)gui.m_minStationLevelText).gameObject.SetActive(false);
			}
			HideCraftingRequiredStationLevelTooltip();
			if ((Object)(object)gui.m_itemCraftType != (Object)null)
			{
				((Component)gui.m_itemCraftType).gameObject.SetActive(false);
			}
			HideCraftingSocketWarning();
			if ((Object)(object)_craftingUpgradeProgressionRect != (Object)null)
			{
				((Component)_craftingUpgradeProgressionRect).gameObject.SetActive(false);
			}
			HideCraftingVanillaRequirementSlots(gui);
			HideOwnedCraftingRequirementSlots();
			CraftingController.MarkBottomControlsDirty();
		}

		private static string GetCraftingBottomControlsLayoutSignature(InventoryGui gui, RectTransform grid, RectTransform? countRect, RectTransform? upgradeProgressionRect, int visibleRequirementCount)
		{
			//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)
			return $"{((Object)gui.m_crafting).GetInstanceID()}|{((Object)grid).GetInstanceID()}|{grid.anchoredPosition.x:0.###}|{grid.anchoredPosition.y:0.###}|{GetUnityObjectId((Object?)(object)gui.m_craftButton)}|{GetUnityObjectId((Object?)(object)gui.m_craftProgressPanel)}|{GetUnityObjectId((Object?)(object)countRect)}|{GetUnityObjectId((Object?)(object)upgradeProgressionRect)}|{GetUnityObjectId((Object?)(object)gui.m_minStationLevelIcon)}|{GetUnityObjectId((Object?)(object)gui.m_minStationLevelText)}|{visibleRequirementCount}|ownedReq={CraftingRequirements.OwnedSlots.Count}|{64f:0.###}|{72f:0.###}|socket={IsJewelcraftingSocketTabActive(gui)}";
		}

		private static List<Requirement> GetVisibleCraftingRequirements(InventoryGui gui)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			CraftingRequirements.VisibleRequirements.Clear();
			CraftingRequirements.VisibleRequirementCandidates.Clear();
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			int selectedCraftingQuality = GetSelectedCraftingQuality(gui);
			if ((Object)(object)recipe == (Object)null || recipe.m_resources == null)
			{
				return CraftingRequirements.VisibleRequirements;
			}
			if (IsJewelcraftingSocketTabActive(gui) && ShouldHideJewelcraftingSocketRequirements(gui.m_selectedRecipe))
			{
				return CraftingRequirements.VisibleRequirements;
			}
			Player localPlayer = Player.m_localPlayer;
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (val != null && !((Object)(object)val.m_resItem == (Object)null) && val.GetAmount(selectedCraftingQuality) > 0 && (!recipe.m_requireOnlyOneIngredient || !((Object)(object)localPlayer != (Object)null) || val.m_resItem.m_itemData?.m_shared == null || localPlayer.IsKnownMaterial(val.m_resItem.m_itemData.m_shared.m_name)))
				{
					CraftingRequirements.VisibleRequirementCandidates.Add(val);
				}
			}
			int num = 0;
			if (CraftingRequirements.VisibleRequirementCandidates.Count > 4)
			{
				int num2 = Mathf.CeilToInt((float)CraftingRequirements.VisibleRequirementCandidates.Count / 4f);
				num = (int)Time.fixedTime % Mathf.Max(1, num2) * 4;
			}
			for (int j = num; j < CraftingRequirements.VisibleRequirementCandidates.Count; j++)
			{
				if (CraftingRequirements.VisibleRequirements.Count >= 4)
				{
					break;
				}
				CraftingRequirements.VisibleRequirements.Add(CraftingRequirements.VisibleRequirementCandidates[j]);
			}
			return CraftingRequirements.VisibleRequirements;
		}

		private static bool ShouldShowCraftingStatusHud(InventoryGui gui)
		{
			if (ShouldShowUpgradeCraftingStatusHud(gui))
			{
				return true;
			}
			if (IsJewelcraftingSocketTabActive(gui))
			{
				return true;
			}
			if (IsJewelcraftingGemcutterStationActive() && IsCraftingCraftTabSelected(gui))
			{
				return IsJewelcraftingGemCuttingRecipe(((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe);
			}
			return false;
		}

		private static bool ShouldShowUpgradeCraftingStatusHud(InventoryGui gui)
		{
			if (gui.InUpradeTab() && !IsJewelcraftingSocketTabActive(gui) && !IsRecycleNReclaimReclaimTabActive(gui) && ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData?.m_shared != null)
			{
				return (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe != (Object)null;
			}
			return false;
		}

		private static void LayoutCraftingStatusHud(InventoryGui gui, RectTransform grid, bool updateLayout)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			string craftingStatusHudText = GetCraftingStatusHudText(gui);
			if (string.IsNullOrWhiteSpace(craftingStatusHudText))
			{
				HideCraftingSocketWarning();
				return;
			}
			RectTransform val = EnsureCraftingSocketWarning(gui);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)CraftingUi.SocketWarningText == (Object)null))
			{
				Vector2 val2 = GetCraftingGridCellPosition(grid, 0, 9) + CraftingBottomControlsFixedOffset;
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(568f, 58f);
				CraftingStatusHudStamp stamp = new CraftingStatusHudStamp(((Object)gui.m_crafting).GetInstanceID(), ((Object)grid).GetInstanceID(), val2.x, val2.y, val3.x, val3.y, craftingStatusHudText);
				if (updateLayout || !CraftingController.CanReuseSocketWarning(stamp))
				{
					SetCraftingTopLeftRect(gui.m_crafting, val, val2, val3);
					ConfigureCraftingSocketWarningText(CraftingUi.SocketWarningText, craftingStatusHudText);
					CraftingController.StoreSocketWarningStamp(stamp);
				}
				((Transform)val).SetAsLastSibling();
				((Component)val).gameObject.SetActive(true);
			}
		}

		private static string GetCraftingStatusHudText(InventoryGui gui)
		{
			if (ShouldShowUpgradeCraftingStatusHud(gui))
			{
				return GetUpgradeCraftingStatusText(gui);
			}
			return StripRichText(((Object)(object)gui.m_itemCraftType != (Object)null && !IsUnityNull((Object?)(object)gui.m_itemCraftType)) ? (gui.m_itemCraftType.text ?? "") : "").Trim();
		}

		private static string GetUpgradeCraftingStatusText(InventoryGui gui)
		{
			ItemData itemData = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData;
			if (itemData?.m_shared == null)
			{
				return "";
			}
			int num = Mathf.Max(1, itemData.m_quality);
			int num2 = Mathf.Max(num, itemData.m_shared.m_maxQuality);
			if (num >= num2)
			{
				if (Localization.instance == null)
				{
					return "Max quality";
				}
				return Localization.instance.Localize("$inventory_maxquality");
			}
			string localizedItemName = GetLocalizedItemName(itemData);
			string text = (num + 1).ToString();
			if (Localization.instance == null)
			{
				return "Upgrade " + localizedItemName + " quality to " + text;
			}
			return Localization.instance.Localize("$inventory_upgrade", new string[2] { localizedItemName, text });
		}

		private static RectTransform? EnsureCraftingSocketWarning(InventoryGui gui)
		{
			//IL_00b6: 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_0179: 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_012d: Expected O, but got Unknown
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			if ((Object)(object)CraftingUi.SocketWarningRect != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.SocketWarningRect) && (Object)(object)((Transform)CraftingUi.SocketWarningRect).parent == (Object)(object)gui.m_crafting)
			{
				return CraftingUi.SocketWarningRect;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingSocketWarning");
			CraftingUi.SocketWarningRect = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)CraftingUi.SocketWarningRect == (Object)null)
			{
				CraftingUi.SocketWarningRect = new GameObject("InventorySlots_CraftingSocketWarning", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			}
			((Transform)CraftingUi.SocketWarningRect).SetParent((Transform)(object)gui.m_crafting, false);
			Image val2 = default(Image);
			if (((Component)CraftingUi.SocketWarningRect).TryGetComponent<Image>(ref val2))
			{
				((Behaviour)val2).enabled = false;
				((Graphic)val2).raycastTarget = false;
			}
			Transform val3 = ((Transform)CraftingUi.SocketWarningRect).Find("Text");
			RectTransform rect;
			if ((Object)(object)val3 != (Object)null)
			{
				TMP_Text component = ((Component)val3).GetComponent<TMP_Text>();
				if (component != null)
				{
					rect = (RectTransform)val3;
					CraftingUi.SocketWarningText = component;
					goto IL_015f;
				}
			}
			rect = CreateTextRect("Text", (Transform)(object)CraftingUi.SocketWarningRect, out TMP_Text text);
			CraftingUi.SocketWarningText = text;
			goto IL_015f;
			IL_015f:
			SetStretchRectLayout(rect, new Vector2(12f, 5f), new Vector2(-12f, -5f));
			TMP_Text? socketWarningText = CraftingUi.SocketWarningText;
			ConfigureCraftingSocketWarningText(socketWarningText, socketWarningText.text);
			return CraftingUi.SocketWarningRect;
		}

		private static void ConfigureCraftingSocketWarningText(TMP_Text text, string warning)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)text == (Object)null) && !IsUnityNull((Object?)(object)text))
			{
				ApplyDefaultFontAsset(text);
				text.text = warning;
				((Graphic)text).color = new Color(1f, 0.72f, 0.28f, 1f);
				text.alignment = (TextAlignmentOptions)514;
				text.textWrappingMode = (TextWrappingModes)1;
				text.overflowMode = (TextOverflowModes)3;
				text.enableAutoSizing = true;
				text.fontSizeMin = 12f;
				text.fontSizeMax = 18f;
				((Graphic)text).raycastTarget = false;
			}
		}

		private static void HideCraftingSocketWarning()
		{
			if ((Object)(object)CraftingUi.SocketWarningRect != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.SocketWarningRect))
			{
				((Component)CraftingUi.SocketWarningRect).gameObject.SetActive(false);
			}
			CraftingController.ResetSocketWarningStamp();
		}

		private static int GetSelectedCraftingQuality(InventoryGui gui)
		{
			if (IsJewelcraftingSocketTabActive(gui))
			{
				return 1;
			}
			if (((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null)
			{
				return ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData.m_quality + 1;
			}
			return 1;
		}

		private static Vector2 GetCraftingGridCellPosition(RectTransform grid, int column, int row)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			return grid.anchoredPosition + new Vector2((float)column * 72f, (float)(-row) * 72f);
		}

		private static Vector2 GetCraftingGridCenteredPosition(RectTransform grid, int column, int row, Vector2 size, int columnSpan = 1)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)(Mathf.Max(1, columnSpan) - 1) * 72f + 64f;
			return GetCraftingGridCellPosition(grid, column, row) + new Vector2((num - size.x) * 0.5f, (0f - (64f - size.y)) * 0.5f);
		}

		private static RectTransform? EnsureCraftingCountInput(InventoryGui gui)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_0152: 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_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_craftingCountInputRect != (Object)null && !IsUnityNull((Object?)(object)_craftingCountInputRect) && (Object)(object)((Transform)_craftingCountInputRect).parent == (Object)(object)gui.m_crafting)
			{
				return _craftingCountInputRect;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingCountInput");
			_craftingCountInputRect = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingCountInputRect == (Object)null)
			{
				_craftingCountInputRect = new GameObject("InventorySlots_CraftingCountInput", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(TMP_InputField)
				}).GetComponent<RectTransform>();
				((Transform)_craftingCountInputRect).SetParent((Transform)(object)gui.m_crafting, false);
				Image component = ((Component)_craftingCountInputRect).GetComponent<Image>();
				component.sprite = GetSolidUiSprite();
				((Graphic)component).color = new Color(0f, 0f, 0f, 0.46f);
				((Graphic)component).raycastTarget = true;
				RectTransform component2 = new GameObject("Text Area", new Type[2]
				{
					typeof(RectTransform),
					typeof(RectMask2D)
				}).GetComponent<RectTransform>();
				((Transform)component2).SetParent((Transform)(object)_craftingCountInputRect, false);
				SetStretchRectLayout(component2, new Vector2(22f, 3f), new Vector2(-4f, -3f));
				CraftingUi.CountInputViewport = component2;
				SetStretchRectLayout(CreateTextRect("Text", (Transform)(object)component2, out TMP_Text text), Vector2.zero, Vector2.zero);
				text.fontSize = 22f;
				text.alignment = (TextAlignmentOptions)514;
				((Graphic)text).color = Color.white;
				text.textWrappingMode = (TextWrappingModes)0;
				_craftingCountInput = ((Component)_craftingCountInputRect).GetComponent<TMP_InputField>();
				_craftingCountInput.textViewport = component2;
				_craftingCountInput.textComponent = text;
				((Selectable)_craftingCountInput).targetGraphic = (Graphic)(object)component;
				_craftingCountInput.contentType = (ContentType)2;
				_craftingCountInput.characterValidation = (CharacterValidation)2;
				_craftingCountInput.lineType = (LineType)0;
				_craftingCountInput.characterLimit = 2;
				_craftingCountInput.SetTextWithoutNotify("1");
				((UnityEvent<string>)(object)_craftingCountInput.onEndEdit).AddListener((UnityAction<string>)delegate(string value)
				{
					SetCraftingCount(ParseCraftingCount(value));
				});
			}
			else
			{
				_craftingCountInput = ((Component)_craftingCountInputRect).GetComponent<TMP_InputField>();
				CraftingUiRuntimeState craftingUi = CraftingUi;
				TMP_InputField? craftingCountInput = _craftingCountInput;
				craftingUi.CountInputViewport = ((craftingCountInput != null) ? craftingCountInput.textViewport : null);
				if ((Object)(object)CraftingUi.CountInputViewport == (Object)null || IsUnityNull((Object?)(object)CraftingUi.CountInputViewport))
				{
					ref RectTransform? countInputViewport = ref CraftingUi.CountInputViewport;
					Transform obj = ((Transform)_craftingCountInputRect).Find("Text Area");
					countInputViewport = (RectTransform?)(object)((obj is RectTransform) ? obj : null);
				}
			}
			EnsureCraftingCountWheelIcon(_craftingCountInputRect, locked: false);
			return _craftingCountInputRect;
		}

		private static RectTransform? EnsureCraftingUpgradeProgression(InventoryGui gui)
		{
			//IL_00a0: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_craftingUpgradeProgressionRect != (Object)null && !IsUnityNull((Object?)(object)_craftingUpgradeProgressionRect) && (Object)(object)((Transform)_craftingUpgradeProgressionRect).parent == (Object)(object)gui.m_crafting)
			{
				return _craftingUpgradeProgressionRect;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingUpgradeProgression");
			_craftingUpgradeProgressionRect = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingUpgradeProgressionRect == (Object)null)
			{
				_craftingUpgradeProgressionRect = new GameObject("InventorySlots_CraftingUpgradeProgression", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(UITooltip)
				}).GetComponent<RectTransform>();
				((Transform)_craftingUpgradeProgressionRect).SetParent((Transform)(object)gui.m_crafting, false);
				Image component = ((Component)_craftingUpgradeProgressionRect).GetComponent<Image>();
				component.sprite = GetSolidUiSprite();
				((Graphic)component).color = new Color(0f, 0f, 0f, 0.42f);
				((Graphic)component).raycastTarget = true;
				TMP_Text text;
				RectTransform rect = CreateTextRect("Text", (Transform)(object)_craftingUpgradeProgressionRect, out text);
				CraftingUi.UpgradeProgressionText = text;
				SetStretchRectLayout(rect, new Vector2(4f, 3f), new Vector2(-4f, -3f));
				text.fontSize = 20f;
				text.alignment = (TextAlignmentOptions)514;
				((Graphic)text).color = new Color(1f, 0.84f, 0.42f, 1f);
				text.textWrappingMode = (TextWrappingModes)0;
				text.overflowMode = (TextOverflowModes)0;
				((Graphic)text).raycastTarget = false;
			}
			else
			{
				CraftingUiRuntimeState craftingUi = CraftingUi;
				Transform obj = ((Transform)_craftingUpgradeProgressionRect).Find("Text");
				craftingUi.UpgradeProgressionText = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
			}
			return _craftingUpgradeProgressionRect;
		}

		private static void UpdateCraftingUpgradeProgression(InventoryGui gui)
		{
			if ((Object)(object)_craftingUpgradeProgressionRect == (Object)null)
			{
				return;
			}
			ItemData itemData = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData;
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			bool flag = itemData?.m_shared != null && (Object)(object)recipe != (Object)null;
			((Component)_craftingUpgradeProgressionRect).gameObject.SetActive(flag);
			if (!flag)
			{
				return;
			}
			int num = Mathf.Max(1, itemData.m_quality);
			int num2 = Mathf.Max(num, itemData.m_shared.m_maxQuality);
			int num3 = Mathf.Min(num + 1, num2);
			string text = ((num < num2) ? $"{num} > {num3}" : LocalizeUi("$inventoryslots_max", "Max"));
			if ((Object)(object)CraftingUi.UpgradeProgressionText != (Object)null)
			{
				CraftingTextCacheState craftingTextCache = GetCraftingTextCache(((Component)_craftingUpgradeProgressionRect).gameObject);
				CraftingTextStamp craftingTextStamp = new CraftingTextStamp("upgrade", text, "", 20f);
				if (!craftingTextCache.LastTextStamp.Equals(craftingTextStamp))
				{
					ApplyDefaultFontAsset(CraftingUi.UpgradeProgressionText);
					CraftingUi.UpgradeProgressionText.text = text;
					CraftingUi.UpgradeProgressionText.enableAutoSizing = true;
					CraftingUi.UpgradeProgressionText.fontSizeMin = 10f;
					CraftingUi.UpgradeProgressionText.fontSizeMax = 20f;
					craftingTextCache.LastTextStamp = craftingTextStamp;
				}
			}
			ConfigureSimpleTooltip(((Component)_craftingUpgradeProgressionRect).gameObject, GetLocalizedItemName(itemData) + " " + text, enabled: true);
		}

		private static void EnsureCraftingCountWheelIcon(RectTransform countRect, bool locked)
		{
			//IL_0016: 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_0040: 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_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_0080: 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_00cc: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = EnsureHintImage(countRect, "InventorySlots_CraftingCountWheelIcon");
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(0f, 0.5f);
			obj.pivot = new Vector2(0f, 0.5f);
			obj.anchoredPosition = new Vector2(5f, 0f);
			obj.sizeDelta = new Vector2(13f, 19f);
			((Transform)obj).localScale = Vector3.one;
			((Transform)obj).localRotation = Quaternion.identity;
			((Transform)obj).SetAsLastSibling();
			Image component = ((Component)obj).GetComponent<Image>();
			component.sprite = GetMouseWheelHintSprite();
			component.type = (Type)0;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			((Graphic)component).color = (locked ? new Color(0.68f, 0.88f, 1f, 0.32f) : new Color(0.68f, 0.88f, 1f, 0.82f));
			RectTransform val = CraftingUi.CountInputViewport;
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)((Transform)val).parent != (Object)(object)countRect)
			{
				Transform obj2 = ((Transform)countRect).Find("Text Area");
				val = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				CraftingUi.CountInputViewport = val;
			}
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
			{
				SetStretchRectLayout(val, new Vector2(22f, 3f), new Vector2(-4f, -3f));
			}
		}

		private static void UpdateCraftingRequiredStationLevel(InventoryGui gui, Vector2 anchoredPosition, bool updateLayout)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_010d: 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_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_0163: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: 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_02ba: Unknown result type (might be due to invalid IL or missing references)
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			if ((Object)(object)gui.m_minStationLevelIcon == (Object)null || (Object)(object)gui.m_minStationLevelText == (Object)null)
			{
				return;
			}
			RectTransform val = (RectTransform)((Component)gui.m_minStationLevelIcon).transform;
			RectTransform val2 = (RectTransform)gui.m_minStationLevelText.transform;
			SuppressCraftingRequiredStationLevelOriginalBackground(gui, val, val2);
			if ((Object)(object)recipe == (Object)null)
			{
				((Component)gui.m_minStationLevelIcon).gameObject.SetActive(false);
				((Component)gui.m_minStationLevelText).gameObject.SetActive(false);
				HideCraftingRequiredStationLevelTooltip();
				return;
			}
			int num = ((((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null) ? 1 : (((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData.m_quality + 1));
			bool flag = num <= recipe.m_item.m_itemData.m_shared.m_maxQuality;
			CraftingStation requiredStation = recipe.GetRequiredStation(num);
			if ((Object)(object)requiredStation == (Object)null || !flag)
			{
				((Component)gui.m_minStationLevelIcon).gameObject.SetActive(false);
				((Component)gui.m_minStationLevelText).gameObject.SetActive(false);
				HideCraftingRequiredStationLevelTooltip();
				return;
			}
			int requiredStationLevel = recipe.GetRequiredStationLevel(num);
			bool flag2 = !IsVeiledRecipeMasked(gui.m_selectedRecipe) || KnowsVeiledRecipeStationRequirement(recipe, num);
			Vector2 val3 = anchoredPosition + new Vector2(10f, -10f);
			if (updateLayout)
			{
				SetCraftingTopLeftRect(gui.m_crafting, val, val3, new Vector2(44f, 44f));
				SetCraftingTopLeftRect(gui.m_crafting, val2, val3 + new Vector2(0f, -24f), new Vector2(44f, 20f));
			}
			if ((Object)(object)requiredStation.m_icon != (Object)null)
			{
				gui.m_minStationLevelIcon.sprite = requiredStation.m_icon;
				gui.m_minStationLevelIcon.overrideSprite = requiredStation.m_icon;
			}
			((Graphic)gui.m_minStationLevelIcon).color = Color.white;
			((Component)gui.m_minStationLevelIcon).gameObject.SetActive(true);
			ApplyDefaultFontAsset(gui.m_minStationLevelText);
			gui.m_minStationLevelText.text = (flag2 ? requiredStationLevel.ToString() : GetVeiledRecipeUnknownRequirementText());
			gui.m_minStationLevelText.alignment = (TextAlignmentOptions)1028;
			gui.m_minStationLevelText.enableAutoSizing = true;
			gui.m_minStationLevelText.fontSizeMin = 12f;
			gui.m_minStationLevelText.fontSizeMax = 18f;
			CraftingStation val4 = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetCurrentCraftingStation() : null);
			bool flag3 = flag2 && ((Object)(object)val4 == (Object)null || val4.GetLevel(true) < requiredStationLevel);
			((Graphic)gui.m_minStationLevelText).color = ((flag3 && !ZoneSystem.instance.GetGlobalKey((GlobalKeys)20) && Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : gui.m_minStationLevelBasecolor);
			((Component)gui.m_minStationLevelText).gameObject.SetActive(true);
			RectTransform val5 = EnsureCraftingRequiredStationLevelHitbox(gui, val3, 44f);
			if ((Object)(object)val5 != (Object)null)
			{
				ConfigureSimpleTooltip(((Component)val5).gameObject, flag2 ? GetCraftingStationDisplayName(requiredStation) : GetVeiledRecipeUnknownNameText(), enabled: true);
			}
		}

		private static RectTransform? EnsureCraftingRequiredStationLevelHitbox(InventoryGui gui, Vector2 iconPosition, float iconSize)
		{
			//IL_008b: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			RectTransform val = CraftingUi.RequiredStationLevelHitbox;
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)((Transform)val).parent != (Object)(object)gui.m_crafting)
			{
				Transform obj = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingRequiredStationHitbox");
				val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
				{
					val = new GameObject("InventorySlots_CraftingRequiredStationHitbox", new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					}).GetComponent<RectTransform>();
				}
				CraftingUi.RequiredStationLevelHitbox = val;
			}
			SetCraftingTopLeftRect(gui.m_crafting, val, iconPosition, new Vector2(iconSize, iconSize));
			((Component)val).gameObject.SetActive(true);
			Image obj2 = ((Component)val).GetComponent<Image>() ?? ((Component)val).gameObject.AddComponent<Image>();
			obj2.sprite = GetSolidUiSprite();
			((Graphic)obj2).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)obj2).raycastTarget = true;
			if ((Object)(object)((Transform)val).parent != (Object)null && ((Transform)val).GetSiblingIndex() != ((Transform)val).parent.childCount - 1)
			{
				((Transform)val).SetAsLastSibling();
			}
			return val;
		}

		private static void HideCraftingRequiredStationLevelTooltip()
		{
			RectTransform requiredStationLevelHitbox = CraftingUi.RequiredStationLevelHitbox;
			if ((Object)(object)requiredStationLevelHitbox == (Object)null || IsUnityNull((Object?)(object)requiredStationLevelHitbox))
			{
				CraftingUi.RequiredStationLevelHitbox = null;
				return;
			}
			ConfigureSimpleTooltip(((Component)requiredStationLevelHitbox).gameObject, "", enabled: false);
			((Component)requiredStationLevelHitbox).gameObject.SetActive(false);
		}

		private static void SuppressCraftingRequiredStationLevelOriginalBackground(InventoryGui gui)
		{
			//IL_0029: 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_0043: Expected O, but got Unknown
			//IL_0043: Expected O, but got Unknown
			if (!((Object)(object)gui.m_minStationLevelIcon == (Object)null) && !((Object)(object)gui.m_minStationLevelText == (Object)null))
			{
				SuppressCraftingRequiredStationLevelOriginalBackground(gui, (RectTransform)((Component)gui.m_minStationLevelIcon).transform, (RectTransform)gui.m_minStationLevelText.transform);
			}
		}

		private static void SuppressCraftingRequiredStationLevelOriginalBackground(InventoryGui gui, RectTransform iconRect, RectTransform textRect)
		{
			HideCraftingRequiredStationLevelOriginalBackground(gui, iconRect, textRect);
		}

		private static void HideCraftingRequiredStationLevelOriginalBackground(InventoryGui gui, RectTransform iconRect, RectTransform textRect)
		{
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return;
			}
			if ((Object)(object)CraftingUi.RequiredStationLevelOriginalRoot == (Object)null || IsUnityNull((Object?)(object)CraftingUi.RequiredStationLevelOriginalRoot))
			{
				CraftingUi.RequiredStationLevelOriginalRoot = FindCraftingRequiredStationLevelOriginalRoot(gui, iconRect, textRect);
			}
			Transform requiredStationLevelOriginalRoot = CraftingUi.RequiredStationLevelOriginalRoot;
			if ((Object)(object)requiredStationLevelOriginalRoot == (Object)null || IsUnityNull((Object?)(object)requiredStationLevelOriginalRoot) || (Object)(object)requiredStationLevelOriginalRoot == (Object)(object)gui.m_crafting || !requiredStationLevelOriginalRoot.IsChildOf((Transform)(object)gui.m_crafting))
			{
				CraftingUi.RequiredStationLevelOriginalRoot = FindCraftingRequiredStationLevelOriginalRoot(gui, iconRect, textRect);
				requiredStationLevelOriginalRoot = CraftingUi.RequiredStationLevelOriginalRoot;
				if ((Object)(object)requiredStationLevelOriginalRoot == (Object)null || IsUnityNull((Object?)(object)requiredStationLevelOriginalRoot) || (Object)(object)requiredStationLevelOriginalRoot == (Object)(object)gui.m_crafting || !requiredStationLevelOriginalRoot.IsChildOf((Transform)(object)gui.m_crafting))
				{
					CraftingUi.RequiredStationLevelOriginalRoot = null;
					return;
				}
			}
			Image[] componentsInChildren = ((Component)requiredStationLevelOriginalRoot).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && !((Object)(object)val == (Object)(object)gui.m_minStationLevelIcon) && !IsOwnedCraftingUiTransform(((Component)val).transform))
				{
					if (!CraftingVanillaPanelBackgroundStates.ContainsKey(val))
					{
						CraftingVanillaPanelBackgroundStates[val] = ((Behaviour)val).enabled;
					}
					((Behaviour)val).enabled = false;
					((Graphic)val).raycastTarget = false;
				}
			}
		}

		private static Transform? FindCraftingRequiredStationLevelOriginalRoot(InventoryGui gui, RectTransform iconRect, RectTransform textRect)
		{
			Transform parent = ((Transform)iconRect).parent;
			Transform parent2 = ((Transform)textRect).parent;
			if ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)gui.m_crafting && (Object)(object)parent2 != (Object)null && ((Object)(object)parent2 == (Object)(object)parent || parent2.IsChildOf(parent)))
			{
				return parent;
			}
			if ((Object)(object)parent2 != (Object)null && (Object)(object)parent2 != (Object)(object)gui.m_crafting && (Object)(object)parent != (Object)null && parent.IsChildOf(parent2))
			{
				return parent2;
			}
			if (!((Object)(object)parent != (Object)null) || !((Object)(object)parent != (Object)(object)gui.m_crafting))
			{
				return null;
			}
			return parent;
		}

		private static void UpdateCraftingCountInputState(InventoryGui gui)
		{
			//IL_007c: 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)
			if (!((Object)(object)_craftingCountInput == (Object)null) && !((Object)(object)_craftingCountInputRect == (Object)null))
			{
				bool flag = IsCraftingCountInputLocked(gui);
				((Selectable)_craftingCountInput).interactable = !flag;
				_craftingCountInput.readOnly = flag;
				Image val = default(Image);
				if (((Component)_craftingCountInputRect).TryGetComponent<Image>(ref val))
				{
					((Graphic)val).color = (flag ? new Color(0f, 0f, 0f, 0.28f) : new Color(0f, 0f, 0f, 0.46f));
				}
				EnsureCraftingCountWheelIcon(_craftingCountInputRect, flag);
			}
		}

		private static void UpdateCraftingCraftButtonLabel(InventoryGui gui)
		{
			if ((Object)(object)gui.m_craftButton == (Object)null || (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)null)
			{
				return;
			}
			string text = (IsJewelcraftingSocketTabActive(gui) ? LocalizeUi("$jc_add_socket_button", "Socket") : ((((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null) ? LocalizeUi("$inventory_upgradebutton", "Upgrade") : LocalizeUi("$inventory_craftbutton", "Craft")));
			int effectiveCraftingCount = GetEffectiveCraftingCount(gui);
			if (((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null && effectiveCraftingCount > 1)
			{
				text = FormatCraftingCountLabel("$inventoryslots_craft_button_count_format", "{label} x{count}", text, effectiveCraftingCount);
			}
			CraftingTextCacheState craftingTextCache = GetCraftingTextCache(((Component)gui.m_craftButton).gameObject);
			CraftingTextStamp craftingTextStamp = new CraftingTextStamp("craft", text, craftingTextCache.ChildSignature);
			if (craftingTextCache.LastTextStamp.Equals(craftingTextStamp) && TextCacheMatches(craftingTextCache, text))
			{
				ApplyCraftingActionButtonTextStateColor(gui.m_craftButton, ((Selectable)gui.m_craftButton).interactable);
				return;
			}
			TMP_Text[] tmpTexts = craftingTextCache.TmpTexts;
			foreach (TMP_Text val in tmpTexts)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					ApplyDefaultFontAsset(val);
					if (val.text != text)
					{
						val.text = text;
					}
				}
			}
			Text[] legacyTexts = craftingTextCache.LegacyTexts;
			foreach (Text val2 in legacyTexts)
			{
				if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2) && val2.text != text)
				{
					val2.text = text;
				}
			}
			craftingTextCache.LastTextStamp = craftingTextStamp;
			SetActionButtonTextAutoSize(gui.m_craftButton);
			ApplyCraftingActionButtonTextStateColor(gui.m_craftButton, ((Selectable)gui.m_craftButton).interactable);
		}

		private static void UpdateJewelcraftingSocketCraftButtonState(InventoryGui gui)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (IsJewelcraftingSocketTabActive(gui) && !((Object)(object)gui.m_craftButton == (Object)null))
			{
				bool flag = CanAffordJewelcraftingSocketAttempt(gui.m_selectedRecipe);
				bool flag2 = CanAttemptJewelcraftingSocket(gui.m_selectedRecipe);
				((Selectable)gui.m_craftButton).interactable = flag2;
				ApplyCraftingActionButtonTextStateColor(gui.m_craftButton, flag2);
				UITooltip component = ((Component)gui.m_craftButton).GetComponent<UITooltip>();
				if (!((Object)(object)component == (Object)null) && !IsUnityNull((Object?)(object)component))
				{
					component.m_text = ((flag2 || flag) ? "" : LocalizeUi("$msg_missingrequirement", "Missing requirement"));
				}
			}
		}

		private static void ApplyCraftingActionButtonTextStateColor(Button button, bool interactable)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0023: 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_004c: 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_008d: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			Color craftingActionButtonTextStateColor = GetCraftingActionButtonTextStateColor(button, interactable);
			CraftingTextCacheState craftingTextCache = GetCraftingTextCache(((Component)button).gameObject);
			CraftingTextColorStamp craftingTextColorStamp = new CraftingTextColorStamp(interactable, craftingActionButtonTextStateColor.r, craftingActionButtonTextStateColor.g, craftingActionButtonTextStateColor.b, craftingActionButtonTextStateColor.a, craftingTextCache.ChildSignature);
			if (craftingTextCache.LastColorStamp.Equals(craftingTextColorStamp) && TextColorCacheMatches(craftingTextCache, craftingActionButtonTextStateColor))
			{
				return;
			}
			TMP_Text[] tmpTexts = craftingTextCache.TmpTexts;
			foreach (TMP_Text val in tmpTexts)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && !ColorsApproximatelyEqual(((Graphic)val).color, craftingActionButtonTextStateColor))
				{
					((Graphic)val).color = craftingActionButtonTextStateColor;
				}
			}
			Text[] legacyTexts = craftingTextCache.LegacyTexts;
			foreach (Text val2 in legacyTexts)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2) && !ColorsApproximatelyEqual(((Graphic)val2).color, craftingActionButtonTextStateColor))
				{
					((Graphic)val2).color = craftingActionButtonTextStateColor;
				}
			}
			craftingTextCache.LastColorStamp = craftingTextColorStamp;
		}

		private static Color GetCraftingActionButtonTextStateColor(Button button, bool interactable)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_001a: 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_0026: 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_0038: 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_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)
			ColorBlock colors = ((Selectable)button).colors;
			Color val = (interactable ? ((ColorBlock)(ref colors)).normalColor : ((ColorBlock)(ref colors)).disabledColor);
			if (interactable && Mathf.Max(new float[3] { val.r, val.g, val.b }) < 0.65f)
			{
				val = Color.white;
			}
			if (val.a < 0.25f)
			{
				val.a = 1f;
			}
			return val;
		}

		private static bool TextCacheMatches(CraftingTextCacheState cache, string label)
		{
			bool result = false;
			TMP_Text[] tmpTexts = cache.TmpTexts;
			foreach (TMP_Text val in tmpTexts)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					result = true;
					if (!string.Equals(val.text, label, StringComparison.Ordinal))
					{
						return false;
					}
				}
			}
			Text[] legacyTexts = cache.LegacyTexts;
			foreach (Text val2 in legacyTexts)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					result = true;
					if (!string.Equals(val2.text, label, StringComparison.Ordinal))
					{
						return false;
					}
				}
			}
			return result;
		}

		private static bool TextColorCacheMatches(CraftingTextCacheState cache, Color color)
		{
			//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_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)
			bool result = false;
			TMP_Text[] tmpTexts = cache.TmpTexts;
			foreach (TMP_Text val in tmpTexts)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					result = true;
					if (!ColorsApproximatelyEqual(((Graphic)val).color, color))
					{
						return false;
					}
				}
			}
			Text[] legacyTexts = cache.LegacyTexts;
			foreach (Text val2 in legacyTexts)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					result = true;
					if (!ColorsApproximatelyEqual(((Graphic)val2).color, color))
					{
						return false;
					}
				}
			}
			return result;
		}

		private static void UpdateCraftingProgressLabel(InventoryGui gui)
		{
			Transform craftProgressPanel = gui.m_craftProgressPanel;
			RectTransform val = (RectTransform)(object)((craftProgressPanel is RectTransform) ? craftProgressPanel : null);
			if (val == null || !((Component)val).gameObject.activeInHierarchy)
			{
				return;
			}
			CraftingTextCacheState craftingProgressTextCache = GetCraftingProgressTextCache(val);
			string text = GetCraftingProgressBaseLabel(craftingProgressTextCache);
			if (TryGetCraftingProgressLabelCount(gui, out var count))
			{
				text = FormatCraftingCountLabel("$inventoryslots_crafting_progress_count_format", "{label} x{count}", text, count);
			}
			CraftingTextStamp craftingTextStamp = new CraftingTextStamp("progress", text, craftingProgressTextCache.ChildSignature);
			if (craftingProgressTextCache.LastTextStamp.Equals(craftingTextStamp) && TextCacheMatches(craftingProgressTextCache, text))
			{
				return;
			}
			TMP_Text[] tmpTexts = craftingProgressTextCache.TmpTexts;
			foreach (TMP_Text val2 in tmpTexts)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					ApplyDefaultFontAsset(val2);
					if (val2.text != text)
					{
						val2.text = text;
					}
					val2.enableAutoSizing = true;
					val2.fontSizeMin = 10f;
					val2.fontSizeMax = Mathf.Min(Mathf.Max(val2.fontSizeMax, 14f), 18f);
					val2.alignment = (TextAlignmentOptions)514;
				}
			}
			Text[] legacyTexts = craftingProgressTextCache.LegacyTexts;
			foreach (Text val3 in legacyTexts)
			{
				if ((Object)(object)val3 != (Object)null && !IsUnityNull((Object?)(object)val3) && val3.text != text)
				{
					val3.text = text;
				}
			}
			craftingProgressTextCache.LastTextStamp = craftingTextStamp;
		}

		private static bool TryGetCraftingProgressLabelCount(InventoryGui gui, out int count)
		{
			count = 0;
			if (gui.m_craftTimer < 0f || (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)null || ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null)
			{
				return false;
			}
			if (CraftingQueue.QueueTotal > 1 && (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)(object)CraftingQueue.QueueRecipe && gui.m_selectedVariant == CraftingQueue.QueueVariant)
			{
				int num = ((gui.m_craftTimer >= 0f) ? 1 : 0);
				count = Mathf.Clamp(CraftingQueue.QueueRemaining + num, 1, CraftingQueue.QueueTotal);
				return true;
			}
			if (gui.m_multiCrafting && gui.m_multiCraftAmount > 1)
			{
				count = Mathf.Clamp(gui.m_multiCraftAmount, 1, 99);
				return true;
			}
			if (CraftingQueue.ProgressLabelCount > 1 && (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)(object)CraftingQueue.ProgressLabelRecipe && gui.m_selectedVariant == CraftingQueue.ProgressLabelVariant)
			{
				count = Mathf.Clamp(CraftingQueue.ProgressLabelCount, 1, 99);
				return true;
			}
			int craftingCount = GetCraftingCount();
			if (craftingCount <= 1)
			{
				return false;
			}
			count = craftingCount;
			return true;
		}

		private static CraftingTextCacheState GetCraftingProgressTextCache(RectTransform progressPanel)
		{
			CraftingTextCacheState craftingTextCache = GetCraftingTextCache(((Component)progressPanel).gameObject);
			Transform obj = ((Transform)progressPanel).Find("Text");
			TMP_Text val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
			Transform obj2 = ((Transform)progressPanel).Find("Text");
			Text val2 = ((obj2 != null) ? ((Component)obj2).GetComponent<Text>() : null);
			bool flag = false;
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && !craftingTextCache.TmpTexts.Contains(val))
			{
				craftingTextCache.TmpTexts = craftingTextCache.TmpTexts.Concat((IEnumerable<TMP_Text>)(object)new TMP_Text[1] { val }).ToArray();
				flag = true;
			}
			if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2) && !craftingTextCache.LegacyTexts.Contains(val2))
			{
				craftingTextCache.LegacyTexts = craftingTextCache.LegacyTexts.Concat((IEnumerable<Text>)(object)new Text[1] { val2 }).ToArray();
				flag = true;
			}
			if (craftingTextCache.TmpTexts.Length == 0 && craftingTextCache.LegacyTexts.Length == 0)
			{
				TMP_Text val3 = EnsureCraftingProgressLabel(progressPanel);
				if ((Object)(object)val3 != (Object)null && !IsUnityNull((Object?)(object)val3))
				{
					craftingTextCache.TmpTexts = (TMP_Text[])(object)new TMP_Text[1] { val3 };
					flag = true;
				}
			}
			if (flag)
			{
				craftingTextCache.LastTextStamp = default(CraftingTextStamp);
				craftingTextCache.ProgressBaseLabel = "";
			}
			return craftingTextCache;
		}

		private static TMP_Text? EnsureCraftingProgressLabel(RectTransform progressPanel)
		{
			//IL_0065: 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_007b: 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_0091: 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)
			Transform val = ((Transform)progressPanel).Find("Text");
			if ((Object)(object)val != (Object)null)
			{
				TMP_Text component = ((Component)val).GetComponent<TMP_Text>();
				if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
				{
					return component;
				}
			}
			RectTransform val2 = (RectTransform)(((object)((val is RectTransform) ? val : null)) ?? ((object)new GameObject("Text", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>()));
			((Transform)val2).SetParent((Transform)(object)progressPanel, false);
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Transform)val2).localScale = Vector3.one;
			object obj = ((object)((Component)val2).GetComponent<TMP_Text>()) ?? ((object)((Component)val2).gameObject.AddComponent<TextMeshProUGUI>());
			ApplyDefaultFontAsset((TMP_Text?)obj);
			((TMP_Text)obj).text = LocalizeUi("$inventory_crafting", "Crafting");
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj).enableAutoSizing = true;
			((TMP_Text)obj).fontSizeMin = 10f;
			((TMP_Text)obj).fontSizeMax = 18f;
			((Graphic)obj).raycastTarget = false;
			return (TMP_Text?)obj;
		}

		private static string GetCraftingProgressBaseLabel(CraftingTextCacheState cache)
		{
			if (!string.IsNullOrWhiteSpace(cache.ProgressBaseLabel))
			{
				return cache.ProgressBaseLabel;
			}
			TMP_Text[] tmpTexts = cache.TmpTexts;
			foreach (TMP_Text val in tmpTexts)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					string text = StripCraftingProgressCounter(val.text);
					if (!string.IsNullOrWhiteSpace(text))
					{
						cache.ProgressBaseLabel = text;
						return cache.ProgressBaseLabel;
					}
				}
			}
			Text[] legacyTexts = cache.LegacyTexts;
			foreach (Text val2 in legacyTexts)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					string text2 = StripCraftingProgressCounter(val2.text);
					if (!string.IsNullOrWhiteSpace(text2))
					{
						cache.ProgressBaseLabel = text2;
						return cache.ProgressBaseLabel;
					}
				}
			}
			cache.ProgressBaseLabel = LocalizeUi("$inventory_crafting", "Crafting");
			return cache.ProgressBaseLabel;
		}

		private static string FormatCraftingCountLabel(string token, string fallback, string label, int count)
		{
			return LocalizeUi(token, fallback).Replace("{label}", label).Replace("{count}", count.ToString());
		}

		private static string StripCraftingProgressCounter(string value)
		{
			value = value.Trim();
			int num = value.LastIndexOf(' ');
			if (num <= 0)
			{
				return value;
			}
			if (IsCraftingProgressCounterSuffix(value.Substring(num + 1)))
			{
				return value.Substring(0, num);
			}
			return value;
		}

		private static bool IsCraftingProgressCounterSuffix(string suffix)
		{
			int num = suffix.IndexOf('/');
			int result;
			if (num > 0 && num < suffix.Length - 1)
			{
				if (int.TryParse(suffix.Substring(0, num), out result))
				{
					return int.TryParse(suffix.Substring(num + 1), out result);
				}
				return false;
			}
			if (suffix.Length > 1 && (suffix[0] == 'x' || suffix[0] == 'X'))
			{
				return int.TryParse(suffix.Substring(1), out result);
			}
			return false;
		}

		private static string LocalizeUi(string token, string fallback)
		{
			string text = ((Localization.instance != null) ? Localization.instance.Localize(token) : token);
			if (!string.IsNullOrWhiteSpace(text) && !(text == token))
			{
				return text;
			}
			return fallback;
		}

		private static string GetRequirementDisplayName(Requirement requirement)
		{
			if ((Object)(object)requirement.m_resItem == (Object)null)
			{
				return "";
			}
			ItemData itemData = requirement.m_resItem.m_itemData;
			return LocalizeUi(itemData.m_shared.m_name, itemData.m_shared.m_name);
		}

		private static string GetCraftingStationDisplayName(CraftingStation station)
		{
			if (!((Object)(object)station == (Object)null))
			{
				return LocalizeUi(station.m_name, station.m_name);
			}
			return "";
		}

		private static void ConfigureSimpleTooltip(GameObject target, string topic, bool enabled)
		{
			ConfigureSimpleTooltip(target, topic, "", enabled);
		}

		private static void ConfigureSimpleTooltip(GameObject target, string topic, string text, bool enabled)
		{
			if ((Object)(object)target == (Object)null || IsUnityNull((Object?)(object)target))
			{
				return;
			}
			UITooltip component = target.GetComponent<UITooltip>();
			CraftingTooltipState craftingTooltipState = target.GetComponent<CraftingTooltipState>() ?? target.AddComponent<CraftingTooltipState>();
			if (!enabled || string.IsNullOrWhiteSpace(topic))
			{
				if (craftingTooltipState.Stamp.IsValid || !((Object)(object)component == (Object)null))
				{
					if ((Object)(object)component != (Object)null)
					{
						component.m_topic = "";
						component.m_text = "";
						((Behaviour)component).enabled = false;
					}
					InventorySlotsSimpleTooltipHover component2 = target.GetComponent<InventorySlotsSimpleTooltipHover>();
					if ((Object)(object)component2 != (Object)null && !IsUnityNull((Object?)(object)component2))
					{
						component2.Configure("", "");
					}
					craftingTooltipState.Stamp = default(CraftingSimpleTooltipStamp);
				}
			}
			else
			{
				if ((Object)(object)component != (Object)null)
				{
					component.m_topic = "";
					component.m_text = "";
					((Behaviour)component).enabled = false;
				}
				CraftingSimpleTooltipStamp craftingSimpleTooltipStamp = new CraftingSimpleTooltipStamp(topic, text);
				if (!craftingTooltipState.Stamp.Equals(craftingSimpleTooltipStamp))
				{
					(target.GetComponent<InventorySlotsSimpleTooltipHover>() ?? target.AddComponent<InventorySlotsSimpleTooltipHover>()).Configure(topic, text);
					craftingTooltipState.Stamp = craftingSimpleTooltipStamp;
				}
			}
		}

		private static CraftingTextCacheState GetCraftingTextCache(GameObject root)
		{
			CraftingTextCacheState craftingTextCacheState = root.GetComponent<CraftingTextCacheState>() ?? root.AddComponent<CraftingTextCacheState>();
			string text = root.transform.childCount.ToString();
			if (string.Equals(craftingTextCacheState.ChildSignature, text, StringComparison.Ordinal) && !HasInvalidTextCache(craftingTextCacheState))
			{
				return craftingTextCacheState;
			}
			craftingTextCacheState.ChildSignature = text;
			craftingTextCacheState.LastTextStamp = default(CraftingTextStamp);
			craftingTextCacheState.LastColorStamp = default(CraftingTextColorStamp);
			craftingTextCacheState.ProgressBaseLabel = "";
			craftingTextCacheState.TmpTexts = root.GetComponentsInChildren<TMP_Text>(true);
			craftingTextCacheState.LegacyTexts = root.GetComponentsInChildren<Text>(true);
			return craftingTextCacheState;
		}

		private static bool HasInvalidTextCache(CraftingTextCacheState cache)
		{
			if (!cache.TmpTexts.Any((TMP_Text text) => (Object)(object)text == (Object)null || IsUnityNull((Object?)(object)text)))
			{
				return cache.LegacyTexts.Any((Text text) => (Object)(object)text == (Object)null || IsUnityNull((Object?)(object)text));
			}
			return true;
		}

		private static bool IsCraftingCountInputLocked(InventoryGui? gui)
		{
			if (CraftingQueue.QueueRemaining <= 0)
			{
				if ((Object)(object)gui != (Object)null)
				{
					return gui.m_craftTimer >= 0f;
				}
				return false;
			}
			return true;
		}

		private static int GetUnityObjectId(Object? obj)
		{
			if (!(obj != (Object)null) || IsUnityNull(obj))
			{
				return 0;
			}
			return obj.GetInstanceID();
		}

		private static void SetCraftingTopLeftRect(RectTransform parent, RectTransform rect, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			SetTopLeftRectLayout(parent, rect, anchoredPosition, size);
		}

		private static void ConfigureCompactCraftingRequirement(InventoryGui gui, RectTransform rect, Requirement requirement, int quality, int craftMultiplier)
		{
			//IL_0034: 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_00d1: 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_00fd: 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)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_0234: 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_016f: 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_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: 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_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			CraftingRequirementUiMarker craftingRequirementUiMarker = GetCraftingRequirementUiMarker(rect);
			HideCraftingRequirementSlotBackground(craftingRequirementUiMarker);
			string text = $"{64f:0.###}";
			bool flag = !string.Equals(craftingRequirementUiMarker.LayoutSignature, text, StringComparison.Ordinal);
			bool flag2 = !IsVeiledRecipeMasked(gui.m_selectedRecipe) || IsVeiledRecipeRequirementKnown(requirement);
			if ((Object)(object)craftingRequirementUiMarker.Name != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Name))
			{
				((Component)craftingRequirementUiMarker.Name).gameObject.SetActive(false);
			}
			if ((Object)(object)craftingRequirementUiMarker.Icon != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Icon))
			{
				RectTransform icon = craftingRequirementUiMarker.Icon;
				((Component)icon).gameObject.SetActive(true);
				if (flag)
				{
					icon.anchorMin = new Vector2(0f, 1f);
					icon.anchorMax = new Vector2(0f, 1f);
					icon.pivot = new Vector2(0f, 1f);
					icon.anchoredPosition = new Vector2(10f, -10f);
					icon.sizeDelta = new Vector2(44f, 44f);
					((Transform)icon).localScale = Vector3.one;
				}
				if ((Object)(object)craftingRequirementUiMarker.IconImage != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.IconImage))
				{
					craftingRequirementUiMarker.IconImage.sprite = requirement.m_resItem.m_itemData.GetIcon();
					((Graphic)craftingRequirementUiMarker.IconImage).color = (flag2 ? Color.white : Color.black);
					((Graphic)craftingRequirementUiMarker.IconImage).raycastTarget = false;
				}
				ConfigureSimpleTooltip(((Component)icon).gameObject, "", enabled: false);
			}
			if ((Object)(object)craftingRequirementUiMarker.Amount != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Amount))
			{
				RectTransform amount = craftingRequirementUiMarker.Amount;
				((Component)amount).gameObject.SetActive(true);
				if (flag)
				{
					amount.anchorMin = new Vector2(0.5f, 0f);
					amount.anchorMax = new Vector2(0.5f, 0f);
					amount.pivot = new Vector2(0.5f, 0f);
					amount.anchoredPosition = new Vector2(0f, 4f);
					amount.sizeDelta = new Vector2(60f, 20f);
					((Transform)amount).localScale = Vector3.one;
				}
				if ((Object)(object)craftingRequirementUiMarker.AmountText != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.AmountText))
				{
					TMP_Text amountText = craftingRequirementUiMarker.AmountText;
					int num = Mathf.Max(0, requirement.GetAmount(quality) * Mathf.Max(1, craftMultiplier));
					int num2 = (flag2 ? GetAvailableCraftingRequirementAmount(requirement) : 0);
					bool flag3 = HasNoCraftCost();
					bool availableEnough = flag2 && (flag3 || num2 >= num);
					string text2 = (flag2 ? FormatCompactRequirementAmount(num2, num) : GetVeiledRecipeUnknownRequirementText());
					Color val = (flag2 ? GetCompactRequirementAmountColor(availableEnough) : Color.white);
					string text3 = $"{text2}|{val}";
					if (!string.Equals(craftingRequirementUiMarker.AmountSignature, text3, StringComparison.Ordinal) || !RequirementAmountTextMatches(amountText, text2, val))
					{
						ApplyDefaultFontAsset(amountText);
						amountText.text = text2;
						((Graphic)amountText).color = val;
						craftingRequirementUiMarker.AmountSignature = text3;
					}
					if (flag)
					{
						amountText.alignment = (TextAlignmentOptions)1026;
						amountText.enableAutoSizing = true;
						amountText.fontSizeMin = 10f;
						amountText.fontSizeMax = 16f;
						amountText.textWrappingMode = (TextWrappingModes)0;
						amountText.overflowMode = (TextOverflowModes)0;
					}
				}
			}
			RectTransform val2 = EnsureCraftingRequirementHitbox(rect, craftingRequirementUiMarker);
			DisableCompetingCraftingRequirementTooltips(rect, val2, craftingRequirementUiMarker);
			ConfigureCraftingRequirementTooltip(gui, ((Component)val2).gameObject, requirement, quality, craftMultiplier);
			craftingRequirementUiMarker.LayoutSignature = text;
		}

		private static void BindCraftingClientConfigs()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0055: 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_0079: Expected O, but got Unknown
			//IL_0092: 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_00b6: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			_craftingRecipeGridSize = ConfigEntry("4 - Client", "Crafting Recipe Grid Size", 6, new ConfigDescription("Recipe icon grid size inside the fixed 8x8 recipe area. Changed with the crafting grid zoom controls.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(4, 8), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_craftingRecipeGridZoomModifier = OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Crafting Recipe Grid Zoom Modifier", new KeyboardShortcut((KeyCode)308, Array.Empty<KeyCode>()), new ConfigDescription("Hold this key while using the mouse wheel over the crafting recipe grid to zoom between 8x8 and 4x4. Plain mouse wheel changes pages. Alt accepts both LeftAlt and RightAlt.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 748, synchronizedSetting: false);
			_craftingClearFavoritesKey = OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Clear Crafting Favorites Key", new KeyboardShortcut((KeyCode)325, Array.Empty<KeyCode>()), new ConfigDescription("Key used while hovering the favorite group icon to clear crafting or upgrade favorites for the current crafting tab.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 740, synchronizedSetting: false);
			_showCraftingRecipeGridZoomHint = OrderedConfigEntry("5 - Client UI", "Show Crafting Recipe Grid Zoom Hint", Toggle.On, "Show the Alt + mouse wheel hint above the crafting recipe grid. Not synced with server.", 880, synchronizedSetting: false);
			_craftingRecipeGridSize.SettingChanged += delegate
			{
				CraftingController.MarkRecipeGridLayoutDirty();
			};
			_craftingClearFavoritesKey.SettingChanged += delegate
			{
				CraftingController.MarkGroupRailDirty();
			};
			_craftingRecipeSortMode = ConfigEntry("4 - Client", "Crafting Recipe Sort Mode", CraftingRecipeSortMode.TierThenGroup, new ConfigDescription("Sorting mode selected by the crafting station recipe grid buttons.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_craftingRecipeSortMode.SettingChanged += delegate
			{
				CraftingController.ResetSortModeButtonsStamp();
				InvalidateCraftingRecipeView();
			};
			_craftingRecipeCraftableBackgroundColor = OrderedConfigEntry<Color>("4 - Client", "Craftable Recipe Background Color", CraftingRecipeDefaultCraftableBackgroundColor, "Advanced color for recipe grid cells that can currently be crafted. Not synced with server.", 780, synchronizedSetting: false);
			_craftingRecipeCraftableBackgroundColor.SettingChanged += delegate
			{
				CraftingController.MarkRecipeGridLayoutDirty();
			};
		}

		private static bool TryToggleCraftingRecipeFavorite(int originalIndex)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (IsRecycleNReclaimReclaimTabActive(InventoryGui.instance))
			{
				return false;
			}
			if (!IsFavoriteModifierHeld())
			{
				return false;
			}
			InventoryGui instance = InventoryGui.instance;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)instance == (Object)null || (Object)(object)localPlayer == (Object)null || !TryGetCraftingRecipePair(instance, originalIndex, out var pair))
			{
				return true;
			}
			ToggleCraftingRecipeFavorite(localPlayer, pair);
			InvalidateCraftingRecipeView();
			UpdateCraftingPanelRedesign(instance, CraftingPanelUpdateReason.StateChanged);
			return true;
		}

		private static void ToggleCraftingRecipeFavorite(Player player, RecipeDataPair pair)
		{
			//IL_0006: 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)
			EnsureCraftingFavoritesLoaded(player);
			bool flag = IsUpgradeFavoritePair(pair);
			string text = (flag ? GetOrCreateUpgradeFavoriteItemKey(((RecipeDataPair)(ref pair)).ItemData) : GetCraftingRecipeFavoriteKey(pair));
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			HashSet<string> hashSet = (flag ? FavoriteUpgradeItemKeys : FavoriteCraftingRecipeKeys);
			if (!hashSet.Add(text))
			{
				hashSet.Remove(text);
				if (flag && ((RecipeDataPair)(ref pair)).ItemData != null)
				{
					RemoveUpgradeFavoriteItemKey(((RecipeDataPair)(ref pair)).ItemData);
					Inventory inventory = ((Humanoid)player).GetInventory();
					if (inventory != null)
					{
						inventory.Changed();
					}
				}
			}
			else if (flag)
			{
				Inventory inventory2 = ((Humanoid)player).GetInventory();
				if (inventory2 != null)
				{
					inventory2.Changed();
				}
			}
			_craftingFavoritesVersion++;
			ClearCraftingGroupAvailabilityCache();
			SaveCraftingFavorites(player);
		}

		private static bool ClearCraftingFavorites(Player? player, bool upgradeFavorites)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			EnsureCraftingFavoritesLoaded(player);
			HashSet<string> hashSet = (upgradeFavorites ? FavoriteUpgradeItemKeys : FavoriteCraftingRecipeKeys);
			if (hashSet.Count == 0)
			{
				return false;
			}
			if (upgradeFavorites)
			{
				RemoveUpgradeFavoriteItemKeysFromInventory(player, hashSet);
			}
			hashSet.Clear();
			_craftingFavoritesVersion++;
			ClearCraftingGroupAvailabilityCache();
			SaveCraftingFavorites(player);
			return true;
		}

		private static bool IsFavoriteCraftingRecipe(RecipeDataPair pair)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (IsRecycleNReclaimReclaimTabActive(InventoryGui.instance))
			{
				return false;
			}
			EnsureCraftingFavoritesLoaded(Player.m_localPlayer);
			if (IsUpgradeFavoritePair(pair))
			{
				string upgradeFavoriteItemKey = GetUpgradeFavoriteItemKey(((RecipeDataPair)(ref pair)).ItemData);
				if (!string.IsNullOrWhiteSpace(upgradeFavoriteItemKey))
				{
					return FavoriteUpgradeItemKeys.Contains(upgradeFavoriteItemKey);
				}
				return false;
			}
			string craftingRecipeFavoriteKey = GetCraftingRecipeFavoriteKey(pair);
			if (!string.IsNullOrWhiteSpace(craftingRecipeFavoriteKey))
			{
				return FavoriteCraftingRecipeKeys.Contains(craftingRecipeFavoriteKey);
			}
			return false;
		}

		private static bool IsUpgradeFavoritePair(RecipeDataPair pair)
		{
			return ((RecipeDataPair)(ref pair)).ItemData != null;
		}

		private static string GetCraftingRecipeFavoriteKey(RecipeDataPair pair)
		{
			ItemDrop val = (((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null) ? ((RecipeDataPair)(ref pair)).Recipe.m_item : null);
			if ((Object)(object)val == (Object)null)
			{
				return "";
			}
			string text = (((Object)(object)val.m_itemData.m_dropPrefab != (Object)null) ? ((Object)val.m_itemData.m_dropPrefab).name : ((Object)val).name);
			return CleanPrefabName((!string.IsNullOrWhiteSpace(text)) ? text : val.m_itemData.m_shared.m_name);
		}

		private static string GetUpgradeFavoriteItemKey(ItemData? item)
		{
			return UpgradeFavoriteCore.GetItemId(item?.m_customData, "InventorySlotsUpgradeFavoriteId");
		}

		private static string GetOrCreateUpgradeFavoriteItemKey(ItemData? item)
		{
			if (item == null)
			{
				return "";
			}
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			return UpgradeFavoriteCore.GetOrCreateItemId(item.m_customData, "InventorySlotsUpgradeFavoriteId", FavoriteUpgradeItemKeys, () => Guid.NewGuid().ToString("N"));
		}

		private static void SetUpgradeFavoriteItemKey(ItemData? item, string id)
		{
			if (item != null && !string.IsNullOrWhiteSpace(id))
			{
				if (item.m_customData == null)
				{
					item.m_customData = new Dictionary<string, string>();
				}
				UpgradeFavoriteCore.SetItemId(item.m_customData, "InventorySlotsUpgradeFavoriteId", id);
			}
		}

		private static void RemoveUpgradeFavoriteItemKey(ItemData? item)
		{
			UpgradeFavoriteCore.RemoveItemId(item?.m_customData, "InventorySlotsUpgradeFavoriteId");
		}

		private static void RemoveUpgradeFavoriteItemKeysFromInventory(Player player, HashSet<string> favoriteKeys)
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			bool flag = false;
			foreach (ItemData item in inventory.m_inventory.Where((ItemData item) => item?.m_customData != null))
			{
				string upgradeFavoriteItemKey = GetUpgradeFavoriteItemKey(item);
				if (!string.IsNullOrWhiteSpace(upgradeFavoriteItemKey) && favoriteKeys.Contains(upgradeFavoriteItemKey))
				{
					UpgradeFavoriteCore.RemoveItemId(item.m_customData, "InventorySlotsUpgradeFavoriteId");
					flag = true;
				}
			}
			if (flag)
			{
				inventory.Changed();
			}
		}

		private static void EnsureCraftingFavoritesLoaded(Player? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			string playerId = GetPlayerId(player);
			if (string.Equals(_loadedCraftingFavoritesPlayerId, playerId, StringComparison.Ordinal))
			{
				return;
			}
			FavoriteCraftingRecipeKeys.Clear();
			FavoriteUpgradeItemKeys.Clear();
			_loadedCraftingFavoritesPlayerId = playerId;
			_craftingFavoritesVersion++;
			ClearCraftingGroupAvailabilityCache();
			try
			{
				InventorySlotsClientPlayerState clientPlayerState = GetClientPlayerState(playerId, create: false);
				if (clientPlayerState == null)
				{
					return;
				}
				foreach (string item in clientPlayerState.CraftingFavorites.Where((string recipe) => !string.IsNullOrWhiteSpace(recipe)))
				{
					FavoriteCraftingRecipeKeys.Add(item.Trim());
				}
				foreach (string item2 in clientPlayerState.UpgradeFavorites.Where((string itemId) => !string.IsNullOrWhiteSpace(itemId)))
				{
					FavoriteUpgradeItemKeys.Add(item2.Trim());
				}
				_craftingFavoritesVersion++;
				ClearCraftingGroupAvailabilityCache();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to load InventorySlots crafting favorites from " + ClientStateFilePath + ": " + ex.Message));
			}
		}

		private static void SaveCraftingFavorites(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			string playerId = (_loadedCraftingFavoritesPlayerId = GetPlayerId(player));
			try
			{
				InventorySlotsClientPlayerState? clientPlayerState = GetClientPlayerState(playerId, create: true);
				clientPlayerState.CraftingFavorites = FavoriteCraftingRecipeKeys.OrderBy<string, string>((string recipe) => recipe, StringComparer.OrdinalIgnoreCase).ToList();
				clientPlayerState.UpgradeFavorites = FavoriteUpgradeItemKeys.OrderBy<string, string>((string itemId) => itemId, StringComparer.OrdinalIgnoreCase).ToList();
				SaveClientState();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to save InventorySlots crafting favorites: " + ex.Message));
			}
		}

		internal static void CaptureUpgradeFavoriteBeforeCrafting(InventoryGui gui)
		{
			//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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			_pendingUpgradeFavoriteItemId = "";
			_pendingUpgradeFavoritePrefab = "";
			_pendingUpgradeFavoriteQuality = -1;
			_pendingUpgradeFavoriteVariant = -1;
			_pendingUpgradeFavoriteGridPos = new Vector2i(-1, -1);
			ItemData val = gui?.m_craftUpgradeItem;
			string upgradeFavoriteItemKey = GetUpgradeFavoriteItemKey(val);
			if (val?.m_shared != null && !string.IsNullOrWhiteSpace(upgradeFavoriteItemKey))
			{
				_pendingUpgradeFavoriteItemId = upgradeFavoriteItemKey;
				_pendingUpgradeFavoritePrefab = GetItemPrefabName(val);
				_pendingUpgradeFavoriteQuality = val.m_quality + 1;
				_pendingUpgradeFavoriteVariant = val.m_variant;
				_pendingUpgradeFavoriteGridPos = val.m_gridPos;
			}
		}

		internal static void RestoreUpgradeFavoriteAfterCrafting(InventoryGui gui, Player player)
		{
			string pendingUpgradeFavoriteItemId = _pendingUpgradeFavoriteItemId;
			if (string.IsNullOrWhiteSpace(pendingUpgradeFavoriteItemId))
			{
				return;
			}
			_pendingUpgradeFavoriteItemId = "";
			Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			ItemData val2 = ((val != null) ? val.GetItemAt(_pendingUpgradeFavoriteGridPos.x, _pendingUpgradeFavoriteGridPos.y) : null);
			if (!IsPendingUpgradeFavoriteItem(val2))
			{
				val2 = ((IEnumerable<ItemData>)val?.m_inventory).FirstOrDefault((Func<ItemData, bool>)IsPendingUpgradeFavoriteItem);
			}
			if (val2 != null)
			{
				SetUpgradeFavoriteItemKey(val2, pendingUpgradeFavoriteItemId);
				if (val != null)
				{
					val.Changed();
				}
				_craftingFavoritesVersion++;
				ClearCraftingGroupAvailabilityCache();
				InvalidateCraftingRecipeView();
				if ((Object)(object)gui != (Object)null)
				{
					UpdateCraftingPanelRedesign(gui, CraftingPanelUpdateReason.StateChanged);
				}
			}
		}

		private static bool IsPendingUpgradeFavoriteItem(ItemData? item)
		{
			if (item?.m_shared != null && item.m_quality == _pendingUpgradeFavoriteQuality && item.m_variant == _pendingUpgradeFavoriteVariant)
			{
				return string.Equals(GetItemPrefabName(item), _pendingUpgradeFavoritePrefab, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static bool TryRunCraftingPanelFrameFastPath(InventoryGui gui, CraftingTabAdapterState adapter)
		{
			if (!CanRunCraftingPanelFrameFastPath())
			{
				return false;
			}
			CraftingFrameFastPathStamp stamp = CreateCraftingFrameFastPathStamp(gui, adapter);
			if (!CraftingController.CanReuseFrameFastPath(stamp))
			{
				CraftingController.StoreFrameFastPathStamp(stamp);
				return false;
			}
			RectTransform craftingRecipeGrid = _craftingRecipeGrid;
			if ((Object)(object)craftingRecipeGrid == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGrid))
			{
				return false;
			}
			if (HandleCraftingPanelFastPathInput(gui, craftingRecipeGrid))
			{
				return false;
			}
			RefreshCraftingPanelDynamicFrameUi(gui, craftingRecipeGrid, adapter);
			return true;
		}

		private static bool CanRunCraftingPanelFrameFastPath()
		{
			if (_craftingRedesignApplied && (Object)(object)_craftingRecipeGrid != (Object)null && !IsUnityNull((Object?)(object)_craftingRecipeGrid) && !CraftingController.HasFrameRebuildWork() && !CraftingController.IsSearchInputDirty && (Object)(object)CraftingQueue.QueueRecipe == (Object)null)
			{
				return !CraftingQueue.ContinuingQueue;
			}
			return false;
		}

		private static bool HandleCraftingPanelFastPathInput(InventoryGui gui, RectTransform grid)
		{
			if (HandleCraftingCountWheel())
			{
				CraftingController.MarkBottomControlsDirty();
				return true;
			}
			HandleCraftingGroupFavoriteClearShortcut();
			if (CraftingController.HasFrameRebuildWork())
			{
				return true;
			}
			if (!HandleCraftingPinnedTooltipWheel() && !HandleCraftingHoverTooltipWheel() && !HandleCraftingRecipeGridZoomWheel(gui, grid) && !HandleCraftingRecipeGridWheel(gui, grid))
			{
				return CraftingController.HasFrameRebuildWork();
			}
			return true;
		}

		private static void RefreshCraftingPanelDynamicFrameUi(InventoryGui gui, RectTransform grid, CraftingTabAdapterState adapter)
		{
			SuppressCraftingTabAdapterFrameResidue(gui, adapter);
			LayoutCraftingTabAdapterBottomControls(gui, grid, adapter);
			UpdateCraftingRecipeGridZoomHint(gui, grid);
			UpdateCraftingTooltipRecipeOverlay(gui);
			if (HasActiveCraftingPinnedTooltip())
			{
				RepairCraftingPinnedTooltipTextVisibility();
			}
		}

		private static void StoreCraftingFrameFastPathSignature(InventoryGui gui, CraftingTabAdapterState adapter)
		{
			if (!_craftingRedesignApplied || (Object)(object)_craftingRecipeGrid == (Object)null || IsUnityNull((Object?)(object)_craftingRecipeGrid) || CraftingController.HasFrameRebuildWork() || CraftingController.IsSearchInputDirty || (Object)(object)CraftingQueue.QueueRecipe != (Object)null || CraftingQueue.ContinuingQueue)
			{
				ResetCraftingFrameFastPathStamp();
			}
			else
			{
				CraftingController.StoreFrameFastPathStamp(CreateCraftingFrameFastPathStamp(gui, adapter));
			}
		}

		private static void ResetCraftingFrameFastPathStamp()
		{
			CraftingController.ResetFrameFastPathStamp();
		}

		private static CraftingFrameFastPathStamp CreateCraftingFrameFastPathStamp(InventoryGui gui, CraftingTabAdapterState adapter)
		{
			RectTransform craftingRecipeGrid = _craftingRecipeGrid;
			return new CraftingFrameFastPathStamp(((Object)gui).GetInstanceID(), ((Object)(object)gui.m_crafting != (Object)null && !IsUnityNull((Object?)(object)gui.m_crafting)) ? ((Object)gui.m_crafting).GetInstanceID() : 0, ((Object)(object)craftingRecipeGrid != (Object)null && !IsUnityNull((Object?)(object)craftingRecipeGrid)) ? ((Object)craftingRecipeGrid).GetInstanceID() : 0, adapter.Kind, GetSelectedCraftingRecipeIndexSafe(gui), GetCraftingRecipeViewSignature(gui, adapter), _craftingRecipePage, GetCraftingRecipeGridDimension(), CraftingRequirements.AvailabilityVersion, HasNoCraftCost(), GetCraftingPinnedTooltipGridSignature(), _craftingRecipeVariantVersion, CraftingController.HoveredRecipeIndex, Screen.width, Screen.height);
		}

		private static bool HasActiveCraftingPinnedTooltip()
		{
			for (int i = 0; i < PinnedTooltips.Crafting.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeInHierarchy)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HandleCraftingRecipeGridWheel(InventoryGui gui, RectTransform grid)
		{
			//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_0006: 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)
			Vector2 uiMousePosition = GetUiMousePosition();
			bool flag = IsCraftingRecipeScrollbarScrollTargetActive(uiMousePosition);
			if (IsCraftingRecipeGridZoomModifierHeld() && !flag)
			{
				return false;
			}
			int craftingRecipePageCount = GetCraftingRecipePageCount(gui);
			bool flag2 = IsCraftingRecipePageScrollTargetActive(grid, uiMousePosition, flag);
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Discrete);
			if (craftingRecipePageCount <= 1 || !flag2)
			{
				return false;
			}
			if (Mathf.Abs(uiScrollDelta) < 0.01f)
			{
				return false;
			}
			int num = ((uiScrollDelta < 0f) ? 1 : (-1));
			int craftingRecipePage = _craftingRecipePage;
			_craftingRecipePage = Mathf.Clamp(_craftingRecipePage + num, 0, craftingRecipePageCount - 1);
			if (_craftingRecipePage == craftingRecipePage)
			{
				return false;
			}
			CraftingController.ClearHoveredRecipeAndRequestMouseSync();
			CraftingController.MarkRecipeGridLayoutDirty();
			int num2 = _craftingRecipePage * GetCraftingRecipeGridCapacity();
			if (num2 >= 0 && num2 < CraftingRecipes.View.Count)
			{
				SetCraftingRecipeWithStoredVariant(gui, CraftingRecipes.View[num2].OriginalIndex, center: false);
			}
			return true;
		}

		private static bool HandleCraftingRecipeGridZoomWheel(InventoryGui gui, RectTransform grid)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			bool num = IsCraftingRecipeGridZoomScrollTargetActive(grid, GetUiMousePosition());
			bool flag = IsCraftingRecipeGridZoomModifierHeld();
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Discrete);
			if (!num)
			{
				return false;
			}
			if (!flag || Mathf.Abs(uiScrollDelta) < 0.01f)
			{
				return false;
			}
			int craftingRecipeGridDimension = GetCraftingRecipeGridDimension();
			int num2 = Mathf.Clamp(craftingRecipeGridDimension + ((!(uiScrollDelta > 0f)) ? 1 : (-1)), 4, 8);
			if (num2 == craftingRecipeGridDimension)
			{
				return true;
			}
			if (_craftingRecipeGridSize != null)
			{
				_craftingRecipeGridSize.Value = num2;
			}
			int num3 = FindCraftingRecipeViewIndex(gui.GetSelectedRecipeIndex(false));
			if (num3 >= 0)
			{
				_craftingRecipePage = Mathf.Clamp(num3 / GetCraftingRecipeGridCapacity(), 0, Mathf.Max(0, GetCraftingRecipePageCount(gui) - 1));
			}
			else
			{
				ClampCraftingRecipePage(gui);
			}
			EnsureCraftingRecipeCells(gui, grid);
			CraftingController.MarkRecipeGridLayoutDirty();
			CraftingController.ClearHoveredRecipeAndRequestMouseSync();
			return true;
		}

		private static bool IsCraftingRecipePageScrollTargetActive(RectTransform grid, Vector2 mouse, bool scrollbarTargetActive)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (!(RectContainsCraftingRecipeIconArea(grid, mouse) || scrollbarTargetActive))
			{
				return IsGamepadUiScrollActive();
			}
			return true;
		}

		private static bool IsCraftingRecipeGridZoomScrollTargetActive(RectTransform grid, Vector2 mouse)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (!RectContainsCraftingRecipeIconArea(grid, mouse))
			{
				return IsGamepadUiScrollActive();
			}
			return true;
		}

		private static bool IsCraftingRecipeScrollbarScrollTargetActive(Vector2 mouse)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_craftingRecipeScrollbar != (Object)null && !IsUnityNull((Object?)(object)_craftingRecipeScrollbar) && ((Component)_craftingRecipeScrollbar).gameObject.activeInHierarchy)
			{
				return RectContainsScreenPoint(_craftingRecipeScrollbar, mouse);
			}
			return false;
		}

		private static bool IsCraftingRecipeGridZoomModifierHeld()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (_craftingRecipeGridZoomModifier == null || !IsShortcutHeldAllowingAltPair(_craftingRecipeGridZoomModifier.Value))
			{
				return IsGamepadCraftingRecipeGridZoomModifierHeld();
			}
			return true;
		}

		private static bool IsGamepadCraftingRecipeGridZoomModifierHeld()
		{
			if (!IsGamepadActiveSafe())
			{
				return false;
			}
			try
			{
				return IsControllerHotkeyHeld(_controllerCraftingGridZoomModifierButton);
			}
			catch
			{
				return false;
			}
		}

		private static void UpdateCraftingRecipeGridZoomHint(InventoryGui gui, RectTransform grid)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: 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_034f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)gui?.m_crafting == (Object)null) && !((Object)(object)grid == (Object)null) && _showCraftingRecipeGridZoomHint != null && !_showCraftingRecipeGridZoomHint.Value.IsOff() && _craftingRecipeGridZoomModifier != null)
			{
				KeyboardShortcut value = _craftingRecipeGridZoomModifier.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					string craftingRecipeGridZoomModifierDisplayText = GetCraftingRecipeGridZoomModifierDisplayText();
					if (string.IsNullOrWhiteSpace(craftingRecipeGridZoomModifierDisplayText))
					{
						SetHintActive(CraftingUi.RecipeGridZoomHint, active: false);
						return;
					}
					TMP_Text text = null;
					CraftingUi.RecipeGridZoomHint = EnsureInventoryHintLabel(gui.m_crafting, "InventorySlots_CraftingRecipeGridZoomHint", ref text);
					if (!((Object)(object)CraftingUi.RecipeGridZoomHint == (Object)null) && !((Object)(object)text == (Object)null))
					{
						float num = 16f;
						float num2 = Mathf.Clamp(num * 1.35f, 14f, 42f);
						float num3 = Mathf.Max(10f, num2 * 0.72f);
						float num4 = 0f;
						string text2 = craftingRecipeGridZoomModifierDisplayText + "+";
						float num5 = Mathf.Max(num2, num * 1.45f);
						text.text = "";
						((Behaviour)text).enabled = false;
						((Graphic)text).raycastTarget = false;
						TMP_Text val = EnsureHintText(CraftingUi.RecipeGridZoomHint, "Label", text2);
						((Behaviour)val).enabled = true;
						val.fontSize = num;
						val.alignment = (TextAlignmentOptions)513;
						val.textWrappingMode = (TextWrappingModes)0;
						val.overflowMode = (TextOverflowModes)0;
						((Graphic)val).color = InventoryWheelHintColor;
						((Graphic)val).raycastTarget = false;
						float num6 = Mathf.Ceil(Mathf.Max(num * 1.4f, val.GetPreferredValues(text2, 1000f, num2).x + 1f));
						float num7 = num6 + num4 + num3;
						Vector2 size = default(Vector2);
						((Vector2)(ref size))..ctor(num7, num5);
						Vector2 craftingRecipeGridZoomHintFixedOffset = CraftingRecipeGridZoomHintFixedOffset;
						if ((Object)(object)((Transform)CraftingUi.RecipeGridZoomHint).parent != (Object)(object)gui.m_crafting)
						{
							((Transform)CraftingUi.RecipeGridZoomHint).SetParent((Transform)(object)gui.m_crafting, false);
						}
						SetCenteredRectLayout(CraftingUi.RecipeGridZoomHint, craftingRecipeGridZoomHintFixedOffset, size);
						((Transform)CraftingUi.RecipeGridZoomHint).SetAsLastSibling();
						RectTransform val2 = (RectTransform)val.transform;
						val2.anchorMin = new Vector2(0f, 0.5f);
						val2.anchorMax = new Vector2(0f, 0.5f);
						val2.pivot = new Vector2(0f, 0.5f);
						val2.anchoredPosition = Vector2.zero;
						val2.sizeDelta = new Vector2(num6, num5);
						((Transform)val2).localScale = Vector3.one;
						((Transform)val2).localRotation = Quaternion.identity;
						RectTransform obj = EnsureHintImage(CraftingUi.RecipeGridZoomHint, "MouseWheelIcon");
						obj.anchorMin = new Vector2(0f, 0.5f);
						obj.anchorMax = new Vector2(0f, 0.5f);
						obj.pivot = new Vector2(0f, 0.5f);
						obj.anchoredPosition = new Vector2(num6 + num4, 0f);
						obj.sizeDelta = new Vector2(num3, num2);
						((Transform)obj).localScale = Vector3.one;
						((Transform)obj).localRotation = Quaternion.identity;
						((Transform)obj).SetAsLastSibling();
						Image component = ((Component)obj).GetComponent<Image>();
						component.sprite = GetMouseWheelHintSprite();
						component.type = (Type)0;
						component.preserveAspect = true;
						((Graphic)component).raycastTarget = false;
						((Graphic)component).color = InventoryWheelHintColor;
						SetHintActive(CraftingUi.RecipeGridZoomHint, active: true);
					}
					return;
				}
			}
			SetHintActive(CraftingUi.RecipeGridZoomHint, active: false);
		}

		private static string GetCraftingRecipeGridZoomModifierDisplayText()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (_craftingRecipeGridZoomModifier == null)
			{
				return "";
			}
			string displayText = _craftingRecipeGridZoomModifier.Value.GetDisplayText();
			if (string.IsNullOrWhiteSpace(displayText))
			{
				return "";
			}
			return displayText;
		}

		private static void SyncCraftingRecipePageToSelected(InventoryGui gui)
		{
			int selectedRecipeIndex = gui.GetSelectedRecipeIndex(false);
			if (selectedRecipeIndex < 0)
			{
				int craftingRecipePage = _craftingRecipePage;
				_craftingRecipePage = 0;
				if (_craftingRecipePage != craftingRecipePage)
				{
					CraftingController.MarkRecipeGridLayoutDirty();
				}
				return;
			}
			int num = FindCraftingRecipeViewIndex(selectedRecipeIndex);
			int craftingRecipePage2 = _craftingRecipePage;
			_craftingRecipePage = ((num >= 0) ? Mathf.Clamp(num / GetCraftingRecipeGridCapacity(), 0, Mathf.Max(0, GetCraftingRecipePageCount(gui) - 1)) : 0);
			if (_craftingRecipePage != craftingRecipePage2)
			{
				CraftingController.MarkRecipeGridLayoutDirty();
			}
		}

		private static void ClampCraftingRecipePage(InventoryGui gui)
		{
			int craftingRecipePage = _craftingRecipePage;
			_craftingRecipePage = Mathf.Clamp(_craftingRecipePage, 0, Mathf.Max(0, GetCraftingRecipePageCount(gui) - 1));
			if (_craftingRecipePage != craftingRecipePage)
			{
				CraftingController.MarkRecipeGridLayoutDirty();
			}
		}

		private static int GetCraftingRecipePageCount(InventoryGui gui)
		{
			int count = CraftingRecipes.View.Count;
			if (count > 0)
			{
				return Mathf.CeilToInt((float)count / (float)GetCraftingRecipeGridCapacity());
			}
			return 1;
		}

		private static void LayoutCraftingRecipeGrid(InventoryGui gui, RectTransform grid)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			int craftingRecipeGridDimension = GetCraftingRecipeGridDimension();
			int num = _craftingRecipePage * GetCraftingRecipeGridCapacity();
			int selectedRecipeIndex = gui.GetSelectedRecipeIndex(false);
			int craftingRecipeGridAvailabilityHash = GetCraftingRecipeGridAvailabilityHash(gui, num);
			CraftingRecipeGridStamp stamp = new CraftingRecipeGridStamp(craftingRecipeGridDimension, num, selectedRecipeIndex, craftingRecipeGridAvailabilityHash, GetCraftingPinnedTooltipGridSignature(), CraftingRecipes.View.Count, _craftingRecipeVariantVersion);
			if (CraftingController.CanReuseRecipeGrid(stamp))
			{
				return;
			}
			EnsureCraftingRecipeCells(gui, grid);
			for (int i = 0; i < CraftingRecipes.GridCells.Count; i++)
			{
				CraftingRecipeGridCell cell = CraftingRecipes.GridCells[i];
				int num2 = num + i;
				if (num2 < 0 || num2 >= CraftingRecipes.View.Count)
				{
					SetCraftingRecipeCellVisible(cell, visible: false);
					continue;
				}
				CraftingRecipeViewEntry craftingRecipeViewEntry = CraftingRecipes.View[num2];
				ConfigureCraftingRecipeCell(gui, cell, craftingRecipeViewEntry.Pair, craftingRecipeViewEntry.OriginalIndex, i, IsCraftingRecipeTooltipPinned(craftingRecipeViewEntry.OriginalIndex), craftingRecipeViewEntry.OriginalIndex == selectedRecipeIndex);
			}
			CraftingController.StoreRecipeGridStamp(stamp);
		}

		private static void SetCraftingRecipeCellVisible(CraftingRecipeGridCell cell, bool visible)
		{
			if (!visible)
			{
				ClearCurrentCraftingRecipeTooltip(cell.Tooltip);
			}
			if ((Object)(object)cell.Go != (Object)null && !IsUnityNull((Object?)(object)cell.Go))
			{
				cell.Go.SetActive(visible);
			}
		}

		private static void ConfigureCraftingRecipeCell(InventoryGui gui, CraftingRecipeGridCell cell, RecipeDataPair pair, int index, int slotIndex, bool tooltipPinned, bool craftingSelected)
		{
			//IL_0057: 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_0081: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0132: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cell.Go == (Object)null || IsUnityNull((Object?)(object)cell.Go))
			{
				return;
			}
			cell.Go.SetActive(true);
			RectTransform rect = cell.Rect;
			int craftingRecipeGridDimension = GetCraftingRecipeGridDimension();
			float craftingRecipeDynamicCellSpace = GetCraftingRecipeDynamicCellSpace();
			float craftingRecipeDynamicCellSize = GetCraftingRecipeDynamicCellSize(craftingRecipeDynamicCellSpace);
			int num = slotIndex % craftingRecipeGridDimension;
			int num2 = slotIndex / craftingRecipeGridDimension;
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = new Vector2(0f, 1f);
			rect.pivot = new Vector2(0f, 1f);
			rect.sizeDelta = new Vector2(craftingRecipeDynamicCellSize, craftingRecipeDynamicCellSize);
			rect.anchoredPosition = new Vector2((float)num * craftingRecipeDynamicCellSpace, (float)(-num2) * craftingRecipeDynamicCellSpace);
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
			ConfigureCraftingRecipeCellOverlays(cell, craftingRecipeDynamicCellSize);
			if ((Object)(object)cell.Background != (Object)null)
			{
				bool flag = !IsVeiledRecipeMasked(pair) && IsCraftingRecipeActionAvailable(gui, pair, index);
				((Graphic)cell.Background).raycastTarget = true;
				((Graphic)cell.Background).color = (craftingSelected ? CraftingRecipeSelectedBackgroundColor : (flag ? GetCraftingRecipeCraftableBackgroundColor() : CraftingRecipeUnavailableBackgroundColor));
			}
			ConfigureCraftingRecipeCellIcon(cell.Icon, pair, craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeFoodIcon(gui, cell.Food, pair, craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeCellAmountText(cell.Amount, GetCraftingRecipeCellAmountText(gui, pair), craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeCellQualityText(cell.Quality, (!IsVeiledRecipeMasked(pair) && ((RecipeDataPair)(ref pair)).ItemData != null) ? ((RecipeDataPair)(ref pair)).ItemData.m_quality.ToString() : "", craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeStyleButton(gui, cell, pair, index, craftingRecipeDynamicCellSize);
			SetCraftingRecipeCellChild(cell.Selected, active: false);
			SetCraftingRecipeCellChild(cell.Equipped, active: false);
			SetCraftingRecipeCellChild(cell.Queued, active: false);
			SetCraftingRecipeCellChild(cell.NoTeleport, active: false);
			SetCraftingRecipeCellChild(cell.Durability, active: false);
			SetCraftingRecipeFavoriteBorder(cell, IsFavoriteCraftingRecipe(pair), IsUpgradeFavoritePair(pair));
			SetCraftingRecipePinnedTooltipMarker(cell, tooltipPinned, craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeVneiTooltip(cell.Tooltip, pair);
			CraftingRecipeGridMarker marker = cell.Marker;
			marker.Index = index;
			marker.Tooltip = cell.Tooltip;
			if (!marker.Initialized)
			{
				UIInputHandler input = cell.Input;
				input.m_onPointerEnter = (Action<UIInputHandler>)Delegate.Combine(input.m_onPointerEnter, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					SetCraftingRecipeHover(component?.Index ?? (-1), component?.Tooltip);
				});
				input.m_onPointerExit = (Action<UIInputHandler>)Delegate.Combine(input.m_onPointerExit, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					ClearCraftingRecipeHover(component?.Index ?? (-1), component?.Tooltip);
				});
				input.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(input.m_onLeftClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					int num3 = component?.Index ?? (-1);
					ClearCraftingRecipeHover(num3, component?.Tooltip);
					if (!TryToggleCraftingRecipeFavorite(num3))
					{
						SelectCraftingRecipeFromGrid(num3);
					}
				});
				input.m_onRightClick = (Action<UIInputHandler>)Delegate.Combine(input.m_onRightClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					CraftingRecipeGridMarker component = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					int num3 = component?.Index ?? (-1);
					ClearCraftingRecipeHover(num3, component?.Tooltip);
					if (!TryToggleCraftingRecipeFavorite(num3))
					{
						SelectCraftingRecipeFromGrid(num3);
					}
				});
				marker.Initialized = true;
			}
			((Behaviour)cell.Tooltip).enabled = false;
		}

		private static string GetCraftingRecipeCellAmountText(InventoryGui gui, RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (IsVeiledRecipeMasked(pair))
			{
				return "";
			}
			string recycleNReclaimRecipeCellAmountText = GetRecycleNReclaimRecipeCellAmountText(gui, pair);
			if (!string.IsNullOrEmpty(recycleNReclaimRecipeCellAmountText))
			{
				return recycleNReclaimRecipeCellAmountText;
			}
			if (!((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null) || ((RecipeDataPair)(ref pair)).Recipe.m_amount <= 1)
			{
				return "";
			}
			return ((RecipeDataPair)(ref pair)).Recipe.m_amount.ToString();
		}

		private static Color GetCraftingRecipeCraftableBackgroundColor()
		{
			//IL_000f: 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)
			return _craftingRecipeCraftableBackgroundColor?.Value ?? CraftingRecipeDefaultCraftableBackgroundColor;
		}

		private static void SelectCraftingRecipeFromGrid(int index)
		{
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null) && TryGetCraftingRecipePair(instance, index, out var _))
			{
				SetCraftingRecipeWithStoredVariant(instance, index, center: false);
			}
		}

		private static void SetCraftingRecipeHover(int index, UITooltip? tooltip)
		{
			if (CraftingController.IsHoveredRecipe(index))
			{
				SetCurrentCraftingRecipeTooltip(tooltip);
				return;
			}
			CraftingController.SetHoveredRecipe(index);
			SetCurrentCraftingRecipeTooltip(tooltip);
		}

		private static void SyncCraftingRecipeHoverWithMouseIfRequested()
		{
			if (CraftingController.ConsumeRecipeHoverMouseSync() && TryGetCraftingRecipeCellUnderMouse(out int index, out UITooltip tooltip))
			{
				SetCraftingRecipeHover(index, tooltip);
			}
		}

		private static bool TryGetCraftingRecipeCellUnderMouse(out int index, out UITooltip? tooltip)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			index = -1;
			tooltip = null;
			RectTransform craftingRecipeGrid = _craftingRecipeGrid;
			if ((Object)(object)craftingRecipeGrid == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGrid) || !((Component)craftingRecipeGrid).gameObject.activeInHierarchy)
			{
				return false;
			}
			Vector2 uiMousePosition = GetUiMousePosition();
			int num = _craftingRecipePage * GetCraftingRecipeGridCapacity();
			for (int i = 0; i < CraftingRecipes.GridCells.Count; i++)
			{
				CraftingRecipeGridCell craftingRecipeGridCell = CraftingRecipes.GridCells[i];
				if (!((Object)(object)craftingRecipeGridCell.Go == (Object)null) && !IsUnityNull((Object?)(object)craftingRecipeGridCell.Go) && craftingRecipeGridCell.Go.activeInHierarchy && RectContainsScreenPoint(craftingRecipeGridCell.Rect, uiMousePosition))
				{
					int num2 = num + i;
					index = ((num2 >= 0 && num2 < CraftingRecipes.View.Count) ? CraftingRecipes.View[num2].OriginalIndex : craftingRecipeGridCell.Marker.Index);
					tooltip = craftingRecipeGridCell.Tooltip;
					return index >= 0;
				}
			}
			return false;
		}

		private static void ClearCraftingRecipeHover(int index, UITooltip? tooltip)
		{
			if (!CraftingController.IsHoveredRecipe(index))
			{
				ClearCurrentCraftingRecipeTooltip(tooltip);
				return;
			}
			CraftingController.ClearHoveredRecipe();
			ClearCurrentCraftingRecipeTooltip(tooltip);
			HideCraftingTooltipRecipeOverlay();
		}

		private static void SetCurrentCraftingRecipeTooltip(UITooltip? tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip) && !string.IsNullOrWhiteSpace(tooltip.m_topic))
			{
				UITooltip.m_current = tooltip;
			}
		}

		private static void ClearCurrentCraftingRecipeTooltip(UITooltip? tooltip)
		{
			if ((Object)(object)tooltip != (Object)null && !IsUnityNull((Object?)(object)tooltip) && (Object)(object)UITooltip.m_current == (Object)(object)tooltip)
			{
				UITooltip.m_current = null;
			}
		}

		private static void ConfigureCraftingRecipeVneiTooltip(UITooltip tooltip, RecipeDataPair pair)
		{
			//IL_0000: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			if (IsVeiledRecipeMasked(pair))
			{
				string veiledRecipeUnknownNameText = GetVeiledRecipeUnknownNameText();
				string veiledRecipeUnknownDescriptionText = GetVeiledRecipeUnknownDescriptionText();
				tooltip.m_topic = veiledRecipeUnknownNameText;
				tooltip.m_text = veiledRecipeUnknownDescriptionText;
				(((Component)tooltip).GetComponent<InventorySlotsTooltipDisplayData>() ?? ((Component)tooltip).gameObject.AddComponent<InventorySlotsTooltipDisplayData>()).Configure(veiledRecipeUnknownNameText, veiledRecipeUnknownDescriptionText, "");
			}
			else
			{
				string craftingRecipeVneiItemToken = GetCraftingRecipeVneiItemToken(pair);
				string craftingRecipeVneiDisplayText = GetCraftingRecipeVneiDisplayText(pair, craftingRecipeVneiItemToken);
				tooltip.m_topic = craftingRecipeVneiItemToken;
				tooltip.m_text = craftingRecipeVneiDisplayText;
				(((Component)tooltip).GetComponent<InventorySlotsTooltipDisplayData>() ?? ((Component)tooltip).gameObject.AddComponent<InventorySlotsTooltipDisplayData>()).Configure(craftingRecipeVneiItemToken, craftingRecipeVneiDisplayText, "");
			}
		}

		private static string GetCraftingRecipeVneiItemToken(RecipeDataPair pair)
		{
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				string itemPrefabName = GetItemPrefabName(((RecipeDataPair)(ref pair)).ItemData);
				object obj;
				if (string.IsNullOrWhiteSpace(itemPrefabName))
				{
					obj = ((RecipeDataPair)(ref pair)).ItemData.m_shared?.m_name;
					if (obj == null)
					{
						return "";
					}
				}
				else
				{
					obj = itemPrefabName;
				}
				return (string)obj;
			}
			ItemDrop val = ((RecipeDataPair)(ref pair)).Recipe?.m_item;
			if ((Object)(object)val == (Object)null)
			{
				return "";
			}
			string text = (((Object)(object)val.m_itemData.m_dropPrefab != (Object)null) ? ((Object)val.m_itemData.m_dropPrefab).name : ((Object)val).name);
			object obj2;
			if (string.IsNullOrWhiteSpace(text))
			{
				obj2 = val.m_itemData.m_shared?.m_name;
				if (obj2 == null)
				{
					return "";
				}
			}
			else
			{
				obj2 = CleanPrefabName(text);
			}
			return (string)obj2;
		}

		private static string GetCraftingRecipeVneiDisplayText(RecipeDataPair pair, string fallback)
		{
			string text = ((RecipeDataPair)(ref pair)).ItemData?.m_shared?.m_name ?? ((RecipeDataPair)(ref pair)).Recipe?.m_item?.m_itemData.m_shared?.m_name ?? "";
			if (string.IsNullOrWhiteSpace(text))
			{
				return fallback;
			}
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		private static string StripRichText(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			int num = 0;
			char[] array = new char[text.Length];
			int length = 0;
			foreach (char c in text)
			{
				switch (c)
				{
				case '<':
					num++;
					continue;
				case '>':
					if (num > 0)
					{
						num--;
						continue;
					}
					break;
				}
				if (num == 0)
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private static void ConfigureCraftingRecipeCellOverlays(CraftingRecipeGridCell cell, float cellSize)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in (Transform)cell.Rect)
			{
				Transform val = item;
				string text = ((Object)val).name.ToLowerInvariant();
				bool flag = !text.Contains("bkg") && !text.Contains("background") && !text.Contains("border") && !text.Contains("frame");
				if (flag)
				{
					bool flag2;
					switch (text)
					{
					case "selected":
					case "equiped":
					case "queued":
					case "noteleport":
					case "durability":
						flag2 = true;
						break;
					default:
						flag2 = false;
						break;
					}
					flag = !flag2;
				}
				if (!flag)
				{
					RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
					if (val2 != null)
					{
						val2.anchorMin = new Vector2(0f, 1f);
						val2.anchorMax = new Vector2(0f, 1f);
						val2.pivot = new Vector2(0f, 1f);
						val2.anchoredPosition = Vector2.zero;
						val2.sizeDelta = new Vector2(cellSize, cellSize);
						((Transform)val2).localScale = Vector3.one;
						((Transform)val2).localRotation = Quaternion.identity;
					}
				}
			}
		}

		private static void ConfigureCraftingRecipeCellIcon(Image? icon, RecipeDataPair pair, float cellSize)
		{
			//IL_0085: 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_00af: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00f6: 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_0122: 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)(object)icon == (Object)null))
			{
				ItemDrop val = (((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null) ? ((RecipeDataPair)(ref pair)).Recipe.m_item : null);
				((Component)icon).gameObject.SetActive((Object)(object)val != (Object)null);
				if (((Component)icon).gameObject.activeSelf)
				{
					RectTransform rectTransform = ((Graphic)icon).rectTransform;
					float num = Mathf.Clamp(cellSize * 0.08f, 5f, 12f);
					float num2 = Mathf.Max(16f, cellSize - num * 2f);
					rectTransform.anchorMin = new Vector2(0f, 1f);
					rectTransform.anchorMax = new Vector2(0f, 1f);
					rectTransform.pivot = new Vector2(0f, 1f);
					rectTransform.anchoredPosition = new Vector2(num, 0f - num);
					rectTransform.sizeDelta = new Vector2(num2, num2);
					((Transform)rectTransform).localScale = Vector3.one;
					((Transform)rectTransform).localRotation = Quaternion.identity;
					icon.sprite = GetCraftingRecipeIcon(pair);
					((Graphic)icon).color = (Color)(IsVeiledRecipeMasked(pair) ? Color.black : (((RecipeDataPair)(ref pair)).CanCraft ? Color.white : new Color(0.68f, 0.68f, 0.68f, 0.72f)));
					((Graphic)icon).raycastTarget = false;
				}
			}
		}

		private static void ConfigureCraftingRecipeFoodIcon(InventoryGui gui, Image? foodIcon, RecipeDataPair pair, float cellSize)
		{
			//IL_003e: 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_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_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_00eb: 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_00fd: 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_0146: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)foodIcon == (Object)null))
			{
				ItemData val = ((RecipeDataPair)(ref pair)).ItemData ?? ((RecipeDataPair)(ref pair)).Recipe?.m_item?.m_itemData;
				Image inventoryFoodIconSource = GetInventoryFoodIconSource(gui);
				FoodStat stat = FoodStat.None;
				bool flag = !IsVeiledRecipeMasked(pair) && val != null && (Object)(object)inventoryFoodIconSource != (Object)null && (Object)(object)inventoryFoodIconSource.sprite != (Object)null && TryGetDominantFoodStat(val, out stat);
				((Component)foodIcon).gameObject.SetActive(flag);
				if (flag)
				{
					foodIcon.sprite = inventoryFoodIconSource.sprite;
					((Graphic)foodIcon).material = ((Graphic)inventoryFoodIconSource).material;
					foodIcon.type = inventoryFoodIconSource.type;
					foodIcon.preserveAspect = true;
					((Graphic)foodIcon).raycastTarget = false;
					((Graphic)foodIcon).color = (Color)(stat switch
					{
						FoodStat.Health => gui.m_playerGrid.m_foodHealthColor, 
						FoodStat.Stamina => gui.m_playerGrid.m_foodStaminaColor, 
						FoodStat.Eitr => gui.m_playerGrid.m_foodEitrColor, 
						_ => Color.white, 
					});
					RectTransform rectTransform = ((Graphic)foodIcon).rectTransform;
					float num = Mathf.Clamp(cellSize * 0.3f, 16f, 30f);
					float num2 = Mathf.Clamp(cellSize * 0.035f, 2f, 5f);
					rectTransform.anchorMin = Vector2.one;
					rectTransform.anchorMax = Vector2.one;
					rectTransform.pivot = Vector2.one;
					rectTransform.anchoredPosition = new Vector2(num2, 0f - num2);
					rectTransform.sizeDelta = new Vector2(num, num);
					((Transform)rectTransform).localScale = Vector3.one;
					((Transform)rectTransform).localRotation = Quaternion.identity;
					((Transform)rectTransform).SetAsLastSibling();
				}
			}
		}

		private static Image? GetInventoryFoodIconSource(InventoryGui gui)
		{
			InventoryGrid playerGrid = gui.m_playerGrid;
			if ((Object)(object)playerGrid == (Object)null)
			{
				return null;
			}
			if (playerGrid.m_elements != null)
			{
				foreach (Element element in playerGrid.m_elements)
				{
					if ((Object)(object)element?.m_food != (Object)null && (Object)(object)element.m_food.sprite != (Object)null)
					{
						return element.m_food;
					}
				}
			}
			Transform val = (((Object)(object)playerGrid.m_elementPrefab != (Object)null) ? playerGrid.m_elementPrefab.transform.Find("foodicon") : null);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).GetComponent<Image>();
		}

		private static void ConfigureCraftingRecipeStyleButton(InventoryGui gui, CraftingRecipeGridCell cell, RecipeDataPair pair, int originalIndex, float cellSize)
		{
			//IL_0012: 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_007c: 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_00a6: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_01d1: 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_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = EnsureCraftingRecipeStyleButton(gui, cell);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			bool flag = GetCraftingRecipeVariantCount(pair) > 1 && ((RecipeDataPair)(ref pair)).ItemData == null && !IsVeiledRecipeMasked(pair);
			((Component)val).gameObject.SetActive(flag);
			if (flag)
			{
				float num = Mathf.Clamp(cellSize * 0.224f, 14f, 21f);
				float num2 = Mathf.Clamp(cellSize * 0.476f, 31f, 50f);
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.pivot = new Vector2(0f, 1f);
				val.anchoredPosition = new Vector2(cellSize - num2 - 2f, -2f);
				val.sizeDelta = new Vector2(num2, num);
				((Transform)val).localScale = Vector3.one;
				((Transform)val).localRotation = Quaternion.identity;
				((Transform)val).SetAsLastSibling();
				Image component = ((Component)val).GetComponent<Image>();
				if (component != null)
				{
					ApplyVanillaButtonImage(gui.m_variantButton, component);
					((Graphic)component).raycastTarget = true;
				}
				Transform obj = ((Transform)val).Find("Label");
				TMP_Text val2 = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					ApplyDefaultFontAsset(val2);
					val2.text = LocalizeUi("$inventoryslots_style", "Style");
					val2.alignment = (TextAlignmentOptions)514;
					val2.enableAutoSizing = true;
					val2.fontSizeMin = 7f;
					val2.fontSizeMax = Mathf.Clamp(num * 0.66f, 9f, 12f);
					val2.textWrappingMode = (TextWrappingModes)0;
					val2.overflowMode = (TextOverflowModes)3;
					((Graphic)val2).color = GetVanillaButtonTextColor(gui.m_variantButton);
					((Graphic)val2).raycastTarget = false;
					RectTransform rectTransform = val2.rectTransform;
					rectTransform.anchorMin = Vector2.zero;
					rectTransform.anchorMax = Vector2.one;
					rectTransform.offsetMin = Vector2.zero;
					rectTransform.offsetMax = Vector2.zero;
					((Transform)rectTransform).localScale = Vector3.one;
					((Transform)rectTransform).localRotation = Quaternion.identity;
				}
				CraftingRecipeStyleButtonMarker obj2 = ((Component)val).GetComponent<CraftingRecipeStyleButtonMarker>() ?? ((Component)val).gameObject.AddComponent<CraftingRecipeStyleButtonMarker>();
				obj2.Index = originalIndex;
				obj2.Gui = gui;
			}
		}

		private static RectTransform? EnsureCraftingRecipeStyleButton(InventoryGui gui, CraftingRecipeGridCell cell)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cell.Rect == (Object)null || IsUnityNull((Object?)(object)cell.Rect))
			{
				return null;
			}
			Transform val = ((Transform)cell.Rect).Find("InventorySlots_CraftingRecipeStyleButton");
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = new GameObject("InventorySlots_CraftingRecipeStyleButton", new Type[4]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(UIInputHandler),
					typeof(CraftingRecipeStyleButtonMarker)
				}).GetComponent<RectTransform>();
				((Transform)val2).SetParent((Transform)(object)cell.Rect, false);
				CreateTextRect("Label", (Transform)(object)val2);
				UIInputHandler component = ((Component)val2).GetComponent<UIInputHandler>();
				component.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(component.m_onLeftClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					ShowCraftingRecipeStyleDialog(((Component)handler).GetComponent<CraftingRecipeStyleButtonMarker>());
				});
			}
			return val2;
		}

		private static void ApplyVanillaButtonImage(Button? source, Image target)
		{
			//IL_0088: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			Image val = (((Object)(object)source != (Object)null && !IsUnityNull((Object?)(object)source)) ? ((Selectable)source).image : null);
			if ((Object)(object)val != (Object)null)
			{
				target.sprite = val.sprite;
				target.type = val.type;
				((Graphic)target).material = ((Graphic)val).material;
				target.pixelsPerUnitMultiplier = val.pixelsPerUnitMultiplier;
				((Graphic)target).color = ((Graphic)val).color;
			}
			else
			{
				target.sprite = GetSolidUiSprite();
				target.type = (Type)1;
				((Graphic)target).color = new Color(0.02f, 0.015f, 0.01f, 0.76f);
			}
		}

		private static Color GetVanillaButtonTextColor(Button? button)
		{
			//IL_0037: 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)
			if ((Object)(object)button != (Object)null && !IsUnityNull((Object?)(object)button))
			{
				TMP_Text componentInChildren = ((Component)button).GetComponentInChildren<TMP_Text>(true);
				if (componentInChildren != null)
				{
					return ((Graphic)componentInChildren).color;
				}
			}
			return new Color(1f, 0.84f, 0.32f, 1f);
		}

		private static void ShowCraftingRecipeStyleDialog(CraftingRecipeStyleButtonMarker? marker)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui val = (InventoryGui)(((Object)(object)marker != (Object)null && (Object)(object)marker.Gui != (Object)null && !IsUnityNull((Object?)(object)marker.Gui)) ? ((object)marker.Gui) : ((object)InventoryGui.instance));
			if (!((Object)(object)val == (Object)null) && TryGetCraftingRecipePair(val, marker?.Index ?? (-1), out var pair) && !((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null) && GetCraftingRecipeVariantCount(pair) > 1)
			{
				SetCraftingRecipeWithStoredVariant(val, marker.Index, center: false);
				val.OnShowVariantSelection();
			}
		}

		internal static void OnCraftingRecipeVariantSelected(InventoryGui gui, int variant)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)gui == (Object)null) && ShouldShowCraftingPanelRedesign(gui))
			{
				RecipeDataPair selectedRecipe = gui.m_selectedRecipe;
				Recipe recipe = ((RecipeDataPair)(ref selectedRecipe)).Recipe;
				if (!((Object)(object)recipe == (Object)null) && ((RecipeDataPair)(ref selectedRecipe)).ItemData == null && GetCraftingRecipeVariantCount(selectedRecipe) > 1)
				{
					SetCraftingRecipeVariant(recipe, variant);
					CraftingController.MarkRecipeGridLayoutDirty();
					UpdateCraftingPanelRedesign(gui, CraftingPanelUpdateReason.StateChanged);
				}
			}
		}

		private static void SetCraftingRecipeWithStoredVariant(InventoryGui gui, int index, bool center)
		{
			gui.SetRecipe(index, center);
			ApplyCraftingRecipeVariantToGui(gui, index);
		}

		private static void ApplyCraftingRecipeVariantToGui(InventoryGui gui, int index)
		{
			//IL_002d: 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)(object)gui == (Object)null) && TryGetCraftingRecipePair(gui, index, out var pair) && !((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null) && ((RecipeDataPair)(ref pair)).ItemData == null)
			{
				if (GetCraftingRecipeVariantCount(pair) <= 1)
				{
					gui.m_selectedVariant = 0;
				}
				else
				{
					gui.m_selectedVariant = GetCraftingRecipeVariant(pair);
				}
			}
		}

		private static int GetCraftingRecipeVariant(RecipeDataPair pair)
		{
			//IL_0017: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				return Mathf.Clamp(((RecipeDataPair)(ref pair)).ItemData.m_variant, 0, Mathf.Max(0, GetCraftingRecipeVariantCount(pair) - 1));
			}
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null || GetCraftingRecipeVariantCount(pair) <= 1)
			{
				return 0;
			}
			int value;
			return Mathf.Clamp(CraftingRecipes.Variants.TryGetValue(((RecipeDataPair)(ref pair)).Recipe, out value) ? value : 0, 0, GetCraftingRecipeVariantCount(pair) - 1);
		}

		private static void SetCraftingRecipeVariant(Recipe recipe, int variant)
		{
			if (!((Object)(object)recipe == (Object)null))
			{
				int recipeVariantCount = GetRecipeVariantCount(recipe);
				int num = Mathf.Clamp(variant, 0, Mathf.Max(0, recipeVariantCount - 1));
				if (!CraftingRecipes.Variants.TryGetValue(recipe, out var value) || value != num)
				{
					CraftingRecipes.Variants[recipe] = num;
					_craftingRecipeVariantVersion++;
				}
			}
		}

		private static int GetCraftingRecipeVariantCount(RecipeDataPair pair)
		{
			if (!((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null))
			{
				return 1;
			}
			return GetRecipeVariantCount(((RecipeDataPair)(ref pair)).Recipe);
		}

		private static int GetRecipeVariantCount(Recipe recipe)
		{
			ItemData val = (((Object)(object)recipe?.m_item != (Object)null) ? recipe.m_item.m_itemData : null);
			if (val?.m_shared == null || val.m_shared.m_icons == null)
			{
				return 1;
			}
			int num = Mathf.Max(1, val.m_shared.m_icons.Length);
			int num2 = Mathf.Max(1, val.m_shared.m_variants);
			return Mathf.Min(num, num2);
		}

		private static Sprite? GetCraftingRecipeIcon(RecipeDataPair pair)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				return ((RecipeDataPair)(ref pair)).ItemData.GetIcon();
			}
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe?.m_item == (Object)null)
			{
				return null;
			}
			ItemData itemData = ((RecipeDataPair)(ref pair)).Recipe.m_item.m_itemData;
			int craftingRecipeVariant = GetCraftingRecipeVariant(pair);
			if (itemData.m_shared?.m_icons != null && craftingRecipeVariant >= 0 && craftingRecipeVariant < itemData.m_shared.m_icons.Length)
			{
				return itemData.m_shared.m_icons[craftingRecipeVariant];
			}
			return itemData.GetIcon();
		}

		private static void ConfigureCraftingRecipeCellAmountText(TMP_Text? text, string value, float cellSize)
		{
			//IL_0012: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			ConfigureCraftingRecipeCellText(text, value, cellSize, (TextAlignmentOptions)1026, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 1f));
		}

		private static void ConfigureCraftingRecipeCellQualityText(TMP_Text? text, string value, float cellSize)
		{
			//IL_0012: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			ConfigureCraftingRecipeCellText(text, value, cellSize, (TextAlignmentOptions)260, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-1f, -1f));
		}

		private static void ConfigureCraftingRecipeCellText(TMP_Text? text, string value, float cellSize, TextAlignmentOptions alignment, Vector2 anchor, Vector2 pivot, Vector2 direction)
		{
			//IL_002c: 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_006b: 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_00a9: 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_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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)text == (Object)null))
			{
				ApplyDefaultFontAsset(text);
				text.text = value;
				((Component)text).gameObject.SetActive(!string.IsNullOrEmpty(value));
				text.alignment = alignment;
				text.textWrappingMode = (TextWrappingModes)0;
				((Graphic)text).raycastTarget = false;
				text.fontSize = Mathf.Clamp(cellSize * 0.28f, 16f, 34f);
				RectTransform rectTransform = text.rectTransform;
				rectTransform.anchorMin = anchor;
				rectTransform.anchorMax = anchor;
				rectTransform.pivot = pivot;
				float num = Mathf.Clamp(cellSize * 0.06f, 4f, 10f);
				float num2 = Mathf.Clamp(cellSize * 0.32f, 20f, 42f);
				rectTransform.anchoredPosition = new Vector2(direction.x * num, direction.y * num);
				rectTransform.sizeDelta = new Vector2(cellSize - num * 2f, num2);
				((Transform)rectTransform).localScale = Vector3.one;
				((Transform)rectTransform).localRotation = Quaternion.identity;
			}
		}

		private static void SetCraftingRecipeCellChild(GameObject? child, bool active)
		{
			//IL_003e: 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_0050: 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)
			if ((Object)(object)child == (Object)null)
			{
				return;
			}
			Image val = default(Image);
			if (string.Equals(((Object)child).name, "selected", StringComparison.OrdinalIgnoreCase) && child.TryGetComponent<Image>(ref val))
			{
				if (!child.activeSelf)
				{
					child.SetActive(true);
				}
				((Behaviour)val).enabled = true;
				Color color = ((Graphic)val).color;
				color.a = (active ? Mathf.Max(color.a, 0.38f) : 0f);
				((Graphic)val).color = color;
			}
			else if (child.activeSelf != active)
			{
				child.SetActive(active);
			}
		}

		private static void SetCraftingRecipeFavoriteBorder(CraftingRecipeGridCell cell, bool active, bool upgradeFavorite)
		{
			//IL_0052: 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)
			RectTransform val = EnsureCraftingRecipeFavoriteBorder(cell);
			if (!((Object)(object)val == (Object)null))
			{
				Image[] componentsInChildren = ((Component)val).GetComponentsInChildren<Image>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Graphic)componentsInChildren[i]).color = (upgradeFavorite ? new Color(0.2f, 0.95f, 0.38f, 0.96f) : new Color(1f, 0.82f, 0.1f, 0.96f));
				}
				((Component)val).gameObject.SetActive(active);
				if (active)
				{
					((Transform)val).SetAsLastSibling();
				}
			}
		}

		private static void SetCraftingRecipePinnedTooltipMarker(CraftingRecipeGridCell cell, bool active, float cellSize)
		{
			RectTransform val = EnsureCraftingRecipePinnedTooltipMarker(cell);
			if (!((Object)(object)val == (Object)null))
			{
				ConfigureCraftingRecipePinnedTooltipMarker(val, cellSize);
				((Component)val).gameObject.SetActive(active);
				if (active)
				{
					((Transform)val).SetAsLastSibling();
				}
			}
		}

		private static RectTransform? EnsureCraftingRecipePinnedTooltipMarker(CraftingRecipeGridCell cell)
		{
			if ((Object)(object)cell.Rect == (Object)null || IsUnityNull((Object?)(object)cell.Rect))
			{
				return null;
			}
			Transform val = ((Transform)cell.Rect).Find("InventorySlots_CraftingPinnedTooltipMarker");
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = CreateTextRect("InventorySlots_CraftingPinnedTooltipMarker", (Transform)(object)cell.Rect, out TMP_Text text, active: false);
				text.text = "T";
			}
			return val2;
		}

		private static void ConfigureCraftingRecipePinnedTooltipMarker(RectTransform marker, float cellSize)
		{
			//IL_00a7: 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_00c5: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null || IsUnityNull((Object?)(object)marker))
			{
				return;
			}
			float num = Mathf.Clamp(cellSize * 0.06f, 4f, 8f);
			float num2 = Mathf.Clamp(cellSize * 0.34f, 20f, 28f);
			float num3 = Mathf.Clamp(cellSize * 0.28f, 16f, 24f);
			string text = $"{num:0.###}|{num2:0.###}|{num3:0.###}";
			CraftingPinnedTooltipMarkerState craftingPinnedTooltipMarkerState = ((Component)marker).GetComponent<CraftingPinnedTooltipMarkerState>() ?? ((Component)marker).gameObject.AddComponent<CraftingPinnedTooltipMarkerState>();
			if (!string.Equals(craftingPinnedTooltipMarkerState.LayoutSignature, text, StringComparison.Ordinal))
			{
				SetRectLayout(marker, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(0f - num, num), new Vector2(num2, num2));
				TMP_Text component = ((Component)marker).GetComponent<TMP_Text>();
				if ((Object)(object)component == (Object)null)
				{
					craftingPinnedTooltipMarkerState.LayoutSignature = text;
					return;
				}
				ApplyDefaultFontAsset(component);
				component.text = "T";
				component.alignment = (TextAlignmentOptions)1028;
				component.textWrappingMode = (TextWrappingModes)0;
				component.fontSize = num3;
				((Graphic)component).color = Color.white;
				component.outlineColor = new Color32((byte)0, (byte)0, (byte)0, (byte)230);
				component.outlineWidth = 0.18f;
				((Graphic)component).raycastTarget = false;
				craftingPinnedTooltipMarkerState.LayoutSignature = text;
			}
		}

		private static RectTransform? EnsureCraftingRecipeFavoriteBorder(CraftingRecipeGridCell cell)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//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_0080: 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_0096: 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_00bb: 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_00d9: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cell.Rect == (Object)null || IsUnityNull((Object?)(object)cell.Rect))
			{
				return null;
			}
			Transform obj = ((Transform)cell.Rect).Find("InventorySlots_CraftingFavoriteBorder");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				return val;
			}
			GameObject val2 = new GameObject("InventorySlots_CraftingFavoriteBorder", new Type[1] { typeof(RectTransform) });
			RectTransform component = val2.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)cell.Rect, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Transform)component).localScale = Vector3.one;
			((Transform)component).localRotation = Quaternion.identity;
			CreateFavoriteBorderSide(component, "Top", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, 2f), Vector2.zero);
			CreateFavoriteBorderSide(component, "Bottom", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 2f), Vector2.zero);
			CreateFavoriteBorderSide(component, "Left", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(0f, 0.5f), new Vector2(2f, 0f), Vector2.zero);
			CreateFavoriteBorderSide(component, "Right", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(1f, 0.5f), new Vector2(2f, 0f), Vector2.zero);
			val2.SetActive(false);
			return component;
		}

		private static bool RectContainsCraftingRecipeIconArea(RectTransform grid, Vector2 screenPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Vector2.op_Implicit(((Transform)grid).InverseTransformPoint(Vector2.op_Implicit(screenPoint)));
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(0f, -576f, 576f, 576f);
			return ((Rect)(ref val2)).Contains(val);
		}

		private static void UpdateCraftingGroupRail(InventoryGui gui, RectTransform grid)
		{
			//IL_00ad: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_012e: 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_015e: 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_0180: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = EnsureCraftingGroupRail(gui);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			IReadOnlyList<CraftingRecipeGroupFilter> selectableCraftingGroupFilters = GetSelectableCraftingGroupFilters(gui);
			CraftingGroupRailStamp craftingGroupRailStamp = GetCraftingGroupRailStamp(gui, grid);
			if (CraftingController.CanReuseGroupRail(craftingGroupRailStamp))
			{
				return;
			}
			if (!string.IsNullOrEmpty(_selectedCraftingGroupId) && selectableCraftingGroupFilters.All((CraftingRecipeGroupFilter craftingRecipeGroupFilter) => craftingRecipeGroupFilter.Id != _selectedCraftingGroupId))
			{
				_selectedCraftingGroupId = "";
				_craftingRecipePage = 0;
				CraftingController.ClearHoveredRecipe();
				InvalidateCraftingRecipeView();
				selectableCraftingGroupFilters = GetSelectableCraftingGroupFilters(gui);
				craftingGroupRailStamp = GetCraftingGroupRailStamp(gui, grid);
			}
			if (selectableCraftingGroupFilters.Count == 0)
			{
				((Component)val).gameObject.SetActive(false);
				CraftingController.StoreGroupRailStamp(craftingGroupRailStamp);
				return;
			}
			((Component)val).gameObject.SetActive(true);
			Vector2 craftingGroupBlockSize = GetCraftingGroupBlockSize(selectableCraftingGroupFilters);
			val.anchoredPosition = grid.anchoredPosition + CraftingGroupRailFixedOffset;
			((Transform)val).SetAsLastSibling();
			float x = craftingGroupBlockSize.x;
			float x2 = craftingGroupBlockSize.x;
			float y = craftingGroupBlockSize.y;
			CraftingRecipeGroupPanel craftingRecipeGroupPanel = EnsureCraftingGroupPanel(val, 0);
			((Component)craftingRecipeGroupPanel.Rect).gameObject.SetActive(true);
			craftingRecipeGroupPanel.Rect.anchorMin = new Vector2(0f, 1f);
			craftingRecipeGroupPanel.Rect.anchorMax = new Vector2(0f, 1f);
			craftingRecipeGroupPanel.Rect.pivot = new Vector2(0f, 1f);
			craftingRecipeGroupPanel.Rect.sizeDelta = new Vector2(x, y);
			craftingRecipeGroupPanel.Rect.anchoredPosition = Vector2.zero;
			((Transform)craftingRecipeGroupPanel.Rect).localScale = Vector3.one;
			((Transform)craftingRecipeGroupPanel.Rect).localRotation = Quaternion.identity;
			if ((Object)(object)craftingRecipeGroupPanel.Background != (Object)null)
			{
				craftingRecipeGroupPanel.Background.sprite = GetSolidUiSprite();
				((Graphic)craftingRecipeGroupPanel.Background).color = Color.clear;
				((Graphic)craftingRecipeGroupPanel.Background).raycastTarget = false;
			}
			for (int num = 0; num < selectableCraftingGroupFilters.Count; num++)
			{
				CraftingRecipeGroupFilter filter = selectableCraftingGroupFilters[num];
				CraftingRecipeGroupButton button = EnsureCraftingGroupButton(gui, craftingRecipeGroupPanel.Rect, num);
				bool hasRecipes = CraftingGroupHasRecipes(gui, filter);
				ConfigureCraftingGroupButton(gui, button, filter, num, x, x2, hasRecipes);
			}
			for (int num2 = 1; num2 < CraftingRecipes.GroupPanels.Count; num2++)
			{
				RectTransform rect = CraftingRecipes.GroupPanels[num2].Rect;
				if (!IsUnityNull((Object?)(object)rect))
				{
					((Component)rect).gameObject.SetActive(false);
				}
			}
			for (int num3 = selectableCraftingGroupFilters.Count; num3 < CraftingRecipes.GroupButtons.Count; num3++)
			{
				GameObject go = CraftingRecipes.GroupButtons[num3].Go;
				if (!IsUnityNull((Object?)(object)go))
				{
					go.SetActive(false);
				}
			}
			val.sizeDelta = new Vector2(x, y);
			CraftingController.StoreGroupRailStamp(craftingGroupRailStamp);
		}

		private static void HideCraftingGroupRail()
		{
			if ((Object)(object)_craftingGroupRail != (Object)null && !IsUnityNull((Object?)(object)_craftingGroupRail))
			{
				((Component)_craftingGroupRail).gameObject.SetActive(false);
			}
			CraftingController.StoreGroupRailStamp(default(CraftingGroupRailStamp));
		}

		private static CraftingGroupRailStamp GetCraftingGroupRailStamp(InventoryGui gui, RectTransform grid)
		{
			//IL_0012: 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)
			return new CraftingGroupRailStamp(((Object)gui.m_crafting).GetInstanceID(), ((Object)grid).GetInstanceID(), grid.anchoredPosition.x, grid.anchoredPosition.y, _selectedCraftingGroupId, _craftingFavoritesVersion, GetCraftingGroupIconBackgroundAlpha(), _craftingGroupAvailabilitySignature, _craftingSelectableGroupFilterIdsSignature);
		}

		private static RectTransform? EnsureCraftingGroupRail(InventoryGui gui)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_craftingGroupRail != (Object)null && !IsUnityNull((Object?)(object)_craftingGroupRail) && (Object)(object)((Transform)_craftingGroupRail).parent == (Object)(object)gui.m_crafting)
			{
				ConfigureCraftingGroupRail(_craftingGroupRail);
				return _craftingGroupRail;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingGroupRail");
			_craftingGroupRail = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingGroupRail == (Object)null)
			{
				_craftingGroupRail = new GameObject("InventorySlots_CraftingGroupRail", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)_craftingGroupRail).SetParent((Transform)(object)gui.m_crafting, false);
			}
			ConfigureCraftingGroupRail(_craftingGroupRail);
			return _craftingGroupRail;
		}

		private static void ConfigureCraftingGroupRail(RectTransform rail)
		{
			//IL_000b: 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_0035: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			rail.anchorMin = new Vector2(0f, 1f);
			rail.anchorMax = new Vector2(0f, 1f);
			rail.pivot = new Vector2(0f, 1f);
			((Transform)rail).localScale = Vector3.one;
			((Transform)rail).localRotation = Quaternion.identity;
		}

		private static Vector2 GetCraftingGroupBlockSize(IReadOnlyList<CraftingRecipeGroupFilter> filters)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(1, filters.Count);
			return new Vector2(60f, 60f * (float)num);
		}

		private static CraftingRecipeGroupPanel EnsureCraftingGroupPanel(RectTransform rail, int index)
		{
			while (CraftingRecipes.GroupPanels.Count <= index)
			{
				CraftingRecipes.GroupPanels.Add(CreateCraftingGroupPanel(rail, CraftingRecipes.GroupPanels.Count));
			}
			CraftingRecipeGroupPanel craftingRecipeGroupPanel = CraftingRecipes.GroupPanels[index];
			if (IsUnityNull((Object?)(object)craftingRecipeGroupPanel.Rect))
			{
				craftingRecipeGroupPanel = CreateCraftingGroupPanel(rail, index);
				CraftingRecipes.GroupPanels[index] = craftingRecipeGroupPanel;
			}
			if ((Object)(object)((Transform)craftingRecipeGroupPanel.Rect).parent != (Object)(object)rail)
			{
				((Transform)craftingRecipeGroupPanel.Rect).SetParent((Transform)(object)rail, false);
			}
			return craftingRecipeGroupPanel;
		}

		private static CraftingRecipeGroupPanel CreateCraftingGroupPanel(RectTransform rail, int index)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject("InventorySlots_CraftingGroupPanel_" + index, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)rail, false);
			return new CraftingRecipeGroupPanel(component);
		}

		private static CraftingRecipeGroupButton EnsureCraftingGroupButton(InventoryGui gui, RectTransform panel, int index)
		{
			while (CraftingRecipes.GroupButtons.Count <= index)
			{
				CraftingRecipes.GroupButtons.Add(CreateCraftingGroupButton(panel, CraftingRecipes.GroupButtons.Count));
			}
			CraftingRecipeGroupButton craftingRecipeGroupButton = CraftingRecipes.GroupButtons[index];
			if (IsUnityNull((Object?)(object)craftingRecipeGroupButton.Go) || IsUnityNull((Object?)(object)craftingRecipeGroupButton.Rect))
			{
				craftingRecipeGroupButton = CreateCraftingGroupButton(panel, index);
				CraftingRecipes.GroupButtons[index] = craftingRecipeGroupButton;
			}
			if ((Object)(object)((Transform)craftingRecipeGroupButton.Rect).parent != (Object)(object)panel)
			{
				((Transform)craftingRecipeGroupButton.Rect).SetParent((Transform)(object)panel, false);
			}
			return craftingRecipeGroupButton;
		}

		private static CraftingRecipeGroupButton CreateCraftingGroupButton(RectTransform panel, int index)
		{
			GameObject obj = CreateFallbackCraftingGroupButton(panel);
			((Object)obj).name = "InventorySlots_CraftingGroupButton_" + index;
			obj.SetActive(true);
			Button component = obj.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((Selectable)component).interactable = false;
			}
			return new CraftingRecipeGroupButton(obj);
		}

		private static GameObject CreateFallbackCraftingGroupButton(RectTransform parent)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventorySlots_CraftingGroupButton_fallback", new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(UIInputHandler),
				typeof(UITooltip)
			});
			val.SetActive(false);
			val.transform.SetParent((Transform)(object)parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).color = new Color(0.05f, 0.035f, 0.02f, 0.72f);
			((Graphic)component).raycastTarget = true;
			((Transform)new GameObject("icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>()).SetParent(val.transform, false);
			CreateTextRect("Label", val.transform);
			return val;
		}

		private static void ConfigureCraftingGroupButton(InventoryGui gui, CraftingRecipeGroupButton button, CraftingRecipeGroupFilter filter, int position, float tabWidth, float tabHeight, bool hasRecipes)
		{
			//IL_001c: 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_0050: 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_007f: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: 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_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: 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_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: 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)
			button.Go.SetActive(false);
			button.Rect.anchorMin = new Vector2(0f, 1f);
			button.Rect.anchorMax = new Vector2(0f, 1f);
			button.Rect.pivot = new Vector2(0f, 1f);
			button.Rect.sizeDelta = new Vector2(tabWidth, tabHeight);
			button.Rect.anchoredPosition = new Vector2(0f, (float)(-position) * tabHeight);
			((Transform)button.Rect).localScale = Vector3.one;
			((Transform)button.Rect).localRotation = Quaternion.identity;
			bool flag = string.Equals(_selectedCraftingGroupId, filter.Id, StringComparison.Ordinal);
			bool flag2 = string.Equals(filter.Id, "favorite", StringComparison.OrdinalIgnoreCase);
			bool flag3 = hasRecipes || flag2;
			float craftingGroupIconBackgroundAlpha = GetCraftingGroupIconBackgroundAlpha();
			if ((Object)(object)button.Background != (Object)null)
			{
				button.Background.sprite = GetSolidUiSprite();
				((Graphic)button.Background).color = (flag ? new Color(1f, 0.55f, 0.04f, flag3 ? 0.92f : 0.62f) : new Color(0.08f, 0.05f, 0.03f, flag3 ? craftingGroupIconBackgroundAlpha : (craftingGroupIconBackgroundAlpha * 0.5f)));
				((Graphic)button.Background).raycastTarget = true;
			}
			TMP_Text val = EnsureCraftingGroupButtonLabel(button.Rect);
			ApplyDefaultFontAsset(val);
			Sprite craftingGroupIcon = GetCraftingGroupIcon(gui, filter);
			if ((Object)(object)button.Icon != (Object)null)
			{
				((Component)button.Icon).gameObject.SetActive((Object)(object)craftingGroupIcon != (Object)null);
				button.Icon.sprite = craftingGroupIcon;
				((Graphic)button.Icon).color = (Color)(flag3 ? Color.white : new Color(1f, 1f, 1f, 0.42f));
				button.Icon.preserveAspect = true;
				((Graphic)button.Icon).raycastTarget = false;
				RectTransform rectTransform = ((Graphic)button.Icon).rectTransform;
				float num = Mathf.Clamp(3f, 0f, Mathf.Min(tabWidth, tabHeight) * 0.45f);
				float num2 = Mathf.Max(4f, Mathf.Min(tabWidth, tabHeight) - num * 2f);
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				rectTransform.pivot = new Vector2(0.5f, 0.5f);
				rectTransform.sizeDelta = new Vector2(num2, num2);
				rectTransform.anchoredPosition = Vector2.zero;
				((Transform)rectTransform).localScale = Vector3.one;
				((Transform)rectTransform).localRotation = Quaternion.identity;
				((Transform)rectTransform).SetAsLastSibling();
			}
			((Component)val).gameObject.SetActive((Object)(object)craftingGroupIcon == (Object)null);
			val.text = GetCraftingGroupLabel(filter);
			((Graphic)val).color = (Color)(flag ? new Color(0.12f, 0.07f, 0.035f, 1f) : (flag3 ? Color.white : new Color(1f, 1f, 1f, 0.45f)));
			val.fontSize = Mathf.Clamp(tabHeight * 0.42f, 8f, 18f);
			val.fontStyle = (FontStyles)(flag ? 1 : 0);
			val.alignment = (TextAlignmentOptions)4098;
			val.textWrappingMode = (TextWrappingModes)0;
			val.overflowMode = (TextOverflowModes)1;
			((Graphic)val).raycastTarget = false;
			RectTransform rectTransform2 = val.rectTransform;
			rectTransform2.anchorMin = Vector2.zero;
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = Vector2.zero;
			rectTransform2.offsetMax = Vector2.zero;
			((Transform)rectTransform2).localScale = Vector3.one;
			((Transform)rectTransform2).localRotation = Quaternion.identity;
			((Transform)rectTransform2).SetAsLastSibling();
			TMP_Text[] componentsInChildren = ((Component)button.Rect).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val2 in componentsInChildren)
			{
				if ((Object)(object)val2 != (Object)(object)val)
				{
					((Component)val2).gameObject.SetActive(false);
				}
			}
			if ((Object)(object)button.Icon != (Object)null && (Object)(object)craftingGroupIcon != (Object)null)
			{
				((Transform)((Graphic)button.Icon).rectTransform).SetAsLastSibling();
			}
			if ((Object)(object)button.ActiveOverlay != (Object)null)
			{
				((Component)button.ActiveOverlay).gameObject.SetActive(false);
			}
			button.Go.SetActive(true);
			button.Marker.FilterId = filter.Id;
			if (!button.Marker.Initialized)
			{
				UIInputHandler input = button.Input;
				input.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(input.m_onLeftClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					ToggleCraftingGroupFilter(((Component)handler).GetComponent<CraftingGroupButtonMarker>()?.FilterId ?? "");
				});
				button.Marker.Initialized = true;
			}
			string craftingGroupTooltip = GetCraftingGroupTooltip(filter);
			string text = (flag2 ? GetCraftingClearFavoritesTooltipText() : "");
			ConfigureSimpleTooltip(button.Go, craftingGroupTooltip, text, enabled: true);
		}

		private static string GetCraftingGroupTooltip(CraftingRecipeGroupFilter filter)
		{
			string fallback = (string.Equals(filter.Id, "favorite", StringComparison.OrdinalIgnoreCase) ? "Favorite" : filter.Tooltip);
			return LocalizeUi(GetCraftingGroupTooltipToken(filter.Id), fallback);
		}

		private static string GetCraftingGroupLabel(CraftingRecipeGroupFilter filter)
		{
			return LocalizeUi(GetCraftingGroupLabelToken(filter.Id), filter.Label);
		}

		private static string GetCraftingClearFavoritesTooltipText()
		{
			string craftingClearFavoritesKeyDisplayText = GetCraftingClearFavoritesKeyDisplayText();
			if (string.IsNullOrWhiteSpace(craftingClearFavoritesKeyDisplayText))
			{
				return "";
			}
			return LocalizeUi("$inventoryslots_clear_favorites_hint_format", "{key}: clear favorites").Replace("{key}", craftingClearFavoritesKeyDisplayText);
		}

		private static string GetCraftingClearFavoritesKeyDisplayText()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return JoinShortcutDisplayTexts((_craftingClearFavoritesKey != null) ? _craftingClearFavoritesKey.Value.GetDisplayText() : ((KeyCode)325).GetDisplayText(), GetControllerHotkeyDisplayText(_controllerClearCraftingFavoritesButton));
		}

		private static string GetCraftingGroupTooltipToken(string id)
		{
			return NormalizeGroupId(id) switch
			{
				"favorite" => "$inventoryslots_group_favorite", 
				"melee" => "$inventoryslots_group_melee", 
				"ranged" => "$inventoryslots_group_ranged", 
				"magic" => "$inventoryslots_group_magic", 
				"armor" => "$inventoryslots_group_equipment", 
				"food" => "$inventoryslots_group_food", 
				"consumable" => "$inventoryslots_group_consumable", 
				"meadbase" => "$inventoryslots_group_meadbase", 
				"tool" => "$inventoryslots_group_tool", 
				"misc" => "$inventoryslots_group_misc", 
				_ => "$inventoryslots_group_" + NormalizeGroupId(id), 
			};
		}

		private static string GetCraftingGroupLabelToken(string id)
		{
			return NormalizeGroupId(id) switch
			{
				"favorite" => "$inventoryslots_group_favorite_short", 
				"ranged" => "$inventoryslots_group_ranged_short", 
				"armor" => "$inventoryslots_group_equipment_short", 
				"consumable" => "$inventoryslots_group_consumable_short", 
				"meadbase" => "$inventoryslots_group_meadbase_short", 
				_ => GetCraftingGroupTooltipToken(id), 
			};
		}

		private static float GetCraftingGroupIconBackgroundAlpha()
		{
			return 0f;
		}

		private static void HandleCraftingGroupFavoriteClearShortcut()
		{
			if (IsCraftingClearFavoritesHotkeyDown() && TryGetHoveredCraftingGroupButton(out CraftingRecipeGroupButton button))
			{
				CraftingRecipeGroupButton craftingRecipeGroupButton = button;
				if (string.Equals(craftingRecipeGroupButton.Marker.FilterId, "favorite", StringComparison.OrdinalIgnoreCase))
				{
					ClearCraftingFavoritesFromGroup(craftingRecipeGroupButton.Marker.FilterId);
				}
			}
		}

		private static bool IsCraftingClearFavoritesHotkeyDown()
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (_craftingClearFavoritesKey != null)
			{
				KeyboardShortcut value = _craftingClearFavoritesKey.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0 && IsShortcutDownAllowingAltPair(_craftingClearFavoritesKey.Value))
				{
					return true;
				}
			}
			return IsControllerHotkeyDown(_controllerClearCraftingFavoritesButton);
		}

		private static string JoinShortcutDisplayTexts(string first, string second)
		{
			if (string.IsNullOrWhiteSpace(first))
			{
				return second;
			}
			if (!string.IsNullOrWhiteSpace(second))
			{
				return first + "/" + second;
			}
			return first;
		}

		private static bool TryGetHoveredCraftingGroupButton(out CraftingRecipeGroupButton? button)
		{
			//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_0069: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uiMousePosition = GetUiMousePosition();
			foreach (CraftingRecipeGroupButton groupButton in CraftingRecipes.GroupButtons)
			{
				if (!((Object)(object)groupButton.Go == (Object)null) && !IsUnityNull((Object?)(object)groupButton.Go) && groupButton.Go.activeInHierarchy && !((Object)(object)groupButton.Rect == (Object)null) && !IsUnityNull((Object?)(object)groupButton.Rect) && RectContainsScreenPoint(groupButton.Rect, uiMousePosition))
				{
					button = groupButton;
					return true;
				}
			}
			button = null;
			return false;
		}

		private static TMP_Text EnsureCraftingGroupButtonLabel(RectTransform button)
		{
			Transform val = ((Transform)button).Find("Label");
			TMP_Text val2 = default(TMP_Text);
			if ((Object)(object)val != (Object)null && ((Component)val).TryGetComponent<TMP_Text>(ref val2))
			{
				((Component)val2).gameObject.SetActive(true);
				return val2;
			}
			return ((Component)CreateTextRect("Label", (Transform)(object)button)).GetComponent<TMP_Text>();
		}

		private static void ToggleCraftingGroupFilter(string filterId)
		{
			if (!string.IsNullOrEmpty(filterId))
			{
				_selectedCraftingGroupId = (string.Equals(_selectedCraftingGroupId, filterId, StringComparison.Ordinal) ? "" : filterId);
				_craftingRecipePage = 0;
				CraftingController.ClearHoveredRecipe();
				InvalidateCraftingRecipeView();
				ClearCraftingQueue();
				InventoryGui instance = InventoryGui.instance;
				if ((Object)(object)instance != (Object)null && ShouldShowCraftingPanelRedesign(instance))
				{
					UpdateCraftingPanelRedesign(instance, CraftingPanelUpdateReason.StateChanged);
				}
			}
		}

		private static void ClearCraftingFavoritesFromGroup(string filterId)
		{
			if (!string.Equals(filterId, "favorite", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null) && ClearCraftingFavorites(Player.m_localPlayer, instance.InUpradeTab()))
			{
				if (string.Equals(_selectedCraftingGroupId, "favorite", StringComparison.OrdinalIgnoreCase))
				{
					_selectedCraftingGroupId = "";
				}
				InvalidateCraftingRecipeView();
			}
		}

		private static IReadOnlyList<CraftingRecipeGroupFilter> GetSelectableCraftingGroupFilters(InventoryGui gui)
		{
			EnsureCraftingGroupAvailabilityCache(gui);
			return CraftingRecipes.SelectableGroupFilterCache;
		}

		private static bool CraftingGroupHasRecipes(InventoryGui gui, CraftingRecipeGroupFilter filter)
		{
			EnsureCraftingGroupAvailabilityCache(gui);
			bool value;
			return CraftingRecipes.GroupHasRecipesCache.TryGetValue(filter.Id, out value) && value;
		}

		private static void EnsureCraftingGroupAvailabilityCache(InventoryGui gui)
		{
			object availableRecipes = gui.m_availableRecipes;
			int num = gui.m_availableRecipes?.Count ?? (-1);
			string craftingRecipeListContextSignature = GetCraftingRecipeListContextSignature(gui);
			if (_craftingGroupAvailabilityBuiltVersion == _craftingGroupAvailabilityVersion && _craftingGroupAvailabilityRecipeListRef == availableRecipes && _craftingGroupAvailabilityRecipeCount == num && string.Equals(_craftingGroupAvailabilityContextSignature, craftingRecipeListContextSignature, StringComparison.Ordinal))
			{
				return;
			}
			CraftingRecipes.SelectableGroupFilterCache.Clear();
			CraftingRecipes.GroupHasRecipesCache.Clear();
			_craftingSelectableGroupFilterIdsSignature = "";
			if (gui.m_availableRecipes == null)
			{
				foreach (CraftingRecipeGroupFilter craftingRecipeGroupFilter in CraftingRecipeGroupFilters)
				{
					bool num2 = string.Equals(craftingRecipeGroupFilter.Id, "favorite", StringComparison.OrdinalIgnoreCase);
					CraftingRecipes.GroupHasRecipesCache[craftingRecipeGroupFilter.Id] = false;
					if (num2)
					{
						CraftingRecipes.SelectableGroupFilterCache.Add(craftingRecipeGroupFilter);
					}
				}
				StoreCraftingGroupAvailabilityCacheStamp(availableRecipes, num, craftingRecipeListContextSignature);
				return;
			}
			foreach (CraftingRecipeGroupFilter filter in CraftingRecipeGroupFilters)
			{
				bool num3 = string.Equals(filter.Id, "favorite", StringComparison.OrdinalIgnoreCase);
				bool flag = gui.m_availableRecipes.Any((RecipeDataPair pair) => RecipeMatchesCraftingGroup(pair, filter));
				CraftingRecipes.GroupHasRecipesCache[filter.Id] = flag;
				if (num3 || flag)
				{
					CraftingRecipes.SelectableGroupFilterCache.Add(filter);
				}
			}
			StoreCraftingGroupAvailabilityCacheStamp(availableRecipes, num, craftingRecipeListContextSignature);
		}

		private static void StoreCraftingGroupAvailabilityCacheStamp(object? recipeListRef, int recipeCount, string contextSignature)
		{
			_craftingGroupAvailabilityRecipeListRef = recipeListRef;
			_craftingGroupAvailabilityRecipeCount = recipeCount;
			_craftingGroupAvailabilityContextSignature = contextSignature;
			_craftingGroupAvailabilityBuiltVersion = _craftingGroupAvailabilityVersion;
			_craftingGroupAvailabilitySignature = $"{_craftingGroupAvailabilityBuiltVersion}|{recipeCount}|{CraftingRecipeGroupFilters.Count}|{PredefinedGroupDefinitions.Count}|{ResourceTierByToken.Count}|{CraftingRecipes.SelectableGroupFilterCache.Count}";
			_craftingSelectableGroupFilterIdsSignature = string.Join(",", CraftingRecipes.SelectableGroupFilterCache.Select((CraftingRecipeGroupFilter filter) => filter.Id));
		}

		private static void ClearCraftingGroupAvailabilityCache()
		{
			_craftingGroupAvailabilityVersion++;
			_craftingGroupAvailabilityBuiltVersion = -1;
			_craftingGroupAvailabilityRecipeListRef = null;
			_craftingGroupAvailabilityRecipeCount = -1;
			_craftingGroupAvailabilitySignature = "";
			_craftingGroupAvailabilityContextSignature = "";
			_craftingSelectableGroupFilterIdsSignature = "";
			CraftingRecipes.SelectableGroupFilterCache.Clear();
			CraftingRecipes.GroupHasRecipesCache.Clear();
		}

		private static Sprite? GetCraftingGroupIcon(InventoryGui gui, CraftingRecipeGroupFilter filter)
		{
			//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_004c: 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)
			if (string.Equals(filter.Id, "favorite", StringComparison.OrdinalIgnoreCase))
			{
				return GetFavoriteCraftingGroupIcon();
			}
			Sprite icon = filter.GetIcon(gui);
			if ((Object)(object)icon != (Object)null)
			{
				return icon;
			}
			if (gui.m_availableRecipes == null)
			{
				return null;
			}
			foreach (RecipeDataPair availableRecipe in gui.m_availableRecipes)
			{
				if (RecipeMatchesCraftingGroup(availableRecipe, filter))
				{
					ItemData craftingRecipeItemData = GetCraftingRecipeItemData(availableRecipe);
					if (craftingRecipeItemData != null)
					{
						return craftingRecipeItemData.GetIcon();
					}
				}
			}
			return null;
		}

		private static Sprite GetFavoriteCraftingGroupIcon()
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0095: 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_00d8: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_01a4: 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_01ea: 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_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: 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_029e: Expected O, but got Unknown
			if ((Object)(object)_craftingFavoriteGroupIcon != (Object)null && !IsUnityNull((Object?)(object)_craftingFavoriteGroupIcon))
			{
				return _craftingFavoriteGroupIcon;
			}
			Texture2D val = new Texture2D(96, 96, (TextureFormat)4, false)
			{
				name = "InventorySlots_FavoriteGroupIconTexture",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color32[] array = Enumerable.Repeat<Color32>(new Color32((byte)0, (byte)0, (byte)0, (byte)0), 9216).ToArray();
			DrawRect(array, 96, 19, 28, 77, 56, new Color32((byte)86, (byte)48, (byte)24, byte.MaxValue));
			DrawRect(array, 96, 22, 32, 74, 53, new Color32((byte)128, (byte)78, (byte)34, byte.MaxValue));
			DrawRect(array, 96, 18, 54, 78, 70, new Color32((byte)118, (byte)66, (byte)31, byte.MaxValue));
			DrawRect(array, 96, 22, 58, 74, 67, new Color32((byte)174, (byte)102, (byte)42, byte.MaxValue));
			DrawRect(array, 96, 18, 52, 78, 57, new Color32((byte)38, (byte)22, (byte)14, byte.MaxValue));
			DrawRect(array, 96, 18, 25, 78, 31, new Color32((byte)38, (byte)22, (byte)14, byte.MaxValue));
			DrawRect(array, 96, 17, 28, 23, 56, new Color32((byte)38, (byte)22, (byte)14, byte.MaxValue));
			DrawRect(array, 96, 73, 28, 79, 56, new Color32((byte)38, (byte)22, (byte)14, byte.MaxValue));
			DrawRect(array, 96, 20, 42, 76, 48, new Color32((byte)219, (byte)157, (byte)55, byte.MaxValue));
			DrawRect(array, 96, 45, 27, 53, 56, new Color32((byte)215, (byte)148, (byte)42, byte.MaxValue));
			DrawRect(array, 96, 42, 37, 56, 49, new Color32((byte)42, (byte)28, (byte)16, byte.MaxValue));
			DrawRect(array, 96, 46, 39, 52, 47, new Color32((byte)243, (byte)192, (byte)70, byte.MaxValue));
			DrawRect(array, 96, 26, 60, 44, 64, new Color32((byte)235, (byte)167, (byte)68, byte.MaxValue));
			DrawRect(array, 96, 55, 34, 70, 38, new Color32((byte)182, (byte)105, (byte)40, byte.MaxValue));
			DrawRect(array, 96, 28, 34, 38, 38, new Color32((byte)73, (byte)39, (byte)21, (byte)180));
			val.SetPixels32(array);
			val.Apply(false, true);
			_craftingFavoriteGroupIcon = Sprite.Create(val, new Rect(0f, 0f, 96f, 96f), new Vector2(0.5f, 0.5f), 100f);
			((Object)_craftingFavoriteGroupIcon).name = "InventorySlots_FavoriteGroupIcon";
			return _craftingFavoriteGroupIcon;
		}

		private static void DrawRect(Color32[] pixels, int textureSize, int xMin, int yMin, int xMax, int yMax, Color32 color)
		{
			//IL_0042: 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)
			xMin = Mathf.Clamp(xMin, 0, textureSize - 1);
			xMax = Mathf.Clamp(xMax, 0, textureSize - 1);
			yMin = Mathf.Clamp(yMin, 0, textureSize - 1);
			yMax = Mathf.Clamp(yMax, 0, textureSize - 1);
			for (int i = yMin; i <= yMax; i++)
			{
				int num = i * textureSize;
				for (int j = xMin; j <= xMax; j++)
				{
					pixels[num + j] = color;
				}
			}
		}

		private static void UpdateCraftingSearchInput(InventoryGui gui, RectTransform grid)
		{
			//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_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_0026: 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_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_003a: 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_0079: 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)
			RectTransform val = EnsureCraftingSearchInput(gui);
			if (!((Object)(object)val == (Object)null))
			{
				Vector2 size = GetCraftingSearchInputSize(gui);
				Vector2 val2 = GetCraftingSearchInputPosition(gui, grid, ref size) + CraftingSearchInputFixedOffset + GetCraftingSearchCompatOffset(gui, size);
				CraftingSearchInputStamp craftingSearchInputStamp = GetCraftingSearchInputStamp(gui, val, val2, size);
				((Component)val).gameObject.SetActive(true);
				if (((Transform)val).GetSiblingIndex() != ((Transform)val).parent.childCount - 1)
				{
					((Transform)val).SetAsLastSibling();
				}
				if (!CraftingController.CanReuseSearchInput(craftingSearchInputStamp))
				{
					SetCraftingTopLeftRect(gui.m_crafting, val, val2, size);
					ConfigureCraftingSearchInputStyle(gui, val);
					CraftingController.StoreSearchInputStamp(craftingSearchInputStamp);
				}
			}
		}

		private static CraftingSearchInputStamp GetCraftingSearchInputStamp(InventoryGui gui, RectTransform inputRect, Vector2 position, Vector2 size)
		{
			//IL_0060: 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_006c: 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)
			Image val = (((Object)(object)gui.m_tabCraft != (Object)null && !IsUnityNull((Object?)(object)gui.m_tabCraft)) ? ((Selectable)gui.m_tabCraft).image : null);
			bool focused = (Object)(object)CraftingUi.SearchInput != (Object)null && CraftingUi.SearchInput.isFocused;
			return new CraftingSearchInputStamp(((Object)gui.m_crafting).GetInstanceID(), ((Object)inputRect).GetInstanceID(), position.x, position.y, size.x, size.y, _craftingSearchQuery, _uiLocalizationVersion, focused, GetUnityObjectId((Object?)(object)val), GetUnityObjectId((Object?)(object)((val != null) ? val.sprite : null)), GetUnityObjectId((Object?)(object)((val != null) ? ((Graphic)val).material : null)));
		}

		private static RectTransform? EnsureCraftingSearchInput(InventoryGui gui)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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_01d1: 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_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			if ((Object)(object)CraftingUi.SearchInputRect != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.SearchInputRect) && (Object)(object)((Transform)CraftingUi.SearchInputRect).parent == (Object)(object)gui.m_crafting)
			{
				return CraftingUi.SearchInputRect;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingSearchInput");
			CraftingUi.SearchInputRect = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)CraftingUi.SearchInputRect == (Object)null)
			{
				CraftingUi.SearchInputRect = new GameObject("InventorySlots_CraftingSearchInput", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(TMP_InputField)
				}).GetComponent<RectTransform>();
				((Transform)CraftingUi.SearchInputRect).SetParent((Transform)(object)gui.m_crafting, false);
				CraftingController.MarkSearchInputDirty();
				Image component = ((Component)CraftingUi.SearchInputRect).GetComponent<Image>();
				((Graphic)component).raycastTarget = true;
				RectTransform component2 = new GameObject("Text Area", new Type[2]
				{
					typeof(RectTransform),
					typeof(RectMask2D)
				}).GetComponent<RectTransform>();
				((Transform)component2).SetParent((Transform)(object)CraftingUi.SearchInputRect, false);
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.offsetMin = new Vector2(12f, 4f);
				component2.offsetMax = new Vector2(-12f, -4f);
				TMP_Text text;
				RectTransform obj = CreateTextRect("Placeholder", (Transform)(object)component2, out text);
				text.text = GetCraftingSearchPlaceholderText();
				text.fontSize = 18f;
				((Graphic)text).color = new Color(1f, 0.86f, 0.52f, 0.55f);
				text.alignment = (TextAlignmentOptions)4097;
				obj.anchorMin = Vector2.zero;
				obj.anchorMax = Vector2.one;
				obj.offsetMin = Vector2.zero;
				obj.offsetMax = Vector2.zero;
				TMP_Text text2;
				RectTransform obj2 = CreateTextRect("Text", (Transform)(object)component2, out text2);
				text2.fontSize = 18f;
				((Graphic)text2).color = Color.white;
				text2.alignment = (TextAlignmentOptions)4097;
				obj2.anchorMin = Vector2.zero;
				obj2.anchorMax = Vector2.one;
				obj2.offsetMin = Vector2.zero;
				obj2.offsetMax = Vector2.zero;
				CraftingUi.SearchInput = ((Component)CraftingUi.SearchInputRect).GetComponent<TMP_InputField>();
				CraftingUi.SearchInput.textViewport = component2;
				CraftingUi.SearchInput.textComponent = text2;
				CraftingUi.SearchInput.placeholder = (Graphic)(object)text;
				((Selectable)CraftingUi.SearchInput).targetGraphic = (Graphic)(object)component;
				CraftingUi.SearchInput.contentType = (ContentType)0;
				CraftingUi.SearchInput.lineType = (LineType)0;
				CraftingUi.SearchInput.characterLimit = 48;
				CraftingUi.SearchInput.restoreOriginalTextOnEscape = false;
				((UnityEvent<string>)(object)CraftingUi.SearchInput.onValueChanged).AddListener((UnityAction<string>)UpdateCraftingSearchQuery);
			}
			else
			{
				CraftingUi.SearchInput = ((Component)CraftingUi.SearchInputRect).GetComponent<TMP_InputField>();
				CraftingController.MarkSearchInputDirty();
			}
			if ((Object)(object)CraftingUi.SearchInput != (Object)null && CraftingUi.SearchInput.text != _craftingSearchQuery)
			{
				CraftingUi.SearchInput.SetTextWithoutNotify(_craftingSearchQuery);
			}
			TMP_InputField? searchInput = CraftingUi.SearchInput;
			Graphic obj3 = ((searchInput != null) ? searchInput.placeholder : null);
			TMP_Text val2 = (TMP_Text)(object)((obj3 is TMP_Text) ? obj3 : null);
			if (val2 != null)
			{
				ApplyDefaultFontAsset(val2);
				val2.text = GetCraftingSearchPlaceholderText();
			}
			return CraftingUi.SearchInputRect;
		}

		private static Vector2 GetCraftingSearchInputSize(InventoryGui gui)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			float num = 32f;
			if ((Object)(object)gui.m_tabCraft != (Object)null)
			{
				Transform transform = ((Component)gui.m_tabCraft).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val != null)
				{
					num = Mathf.Clamp(GetRectHeight(val), 28f, 42f);
				}
			}
			return new Vector2(136f, num);
		}

		private static void ConfigureCraftingSearchInputStyle(InventoryGui gui, RectTransform inputRect)
		{
			//IL_0054: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)inputRect).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				Image val = (((Object)(object)gui.m_tabCraft != (Object)null && !IsUnityNull((Object?)(object)gui.m_tabCraft)) ? ((Selectable)gui.m_tabCraft).image : null);
				if ((Object)(object)val != (Object)null)
				{
					component.sprite = val.sprite;
					component.type = val.type;
					((Graphic)component).material = ((Graphic)val).material;
					component.pixelsPerUnitMultiplier = val.pixelsPerUnitMultiplier;
				}
				else
				{
					component.sprite = GetSolidUiSprite();
					component.type = (Type)1;
				}
				((Graphic)component).color = (((Object)(object)CraftingUi.SearchInput != (Object)null && CraftingUi.SearchInput.isFocused) ? new Color(0.18f, 0.12f, 0.07f, 0.96f) : new Color(0.05f, 0.035f, 0.025f, 0.92f));
				((Graphic)component).raycastTarget = true;
			}
			if ((Object)(object)CraftingUi.SearchInput != (Object)null)
			{
				((Selectable)CraftingUi.SearchInput).targetGraphic = (Graphic)(object)component;
			}
		}

		private static Vector2 GetCraftingSearchInputPosition(InventoryGui gui, RectTransform grid, ref Vector2 size)
		{
			//IL_000c: 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_0056: 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)
			size.x = 136f;
			float num = grid.anchoredPosition.x + 432f;
			float num2 = grid.anchoredPosition.y + 58f;
			if (TryGetCraftingPrimaryTabBounds(gui, out var bounds))
			{
				size.y = bounds.Height;
				return new Vector2(num, bounds.Top);
			}
			return new Vector2(num, num2);
		}

		private static Vector2 GetCraftingSearchCompatOffset(InventoryGui gui, Vector2 searchSize)
		{
			//IL_0018: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldOffsetCraftingSearchForRecycleNReclaim(gui))
			{
				return Vector2.zero;
			}
			return new Vector2(0f, Mathf.Max(0f, searchSize.y));
		}

		private static bool ShouldOffsetCraftingSearchForRecycleNReclaim(InventoryGui gui)
		{
			if (HasPlugin("Azumatt.Recycle_N_Reclaim"))
			{
				return HasVisibleRecycleNReclaimCraftingTab(gui);
			}
			return false;
		}

		private static bool HasVisibleRecycleNReclaimCraftingTab(InventoryGui gui)
		{
			if ((Object)(object)gui == (Object)null || IsUnityNull((Object?)(object)gui) || (Object)(object)gui.m_crafting == (Object)null || IsUnityNull((Object?)(object)gui.m_crafting))
			{
				return false;
			}
			int instanceID = ((Object)gui).GetInstanceID();
			int frameCount = Time.frameCount;
			if (_visibleRecycleNReclaimTabFrame == frameCount && _visibleRecycleNReclaimTabGuiId == instanceID)
			{
				return _visibleRecycleNReclaimTabValue;
			}
			_visibleRecycleNReclaimTabFrame = frameCount;
			_visibleRecycleNReclaimTabGuiId = instanceID;
			_visibleRecycleNReclaimTabValue = false;
			Transform[] componentsInChildren = ((Component)gui.m_crafting).GetComponentsInChildren<Transform>(false);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)val == (Object)(object)gui.m_crafting)
				{
					continue;
				}
				if (IsRecycleNReclaimUiToken(((Object)val).name ?? ""))
				{
					_visibleRecycleNReclaimTabValue = true;
					return true;
				}
				Component[] components = ((Component)val).GetComponents<Component>();
				foreach (Component val2 in components)
				{
					if (IsRecycleNReclaimUiToken(((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2)) ? (((object)val2).GetType().FullName ?? ((object)val2).GetType().Name) : ""))
					{
						_visibleRecycleNReclaimTabValue = true;
						return true;
					}
				}
				TMP_Text component = ((Component)val).GetComponent<TMP_Text>();
				if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component) && IsRecycleNReclaimUiToken(component.text ?? ""))
				{
					_visibleRecycleNReclaimTabValue = true;
					return true;
				}
			}
			return false;
		}

		private static bool IsRecycleNReclaimUiToken(string value)
		{
			if (value.IndexOf("reclaim", StringComparison.OrdinalIgnoreCase) < 0 && value.IndexOf("recycle", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return value.IndexOf("recycling", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static string GetCraftingSearchPlaceholderText()
		{
			return LocalizeUi("$inventoryslots_search", "Search");
		}

		private static void UpdateCraftingSortModeButtons(InventoryGui gui, RectTransform grid)
		{
			//IL_0020: 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_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_003a: 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_0045: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00d7: 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)
			RectTransform val = EnsureCraftingSortModeButtonGroup(gui);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)gui.m_crafting == (Object)null))
			{
				Vector2 size = GetCraftingSearchInputSize(gui);
				Vector2 val2 = GetCraftingSearchInputPosition(gui, grid, ref size) + CraftingSearchInputFixedOffset + GetCraftingSearchCompatOffset(gui, size);
				float num = Mathf.Clamp(size.y, 26f, 34f);
				Vector2 size2 = default(Vector2);
				((Vector2)(ref size2))..ctor(num * 2f + 4f, num);
				Vector2 val3 = val2 + new Vector2(0f, num + 4f) + CraftingSortModeButtonsFixedOffset;
				CraftingSortModeButtonsStamp craftingSortModeButtonsStamp = GetCraftingSortModeButtonsStamp(gui, val, val3, size2, num);
				((Component)val).gameObject.SetActive(true);
				if (((Transform)val).GetSiblingIndex() != ((Transform)val).parent.childCount - 1)
				{
					((Transform)val).SetAsLastSibling();
				}
				if (!CraftingController.CanReuseSortModeButtons(craftingSortModeButtonsStamp))
				{
					SetCraftingTopLeftRect(gui.m_crafting, val, val3, size2);
					ConfigureCraftingSortModeButton(gui, val, "InventorySlots_CraftingGroupFirstSortButton", 0, num, CraftingRecipeSortMode.GroupThenTier);
					ConfigureCraftingSortModeButton(gui, val, "InventorySlots_CraftingTierFirstSortButton", 1, num, CraftingRecipeSortMode.TierThenGroup);
					CraftingController.StoreSortModeButtonsStamp(craftingSortModeButtonsStamp);
				}
			}
		}

		private static CraftingSortModeButtonsStamp GetCraftingSortModeButtonsStamp(InventoryGui gui, RectTransform group, Vector2 position, Vector2 size, float buttonSize)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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)
			Image val = (((Object)(object)gui.m_tabCraft != (Object)null && !IsUnityNull((Object?)(object)gui.m_tabCraft)) ? ((Selectable)gui.m_tabCraft).image : null);
			CraftingRecipeSortMode craftingRecipeSortMode = GetCraftingRecipeSortMode();
			return new CraftingSortModeButtonsStamp(((Object)gui.m_crafting).GetInstanceID(), ((Object)group).GetInstanceID(), position.x, position.y, size.x, size.y, buttonSize, craftingRecipeSortMode, _uiLocalizationVersion, GetUnityObjectId((Object?)(object)val), GetUnityObjectId((Object?)(object)((val != null) ? val.sprite : null)), GetUnityObjectId((Object?)(object)((val != null) ? ((Graphic)val).material : null)));
		}

		private static RectTransform? EnsureCraftingSortModeButtonGroup(InventoryGui gui)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_craftingSortModeButtonGroup != (Object)null && !IsUnityNull((Object?)(object)_craftingSortModeButtonGroup) && (Object)(object)((Transform)_craftingSortModeButtonGroup).parent == (Object)(object)gui.m_crafting)
			{
				return _craftingSortModeButtonGroup;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingSortModeButtons");
			_craftingSortModeButtonGroup = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingSortModeButtonGroup == (Object)null)
			{
				_craftingSortModeButtonGroup = new GameObject("InventorySlots_CraftingSortModeButtons", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)_craftingSortModeButtonGroup).SetParent((Transform)(object)gui.m_crafting, false);
			}
			CraftingController.ResetSortModeButtonsStamp();
			return _craftingSortModeButtonGroup;
		}

		private static void ConfigureCraftingSortModeButton(InventoryGui gui, RectTransform parent, string name, int index, float buttonSize, CraftingRecipeSortMode mode)
		{
			//IL_0020: 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_004a: 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_0074: 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_00e7: 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_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: 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_01d1: 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_01e7: 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)
			RectTransform obj = EnsureCraftingSortModeButton(parent, name, mode);
			((Component)obj).gameObject.SetActive(true);
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(0f, 1f);
			obj.pivot = new Vector2(0f, 1f);
			obj.anchoredPosition = new Vector2((float)index * (buttonSize + 4f), 0f);
			obj.sizeDelta = new Vector2(buttonSize, buttonSize);
			((Transform)obj).localScale = Vector3.one;
			((Transform)obj).localRotation = Quaternion.identity;
			bool flag = GetCraftingRecipeSortMode() == mode;
			Image component = ((Component)obj).GetComponent<Image>();
			if (component != null)
			{
				ApplyVanillaButtonImage(gui.m_variantButton, component);
				((Graphic)component).color = (flag ? new Color(1f, 0.55f, 0.04f, 0.92f) : new Color(0.05f, 0.035f, 0.025f, 0.92f));
				((Graphic)component).raycastTarget = true;
			}
			Transform obj2 = ((Transform)obj).Find("Label");
			TMP_Text val = ((obj2 != null) ? ((Component)obj2).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val != (Object)null)
			{
				ApplyDefaultFontAsset(val);
				val.text = GetCraftingSortModeButtonLabel(mode);
				val.alignment = (TextAlignmentOptions)514;
				val.enableAutoSizing = true;
				val.fontSizeMin = 10f;
				val.fontSizeMax = Mathf.Clamp(buttonSize * 0.62f, 13f, 18f);
				val.textWrappingMode = (TextWrappingModes)0;
				val.overflowMode = (TextOverflowModes)3;
				val.fontStyle = (FontStyles)(flag ? 1 : 0);
				((Graphic)val).color = (Color)(flag ? Color.white : new Color(1f, 0.86f, 0.52f, 0.95f));
				((Graphic)val).raycastTarget = false;
				RectTransform rectTransform = val.rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
				((Transform)rectTransform).localScale = Vector3.one;
				((Transform)rectTransform).localRotation = Quaternion.identity;
			}
			UITooltip component2 = ((Component)obj).GetComponent<UITooltip>();
			if ((Object)(object)component2 != (Object)null)
			{
				EnsureTooltipPrefab(component2);
				((Behaviour)component2).enabled = true;
				component2.Set(GetCraftingSortModeButtonTopic(mode), GetCraftingSortModeButtonText(mode), ((Object)(object)gui.m_playerGrid != (Object)null) ? gui.m_playerGrid.m_tooltipAnchor : null, default(Vector2));
			}
			InventorySlotsSimpleTooltipHover component3 = ((Component)obj).GetComponent<InventorySlotsSimpleTooltipHover>();
			if ((Object)(object)component3 != (Object)null && !IsUnityNull((Object?)(object)component3))
			{
				component3.Configure("", "");
			}
		}

		private static RectTransform EnsureCraftingSortModeButton(RectTransform parent, string name, CraftingRecipeSortMode mode)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Transform)parent).Find(name);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			val2 = new GameObject(name, new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(UIInputHandler),
				typeof(UITooltip)
			}).GetComponent<RectTransform>();
			((Transform)val2).SetParent((Transform)(object)parent, false);
			CreateTextRect("Label", (Transform)(object)val2);
			UIInputHandler component = ((Component)val2).GetComponent<UIInputHandler>();
			component.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(component.m_onLeftClick, (Action<UIInputHandler>)delegate
			{
				SetCraftingRecipeSortMode(mode);
			});
			return val2;
		}

		private static void SetCraftingRecipeSortMode(CraftingRecipeSortMode mode)
		{
			if (_craftingRecipeSortMode != null && _craftingRecipeSortMode.Value != mode)
			{
				_craftingRecipeSortMode.Value = mode;
			}
			CraftingController.ResetSortModeButtonsStamp();
			InvalidateCraftingRecipeView();
		}

		private static CraftingRecipeSortMode GetCraftingRecipeSortMode()
		{
			return _craftingRecipeSortMode?.Value ?? CraftingRecipeSortMode.TierThenGroup;
		}

		private static string GetCraftingSortModeButtonLabel(CraftingRecipeSortMode mode)
		{
			if (mode != CraftingRecipeSortMode.GroupThenTier)
			{
				return "T";
			}
			return "G";
		}

		private static string GetCraftingSortModeButtonTopic(CraftingRecipeSortMode mode)
		{
			if (mode != CraftingRecipeSortMode.GroupThenTier)
			{
				return LocalizeUi("$inventoryslots_sort_tier_first", "Tier first");
			}
			return LocalizeUi("$inventoryslots_sort_group_first", "Group first");
		}

		private static string GetCraftingSortModeButtonText(CraftingRecipeSortMode mode)
		{
			if (mode != CraftingRecipeSortMode.GroupThenTier)
			{
				return LocalizeUi("$inventoryslots_sort_tier_first_tooltip", "Sort by resource tier, then category.");
			}
			return LocalizeUi("$inventoryslots_sort_group_first_tooltip", "Sort by category, then resource tier.");
		}

		private static bool TryGetCraftingPrimaryTabBounds(InventoryGui gui, out CraftingTabRowBounds bounds)
		{
			//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_0059: 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_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_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_007f: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(CraftingTabRowBounds);
			if (!((Object)(object)gui.m_crafting == (Object)null) && !((Object)(object)gui.m_tabCraft == (Object)null))
			{
				Transform transform = ((Component)gui.m_tabCraft).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val != null)
				{
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					val.GetWorldCorners(array);
					Vector3 val2 = ((Transform)gui.m_crafting).InverseTransformPoint(array[0]);
					Vector3 val3 = ((Transform)gui.m_crafting).InverseTransformPoint(array[1]);
					Vector3 val4 = ((Transform)gui.m_crafting).InverseTransformPoint(array[2]);
					if (val4.x <= val3.x || val3.y <= val2.y)
					{
						return false;
					}
					bounds = new CraftingTabRowBounds(val3.x, val4.x, val3.y, val2.y);
					return true;
				}
			}
			return false;
		}

		private static void UpdateCraftingSearchQuery(string value)
		{
			string text = value.Trim();
			if (!string.Equals(_craftingSearchQuery, text, StringComparison.Ordinal))
			{
				_craftingSearchQuery = text;
				_craftingRecipePage = 0;
				CraftingController.ClearHoveredRecipe();
				CraftingController.MarkSearchInputDirty();
				InvalidateCraftingRecipeView();
			}
		}

		internal static bool IsCraftingSearchFocused()
		{
			if (!((Object)(object)CraftingUi.SearchInput != (Object)null) || !CraftingUi.SearchInput.isFocused)
			{
				if ((Object)(object)_craftingCountInput != (Object)null)
				{
					return _craftingCountInput.isFocused;
				}
				return false;
			}
			return true;
		}

		private static bool RecipeMatchesCraftingSearch(RecipeDataPair pair)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(_craftingSearchQuery))
			{
				return true;
			}
			string craftingRecipeSearchText = GetCraftingRecipeSearchText(pair);
			string[] array = _craftingSearchQuery.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				if (!craftingRecipeSearchText.Contains(text.ToLowerInvariant()))
				{
					return false;
				}
			}
			return true;
		}

		private static string GetCraftingRecipeSearchText(RecipeDataPair pair)
		{
			//IL_0000: 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)
			CraftingRecipePairCacheKey craftingRecipePairCacheKey = GetCraftingRecipePairCacheKey(pair);
			if (craftingRecipePairCacheKey.IsValid && CraftingRecipes.SearchTextCache.TryGetValue(craftingRecipePairCacheKey, out string value))
			{
				return value;
			}
			ItemData craftingRecipeItemData = GetCraftingRecipeItemData(pair);
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null || craftingRecipeItemData == null)
			{
				return "";
			}
			List<string> list = new List<string> { ((Object)(object)((RecipeDataPair)(ref pair)).Recipe.m_item != (Object)null) ? ((Object)((RecipeDataPair)(ref pair)).Recipe.m_item).name : "" };
			AddCraftingSearchLocalizedNameParts(list, craftingRecipeItemData.m_shared.m_name ?? "");
			if (((RecipeDataPair)(ref pair)).Recipe.m_resources != null)
			{
				Requirement[] resources = ((RecipeDataPair)(ref pair)).Recipe.m_resources;
				foreach (Requirement val in resources)
				{
					if (!((Object)(object)val?.m_resItem == (Object)null))
					{
						list.Add(((Object)val.m_resItem).name);
						AddCraftingSearchLocalizedNameParts(list, val.m_resItem.m_itemData.m_shared.m_name ?? "");
					}
				}
			}
			string text = string.Join(" ", list).ToLowerInvariant();
			if (craftingRecipePairCacheKey.IsValid)
			{
				CraftingRecipes.SearchTextCache[craftingRecipePairCacheKey] = text;
			}
			return text;
		}

		private static void AddCraftingSearchLocalizedNameParts(List<string> parts, string token)
		{
			AddCraftingSearchTextPart(parts, (Localization.instance != null) ? Localization.instance.Localize(token) : token);
			AddCraftingSearchTextPart(parts, GetEnglishLocalizedText(token));
		}

		private static void AddCraftingSearchTextPart(List<string> parts, string text)
		{
			if (!string.IsNullOrWhiteSpace(text) && !IsMissingLocalizationText(text))
			{
				parts.Add(text);
			}
		}

		private static bool IsMissingLocalizationText(string text)
		{
			if (text.Length >= 2 && text[0] == '[')
			{
				return text[text.Length - 1] == ']';
			}
			return false;
		}

		private static string GetEnglishLocalizedText(string token)
		{
			if (string.IsNullOrWhiteSpace(token) || token[0] != '$')
			{
				return token;
			}
			string key = token.TrimStart(new char[1] { '$' });
			if (CraftingRecipes.EnglishLocalizationCache.TryGetValue(key, out string value))
			{
				return value;
			}
			string text = TryGetIndexedEnglishLocalization(key);
			CraftingRecipes.EnglishLocalizationCache[key] = text;
			return text;
		}

		private static string TryGetIndexedEnglishLocalization(string key)
		{
			EnsureCraftingEnglishLocalizationIndex();
			if (!CraftingRecipes.EnglishLocalizationIndex.TryGetValue(key, out string value))
			{
				return "";
			}
			return value;
		}

		private static void EnsureCraftingEnglishLocalizationIndex()
		{
			if (_craftingEnglishLocalizationIndexBuilt)
			{
				return;
			}
			_craftingEnglishLocalizationIndexBuilt = true;
			CraftingRecipes.EnglishLocalizationIndex.Clear();
			try
			{
				BuildCraftingEnglishLocalizationIndex();
			}
			catch
			{
				CraftingRecipes.EnglishLocalizationIndex.Clear();
			}
		}

		private static void BuildCraftingEnglishLocalizationIndex()
		{
			Localization instance = Localization.instance;
			LocalizationSettings localizationSettings = Localization.m_localizationSettings;
			if (((localizationSettings != null) ? localizationSettings.Localizations : null) == null)
			{
				return;
			}
			foreach (TextAsset localization in Localization.m_localizationSettings.Localizations)
			{
				if ((Object)(object)localization == (Object)null || string.IsNullOrEmpty(localization.text))
				{
					continue;
				}
				using StringReader stringReader = new StringReader(localization.text);
				string text = stringReader.ReadLine();
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				string[] array = text.Split(new char[1] { ',' }, StringSplitOptions.None);
				int num = -1;
				for (int i = 0; i < array.Length; i++)
				{
					if (string.Equals(instance.StripCitations(array[i]), "English", StringComparison.Ordinal))
					{
						num = i;
						break;
					}
				}
				if (num < 0)
				{
					continue;
				}
				foreach (List<string> item in instance.DoQuoteLineSplit(stringReader))
				{
					if (item.Count != 0 && !string.IsNullOrWhiteSpace(item[0]) && item.Count > num)
					{
						string text2 = item[num].Trim();
						if ((string.IsNullOrEmpty(text2) || text2[0] == '\r') && item.Count > 1)
						{
							text2 = item[1].Trim();
						}
						if (!string.IsNullOrWhiteSpace(text2) && !CraftingRecipes.EnglishLocalizationIndex.ContainsKey(item[0]))
						{
							CraftingRecipes.EnglishLocalizationIndex[item[0]] = text2;
						}
					}
				}
			}
		}

		private static void ClearCraftingEnglishLocalizationCaches()
		{
			CraftingRecipes.EnglishLocalizationCache.Clear();
			CraftingRecipes.EnglishLocalizationIndex.Clear();
			_craftingEnglishLocalizationIndexBuilt = false;
		}

		private static bool HandleCraftingCountWheel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_craftingCountInputRect == (Object)null || !((Component)_craftingCountInputRect).gameObject.activeInHierarchy || !RectContainsScreenPoint(_craftingCountInputRect, GetUiMousePosition()))
			{
				return false;
			}
			if (IsCraftingCountInputLocked(InventoryGui.instance))
			{
				return false;
			}
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Discrete, allowGamepad: false);
			if (Mathf.Abs(uiScrollDelta) < 0.01f)
			{
				return false;
			}
			SetCraftingCount(GetCraftingCount() + ((uiScrollDelta > 0f) ? 1 : (-1)));
			return true;
		}

		private static int GetCraftingCount()
		{
			return ParseCraftingCount(((Object)(object)_craftingCountInput != (Object)null) ? _craftingCountInput.text : "1");
		}

		private static int GetEffectiveCraftingCount(InventoryGui? gui)
		{
			if ((Object)(object)gui == (Object)null || ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null)
			{
				return 1;
			}
			if (IsVanillaMultiCraftModifierHeld())
			{
				return Mathf.Max(1, gui.m_multiCraftAmount);
			}
			return GetCraftingCount();
		}

		private static bool IsVanillaMultiCraftModifierHeld()
		{
			try
			{
				return ZInput.GetButton("AltPlace") || ZInput.GetButton("JoyLStick");
			}
			catch
			{
				return Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
			}
		}

		private static int ParseCraftingCount(string value)
		{
			if (!int.TryParse(value, out var result))
			{
				return 1;
			}
			return Mathf.Clamp(result, 1, 99);
		}

		private static void SetCraftingCount(int count)
		{
			if (!((Object)(object)_craftingCountInput == (Object)null))
			{
				_craftingCountInput.SetTextWithoutNotify(Mathf.Clamp(count, 1, 99).ToString());
			}
		}

		private static bool CanContinueCraftingQueue(InventoryGui gui)
		{
			Player localPlayer = Player.m_localPlayer;
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)recipe == (Object)null || (Object)(object)CraftingQueue.QueueRecipe == (Object)null || (Object)(object)recipe != (Object)(object)CraftingQueue.QueueRecipe || gui.m_selectedVariant != CraftingQueue.QueueVariant || ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null)
			{
				return false;
			}
			int num = 1;
			int num2 = default(int);
			ItemData val = default(ItemData);
			int amount = recipe.GetAmount(num, ref num2, ref val, 1);
			if (!localPlayer.NoCostCheat() && !ZoneSystem.instance.GetGlobalKey((GlobalKeys)20) && !localPlayer.HaveRequirements(recipe, false, num, 1))
			{
				return false;
			}
			BeginCraftingInventoryLimitNotice();
			bool flag;
			try
			{
				flag = ((Humanoid)localPlayer).GetInventory().CanAddItem(((Component)recipe.m_item).gameObject, amount);
			}
			finally
			{
				EndCraftingInventoryLimitNotice(showMessage: true);
			}
			if (!flag)
			{
				return false;
			}
			CraftingStation requiredStation = recipe.GetRequiredStation(num);
			int requiredStationLevel = recipe.GetRequiredStationLevel(num);
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			if ((Object)(object)requiredStation != (Object)null)
			{
				if ((Object)(object)currentCraftingStation == (Object)null || currentCraftingStation.m_name != requiredStation.m_name || currentCraftingStation.GetLevel(true) < requiredStationLevel)
				{
					return false;
				}
				if (!currentCraftingStation.CheckUsable(localPlayer, false))
				{
					return false;
				}
			}
			return true;
		}

		internal static void BeginCraftingInventoryLimitNotice()
		{
			if (CraftingQueue.InventoryLimitNoticeDepth == 0)
			{
				CraftingQueue.PendingInventoryLimitItem = null;
				CraftingQueue.PendingInventoryLimitMax = -1;
			}
			CraftingQueue.InventoryLimitNoticeDepth++;
		}

		private static bool IsCraftingInventoryLimitNoticeActive()
		{
			return CraftingQueue.InventoryLimitNoticeDepth > 0;
		}

		private static void RecordCraftingInventoryLimitRejection(ItemData item, int maxAllowed)
		{
			if (IsCraftingInventoryLimitNoticeActive() && item?.m_shared != null && maxAllowed >= 0)
			{
				CraftingQueue.PendingInventoryLimitItem = item;
				CraftingQueue.PendingInventoryLimitMax = maxAllowed;
			}
		}

		internal static bool EndCraftingInventoryLimitNotice(bool showMessage)
		{
			if (CraftingQueue.InventoryLimitNoticeDepth <= 0)
			{
				return false;
			}
			CraftingQueue.InventoryLimitNoticeDepth--;
			if (CraftingQueue.InventoryLimitNoticeDepth > 0)
			{
				return false;
			}
			ItemData pendingInventoryLimitItem = CraftingQueue.PendingInventoryLimitItem;
			int pendingInventoryLimitMax = CraftingQueue.PendingInventoryLimitMax;
			CraftingQueue.PendingInventoryLimitItem = null;
			CraftingQueue.PendingInventoryLimitMax = -1;
			if (pendingInventoryLimitItem?.m_shared == null || pendingInventoryLimitMax < 0)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if (showMessage && (Object)(object)localPlayer != (Object)null)
			{
				ShowInventoryLimitReached(localPlayer, pendingInventoryLimitItem, pendingInventoryLimitMax, force: true);
			}
			return true;
		}

		private static bool CanAttemptJewelcraftingSocket(RecipeDataPair pair)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null && ((RecipeDataPair)(ref pair)).ItemData != null && ((RecipeDataPair)(ref pair)).Recipe.m_enabled && ((RecipeDataPair)(ref pair)).CanCraft)
			{
				return CanAffordJewelcraftingSocketAttempt(pair);
			}
			return false;
		}

		private static bool CanAffordJewelcraftingSocketAttempt(RecipeDataPair pair)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null)
			{
				return false;
			}
			if (ShouldHideJewelcraftingSocketRequirements(pair))
			{
				return true;
			}
			if (localPlayer.NoCostCheat() || ZoneSystem.instance.GetGlobalKey((GlobalKeys)20))
			{
				return true;
			}
			return localPlayer.HaveRequirementItems(((RecipeDataPair)(ref pair)).Recipe, false, 1, 1);
		}

		private static string GetSocketRecipeItemTooltip(RecipeDataPair pair)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = ((RecipeDataPair)(ref pair)).ItemData;
			if (itemData == null)
			{
				return "";
			}
			int quality = Mathf.Max(1, itemData.m_quality);
			int amount = ((RecipeDataPair)(ref pair)).Recipe?.m_amount ?? 1;
			string localizedStaticItemTooltip = GetLocalizedStaticItemTooltip(itemData, quality, crafting: false, amount);
			return AppendItemRequiresSkillLevelCraftingTooltip(pair, localizedStaticItemTooltip);
		}

		private static string GetUpgradeRecipeComparisonTooltip(RecipeDataPair pair)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = ((RecipeDataPair)(ref pair)).ItemData;
			if (itemData == null)
			{
				return "";
			}
			int num = Mathf.Max(1, itemData.m_quality);
			int quality = Mathf.Clamp(num + 1, 1, Mathf.Max(1, itemData.m_shared?.m_maxQuality ?? (num + 1)));
			int amount = ((RecipeDataPair)(ref pair)).Recipe?.m_amount ?? 1;
			ItemData item = CreateUpgradeTooltipPreviewItem(itemData, num);
			ItemData item2 = CreateUpgradeTooltipPreviewItem(itemData, quality);
			string localizedStaticItemTooltip = GetLocalizedStaticItemTooltip(item, num, crafting: false, amount);
			string localizedStaticItemTooltip2 = GetLocalizedStaticItemTooltip(item2, quality, crafting: false, amount);
			string tooltip = BuildUpgradeComparisonTooltip(localizedStaticItemTooltip, localizedStaticItemTooltip2);
			return AppendItemRequiresSkillLevelCraftingTooltip(pair, tooltip);
		}

		private static ItemData CreateUpgradeTooltipPreviewItem(ItemData item, int quality)
		{
			ItemData obj = item.Clone();
			obj.m_quality = quality;
			return obj;
		}

		private static string GetLocalizedStaticItemTooltip(ItemData item, int quality, bool crafting, int amount)
		{
			string tooltip = ItemData.GetTooltip(item, quality, crafting, (float)Game.m_worldLevel, amount);
			if (Localization.instance == null)
			{
				return tooltip;
			}
			return Localization.instance.Localize(tooltip);
		}

		private static string BuildUpgradeComparisonTooltip(string currentTooltip, string upgradedTooltip)
		{
			if (string.IsNullOrWhiteSpace(currentTooltip) || string.IsNullOrWhiteSpace(upgradedTooltip))
			{
				return upgradedTooltip;
			}
			string[] array = SplitTooltipLines(currentTooltip);
			string[] array2 = SplitTooltipLines(upgradedTooltip);
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string[] array3 = array;
			string value;
			foreach (string text in array3)
			{
				if (TrySplitTooltipStatLine(text, out string label, out value))
				{
					string key = NormalizeTooltipStatLabel(label);
					if (!dictionary.ContainsKey(key))
					{
						dictionary.Add(key, text);
					}
				}
			}
			for (int j = 0; j < array2.Length; j++)
			{
				if (TrySplitTooltipStatLine(array2[j], out string label2, out value) && dictionary.TryGetValue(NormalizeTooltipStatLabel(label2), out var value2))
				{
					array2[j] = BuildUpgradeComparisonLine(value2, array2[j]);
				}
			}
			return string.Join("\n", array2);
		}

		private static string[] SplitTooltipLines(string tooltip)
		{
			return tooltip.Replace("\r\n", "\n").Split(new char[1] { '\n' });
		}

		private static string BuildUpgradeComparisonLine(string currentLine, string upgradedLine)
		{
			string line = StripRichText(currentLine).Trim();
			string line2 = StripRichText(upgradedLine).Trim();
			if (!TrySplitTooltipStatLine(line, out string label, out string value) || !TrySplitTooltipStatLine(line2, out string label2, out string value2) || !string.Equals(NormalizeTooltipStatLabel(label), NormalizeTooltipStatLabel(label2), StringComparison.OrdinalIgnoreCase) || string.Equals(NormalizeTooltipStatValue(value), NormalizeTooltipStatValue(value2), StringComparison.OrdinalIgnoreCase) || !ContainsDigit(value) || !ContainsDigit(value2))
			{
				return upgradedLine;
			}
			if (IsDurabilityTooltipLabel(label2) && TryExtractDurabilityMaxValue(value, out string maxValue) && TryExtractDurabilityMaxValue(value2, out string maxValue2))
			{
				return label2 + ": <color=orange>" + maxValue + " > " + maxValue2 + "</color>";
			}
			return label2 + ": <color=orange>" + value.Trim() + " > " + value2.Trim() + "</color>";
		}

		private static bool IsDurabilityTooltipLabel(string label)
		{
			string text = NormalizeTooltipStatLabel(label);
			if (text.IndexOf("durability", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			string text2 = ((Localization.instance != null) ? Localization.instance.Localize("$item_durability") : "");
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return string.Equals(text, NormalizeTooltipStatLabel(text2), StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static bool TryExtractDurabilityMaxValue(string value, out string maxValue)
		{
			maxValue = "";
			string text = StripRichText(value).Trim();
			int num = text.LastIndexOf('/');
			if (num >= 0 && TryReadNumberToken(text, num + 1, out maxValue))
			{
				return true;
			}
			return TryReadLastNumberToken(text, out maxValue);
		}

		private static bool TryReadLastNumberToken(string text, out string number)
		{
			number = "";
			for (int num = text.Length - 1; num >= 0; num--)
			{
				if (char.IsDigit(text[num]))
				{
					int num2 = num;
					while (num2 > 0 && IsNumberTokenChar(text[num2 - 1]))
					{
						num2--;
					}
					number = text.Substring(num2, num - num2 + 1);
					return true;
				}
			}
			return false;
		}

		private static bool TryReadNumberToken(string text, int startIndex, out string number)
		{
			number = "";
			int i;
			for (i = startIndex; i < text.Length && char.IsWhiteSpace(text[i]); i++)
			{
			}
			int j;
			for (j = i; j < text.Length && IsNumberTokenChar(text[j]); j++)
			{
			}
			number = text.Substring(i, j - i).Trim();
			return number.Any(char.IsDigit);
		}

		private static bool IsNumberTokenChar(char c)
		{
			if (!char.IsDigit(c) && c != '.')
			{
				return c == ',';
			}
			return true;
		}

		private static bool TrySplitTooltipStatLine(string line, out string label, out string value)
		{
			label = "";
			value = "";
			string text = StripRichText(line).Trim();
			int num = text.IndexOf(':');
			if (num <= 0 || num >= text.Length - 1)
			{
				return false;
			}
			label = text.Substring(0, num).Trim();
			value = text.Substring(num + 1).Trim();
			if (!string.IsNullOrWhiteSpace(label))
			{
				return !string.IsNullOrWhiteSpace(value);
			}
			return false;
		}

		private static string NormalizeTooltipStatLabel(string label)
		{
			return new string(label.Where((char c) => !char.IsWhiteSpace(c)).ToArray());
		}

		private static string NormalizeTooltipStatValue(string value)
		{
			return new string(value.Where((char c) => !char.IsWhiteSpace(c)).ToArray());
		}

		private static bool ContainsDigit(string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				if (char.IsDigit(value[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static List<CraftingRecipeGroupFilter> CreateCraftingRecipeGroupFilters()
		{
			List<CraftingRecipeGroupFilter> list = new List<CraftingRecipeGroupFilter>
			{
				new CraftingRecipeGroupFilter("favorite", "Favorite", "Favor", (ItemData _) => false, "piece_chest_treasure")
			};
			foreach (BuiltInItemGroupSection section in ItemGroupRegistry.Sections)
			{
				list.Add(new CraftingRecipeGroupFilter(section.Id, section.Tab, section.Label, GetCraftingRecipeGroupMatcher(section.Id), section.IconPrefab));
			}
			return list;
		}

		private static Func<ItemData, bool> GetCraftingRecipeGroupMatcher(string sectionId)
		{
			return sectionId switch
			{
				"melee" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"ranged" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"magic" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"tool" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"armor" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"food" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"consumable" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"meadbase" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				"misc" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId), 
				_ => throw new InvalidOperationException("Unknown built-in item group section '" + sectionId + "'."), 
			};
		}

		private static int GetCraftingRecipeGridAvailabilityHash(InventoryGui gui, int pageStart)
		{
			//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_00a4: Unknown result type (might be due to invalid IL or missing references)
			int num = 17;
			int craftingRecipeGridCapacity = GetCraftingRecipeGridCapacity();
			for (int i = 0; i < craftingRecipeGridCapacity; i++)
			{
				int num2 = pageStart + i;
				if (num2 < 0 || num2 >= CraftingRecipes.View.Count)
				{
					num = num * 31 - 1;
					continue;
				}
				RecipeDataPair pair = CraftingRecipes.View[num2].Pair;
				int originalIndex = CraftingRecipes.View[num2].OriginalIndex;
				num = num * 31 + originalIndex;
				num = num * 31 + (((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null && ((RecipeDataPair)(ref pair)).Recipe.m_enabled) ? 1 : 0);
				num = num * 31 + (((RecipeDataPair)(ref pair)).CanCraft ? 1 : 0);
				bool flag = IsCraftingRecipeActionAvailable(gui, pair, originalIndex);
				num = num * 31 + (flag ? 1 : 0);
			}
			return num;
		}

		internal static void OnCraftingRecipeListUpdated(InventoryGui gui)
		{
			if (!((Object)(object)gui == (Object)null) && CraftingController.TryStoreRecipeListChangeSignature(GetCraftingRecipeListChangeSignature(gui)))
			{
				UpdateCraftingPanelRedesign(gui, CraftingPanelUpdateReason.RecipeListChanged);
			}
		}

		private static string GetCraftingRecipeListChangeSignature(InventoryGui gui)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			int num = 17;
			num = num * 31 + ((Object)gui).GetInstanceID();
			num = num * 31 + (IsCraftingCraftTabSelected(gui) ? 1 : 0);
			num = num * 31 + (IsCraftingUpgradeTabSelected(gui) ? 1 : 0);
			CraftingTabAdapterState craftingTabAdapterState = GetCraftingTabAdapterState(gui);
			num = num * 31 + craftingTabAdapterState.Kind.GetHashCode();
			int num2 = gui.m_availableRecipes?.Count ?? (-1);
			num = num * 31 + num2;
			if (gui.m_availableRecipes != null)
			{
				for (int i = 0; i < gui.m_availableRecipes.Count; i++)
				{
					num = num * 31 + GetCraftingRecipePairChangeHash(gui.m_availableRecipes[i]);
				}
			}
			if (craftingTabAdapterState.IsRecycleNReclaim)
			{
				num = num * 31 + StringComparer.Ordinal.GetHashCode(GetRecycleNReclaimContextSignature());
				num = num * 31 + StringComparer.Ordinal.GetHashCode(GetRecycleNReclaimRecipeListSignature(gui));
			}
			return $"{num2}:{num}";
		}

		private static int GetCraftingRecipePairChangeHash(RecipeDataPair pair)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			int num = 17;
			Recipe recipe = ((RecipeDataPair)(ref pair)).Recipe;
			ItemData itemData = ((RecipeDataPair)(ref pair)).ItemData;
			num = num * 31 + (((Object)(object)recipe != (Object)null) ? ((Object)recipe).GetInstanceID() : 0);
			num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(((Object)(object)recipe != (Object)null) ? (((Object)recipe).name ?? "") : "");
			num = num * 31 + (((Object)(object)recipe?.m_item != (Object)null) ? ((Object)recipe.m_item).GetInstanceID() : 0);
			num = num * 31 + (((Object)(object)recipe != (Object)null && recipe.m_enabled) ? 1 : 0);
			num = num * 31 + (recipe?.m_amount ?? 0);
			num = num * 31 + (recipe?.m_resources?.Length).GetValueOrDefault();
			num = num * 31 + (((RecipeDataPair)(ref pair)).CanCraft ? 1 : 0);
			num = num * 31 + StringComparer.Ordinal.GetHashCode(GetVeiledRecipeDisplaySignature(pair));
			num = num * 31 + ((itemData != null) ? RuntimeHelpers.GetHashCode(itemData) : 0);
			if (itemData?.m_shared == null)
			{
				return num;
			}
			num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(GetItemPrefabName(itemData));
			num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(itemData.m_shared.m_name ?? "");
			num = num * 31 + itemData.m_quality;
			num = num * 31 + itemData.m_variant;
			num = num * 31 + itemData.m_stack;
			num = num * 31 + itemData.m_gridPos.x;
			num = num * 31 + itemData.m_gridPos.y;
			return num * 31 + (itemData.m_equipped ? 1 : 0);
		}

		private static bool UpdateCraftingRecipeView(InventoryGui gui)
		{
			//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_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_00b5: 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_00cc: 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 (gui.m_availableRecipes == null)
			{
				CraftingRecipes.View.Clear();
				CraftingRecipes.ViewIndexByOriginal.Clear();
				CraftingController.StoreRecipeViewSignature("");
				CraftingController.MarkRecipeGridLayoutDirty();
				return true;
			}
			CraftingTabAdapterState adapter = GetCraftingTabAdapterState(gui);
			string craftingRecipeViewSignature = GetCraftingRecipeViewSignature(gui, adapter);
			if (CraftingController.CanReuseRecipeView(craftingRecipeViewSignature))
			{
				return false;
			}
			CraftingRecipes.View.Clear();
			for (int i = 0; i < gui.m_availableRecipes.Count; i++)
			{
				RecipeDataPair pair = gui.m_availableRecipes[i];
				if (!((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null) && ShouldIncludeRecipeInCraftingTabView(adapter, pair))
				{
					bool isVeiledRecipeMasked = IsVeiledRecipeMasked(pair);
					CraftingRecipes.View.Add(new CraftingRecipeViewEntry(i, pair, !adapter.IsRecycleNReclaim && IsFavoriteCraftingRecipe(pair), GetCraftingRecipeSortKey(pair), isVeiledRecipeMasked, IsVeiledRecipePreview(pair)));
				}
			}
			CraftingRecipes.View.Sort((CraftingRecipeViewEntry a, CraftingRecipeViewEntry b) => CompareCraftingRecipeViewEntriesForAdapter(adapter, a, b));
			RebuildCraftingRecipeViewIndexCache();
			CraftingController.StoreRecipeViewSignature(craftingRecipeViewSignature);
			CraftingController.MarkRecipeGridLayoutDirty();
			return true;
		}

		private static void RebuildCraftingRecipeViewIndexCache()
		{
			CraftingRecipes.ViewIndexByOriginal.Clear();
			for (int i = 0; i < CraftingRecipes.View.Count; i++)
			{
				CraftingRecipes.ViewIndexByOriginal[CraftingRecipes.View[i].OriginalIndex] = i;
			}
		}

		private static string GetCraftingRecipeViewSignature(InventoryGui gui, CraftingTabAdapterState? adapter = null)
		{
			CraftingTabAdapterState value = adapter ?? GetCraftingTabAdapterState(gui);
			string text = _craftingRecipeSortMode?.Value.ToString() ?? "";
			return $"{GetCraftingRecipeListContextSignature(gui, value)}|{_selectedCraftingGroupId}|{_craftingSearchQuery}|{text}|{_craftingFavoritesVersion}|{_loadedCraftingFavoritesPlayerId}|{GetVeiledRecipeGroupingSignature()}";
		}

		private static string GetCraftingRecipeListContextSignature(InventoryGui gui, CraftingTabAdapterState? adapter = null)
		{
			int num = ((gui.m_availableRecipes != null) ? RuntimeHelpers.GetHashCode(gui.m_availableRecipes) : 0);
			int num2 = gui.m_availableRecipes?.Count ?? (-1);
			CraftingTabAdapterState craftingTabAdapterState = adapter ?? GetCraftingTabAdapterState(gui);
			string text = (craftingTabAdapterState.IsRecycleNReclaim ? (GetRecycleNReclaimContextSignature() + "|" + GetRecycleNReclaimRecipeListSignature(gui)) : "");
			return $"list={num}|count={num2}|craft={IsCraftingCraftTabSelected(gui)}|upgrade={IsCraftingUpgradeTabSelected(gui)}|adapter={craftingTabAdapterState.Kind}|rnr={text}";
		}

		private static int GetSelectedCraftingRecipeIndexSafe(InventoryGui gui)
		{
			try
			{
				return gui.GetSelectedRecipeIndex(true);
			}
			catch
			{
				return -1;
			}
		}

		private static SortKey GetCraftingRecipeSortKey(RecipeDataPair pair)
		{
			//IL_0000: 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)
			CraftingRecipePairCacheKey craftingRecipePairCacheKey = GetCraftingRecipePairCacheKey(pair);
			if (craftingRecipePairCacheKey.IsValid && CraftingRecipes.SortKeyCache.TryGetValue(craftingRecipePairCacheKey, out SortKey value))
			{
				return value;
			}
			SortKey sortKey = CreateCraftingRecipeSortKey(pair);
			if (craftingRecipePairCacheKey.IsValid)
			{
				CraftingRecipes.SortKeyCache[craftingRecipePairCacheKey] = sortKey;
			}
			return sortKey;
		}

		private static int GetCraftingRecipeResourceTier(Recipe? recipe)
		{
			if (ResourceTierByToken.Count == 0)
			{
				return 0;
			}
			if (recipe?.m_resources == null)
			{
				return int.MinValue;
			}
			int num = int.MinValue;
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (!((Object)(object)val?.m_resItem == (Object)null) && val.m_amount > 0 && TryGetResourceTier(val.m_resItem, out var tier))
				{
					num = Mathf.Max(num, tier);
				}
			}
			return num;
		}

		private static bool TryGetResourceTier(ItemDrop itemDrop, out int tier)
		{
			tier = 0;
			if ((Object)(object)itemDrop == (Object)null || itemDrop.m_itemData?.m_shared == null)
			{
				return false;
			}
			foreach (string resourceToken in GetResourceTokens(itemDrop))
			{
				if (ResourceTierByToken.TryGetValue(resourceToken, out tier))
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<string> GetResourceTokens(ItemDrop itemDrop)
		{
			string text = CleanPrefabName(((Object)itemDrop).name);
			string itemPrefabName = GetItemPrefabName(itemDrop.m_itemData);
			string text2 = itemDrop.m_itemData.m_shared.m_name ?? "";
			string text3 = ((Localization.instance != null) ? Localization.instance.Localize(text2) : text2);
			string[] array = new string[5]
			{
				text,
				itemPrefabName,
				text2,
				StripLocalizationToken(text2),
				text3
			};
			for (int i = 0; i < array.Length; i++)
			{
				string text4 = NormalizeResourceToken(array[i]);
				if (!string.IsNullOrWhiteSpace(text4))
				{
					yield return text4;
				}
			}
		}

		private static int GetItemPredefinedGroupRank(ItemData? item, string bigGroupId, int bigGroupRank)
		{
			if (item?.m_shared == null)
			{
				return int.MaxValue;
			}
			List<string> predefinedGroupOrderForCraftingGroup = GetPredefinedGroupOrderForCraftingGroup(bigGroupId);
			for (int i = 0; i < predefinedGroupOrderForCraftingGroup.Count; i++)
			{
				if (ItemMatchesPredefinedGroup(item, predefinedGroupOrderForCraftingGroup[i]))
				{
					return i;
				}
			}
			if (bigGroupRank < 0)
			{
				return int.MaxValue;
			}
			return 1000 + bigGroupRank;
		}

		private static List<string> GetPredefinedGroupOrderForCraftingGroup(string bigGroupId)
		{
			List<string> order = new List<string>();
			AddRange(bigGroupId);
			AddRange("global");
			return order;
			void AddRange(string key)
			{
				if (!PredefinedGroupOrders.TryGetValue(NormalizeGroupId(key), out List<string> value))
				{
					return;
				}
				foreach (string item in value)
				{
					if (!order.Contains(item))
					{
						order.Add(item);
					}
				}
			}
		}

		private static int GetCraftingRecipeBigGroupRank(RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetCraftingRecipeBigGroupRank(GetCraftingRecipeBigGroupId(pair));
		}

		private static string GetCraftingRecipeBigGroupId(RecipeDataPair pair)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < CraftingRecipeGroupFilters.Count; i++)
			{
				CraftingRecipeGroupFilter craftingRecipeGroupFilter = CraftingRecipeGroupFilters[i];
				if (craftingRecipeGroupFilter.Id != "favorite" && RecipeMatchesCraftingGroup(pair, craftingRecipeGroupFilter))
				{
					return craftingRecipeGroupFilter.Id;
				}
			}
			return "";
		}

		private static int GetCraftingRecipeBigGroupRank(string bigGroupId)
		{
			return GetItemBigGroupRank(bigGroupId);
		}

		private static int GetItemBigGroupRank(string bigGroupId)
		{
			if (string.IsNullOrWhiteSpace(bigGroupId))
			{
				return int.MaxValue;
			}
			string b = NormalizeGroupId(bigGroupId);
			for (int i = 0; i < CraftingRecipeGroupFilters.Count; i++)
			{
				CraftingRecipeGroupFilter craftingRecipeGroupFilter = CraftingRecipeGroupFilters[i];
				if (craftingRecipeGroupFilter.Id != "favorite" && string.Equals(NormalizeGroupId(craftingRecipeGroupFilter.Id), b, StringComparison.OrdinalIgnoreCase))
				{
					return i;
				}
			}
			return int.MaxValue;
		}

		private static string GetCraftingEquipmentSetKey(ItemData? item)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (item?.m_shared == null || !IsArmorLikeItemType(item.m_shared.m_itemType))
			{
				return "";
			}
			string value = item.m_shared.m_setName ?? "";
			if (string.IsNullOrWhiteSpace(value))
			{
				value = (((Object)(object)item.m_shared.m_setStatusEffect != (Object)null) ? item.m_shared.m_setStatusEffect.m_name : "");
			}
			if (!string.IsNullOrWhiteSpace(value))
			{
				return NormalizeSetKey(StripLocalizationToken(value));
			}
			return DeriveEquipmentSetKeyFromName(GetItemPrefabName(item), item.m_shared.m_name);
		}

		private static string DeriveEquipmentSetKeyFromName(string prefabName, string sharedName)
		{
			string value = ((!string.IsNullOrWhiteSpace(prefabName)) ? prefabName : StripLocalizationToken(sharedName));
			if (string.IsNullOrWhiteSpace(value))
			{
				return "";
			}
			string[] array = new string[13]
			{
				"Helmet", "Armor", "Chest", "Legs", "Leg", "Cape", "Shoulder", "Hood", "Tunic", "Pants",
				"Cuirass", "Greaves", "Robe"
			};
			foreach (string token in array)
			{
				value = RemoveTokenIgnoreCase(value, token);
			}
			return NormalizeSetKey(value);
		}

		private static string RemoveTokenIgnoreCase(string value, string token)
		{
			for (int num = value.IndexOf(token, StringComparison.OrdinalIgnoreCase); num >= 0; num = value.IndexOf(token, StringComparison.OrdinalIgnoreCase))
			{
				value = value.Remove(num, token.Length);
			}
			return value;
		}

		private static string NormalizeSetKey(string value)
		{
			string text = NormalizeResourceToken(value);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "";
		}

		private static int GetCraftingEquipmentSlotOrder(ItemData? item)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if (item?.m_shared == null)
			{
				return 99;
			}
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType <= 11)
			{
				if ((int)itemType == 6)
				{
					return 0;
				}
				if ((int)itemType == 7)
				{
					return 1;
				}
				if ((int)itemType == 11)
				{
					return 2;
				}
			}
			else
			{
				if ((int)itemType == 17)
				{
					return 3;
				}
				if ((int)itemType == 18)
				{
					return 4;
				}
				if ((int)itemType == 24)
				{
					return 5;
				}
			}
			return 99;
		}

		private static bool IsArmorLikeItemType(ItemType itemType)
		{
			//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)itemType <= 11)
			{
				if (itemType - 6 <= 1 || (int)itemType == 11)
				{
					goto IL_001e;
				}
			}
			else if (itemType - 17 <= 1 || (int)itemType == 24)
			{
				goto IL_001e;
			}
			return false;
			IL_001e:
			return true;
		}

		private static string StripLocalizationToken(string value)
		{
			return InventorySlotsConfigCore.StripLocalizationToken(value);
		}

		private static void EnsureSelectedCraftingRecipeVisible(InventoryGui gui)
		{
			if (CraftingRecipes.View.Count != 0 && FindCraftingRecipeViewIndex(gui.GetSelectedRecipeIndex(false)) < 0)
			{
				CraftingController.ClearHoveredRecipe();
				SetCraftingRecipeWithStoredVariant(gui, CraftingRecipes.View[0].OriginalIndex, center: false);
			}
		}

		private static int FindCraftingRecipeViewIndex(int originalIndex)
		{
			if (originalIndex < 0 || !CraftingRecipes.ViewIndexByOriginal.TryGetValue(originalIndex, out var value))
			{
				return -1;
			}
			return value;
		}

		private static bool TryGetCraftingRecipePair(InventoryGui gui, int originalIndex, out RecipeDataPair pair)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			pair = default(RecipeDataPair);
			if (gui.m_availableRecipes == null || originalIndex < 0 || originalIndex >= gui.m_availableRecipes.Count)
			{
				return false;
			}
			pair = gui.m_availableRecipes[originalIndex];
			return (Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null;
		}

		private static bool RecipeMatchesSelectedCraftingGroup(RecipeDataPair pair)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(_selectedCraftingGroupId))
			{
				return true;
			}
			CraftingRecipeGroupFilter craftingRecipeGroupFilter = CraftingRecipeGroupFilters.FirstOrDefault((CraftingRecipeGroupFilter group) => group.Id == _selectedCraftingGroupId);
			if (craftingRecipeGroupFilter != null)
			{
				return RecipeMatchesCraftingGroup(pair, craftingRecipeGroupFilter);
			}
			return false;
		}

		private static bool RecipeMatchesCraftingGroup(RecipeDataPair pair, CraftingRecipeGroupFilter filter)
		{
			//IL_0019: 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_009b: 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)
			if (filter.Id == "favorite")
			{
				return IsFavoriteCraftingRecipe(pair);
			}
			CraftingRecipePairCacheKey craftingRecipePairCacheKey = GetCraftingRecipePairCacheKey(pair);
			if (craftingRecipePairCacheKey.IsValid)
			{
				string key = NormalizeGroupId(filter.Id);
				if (CraftingRecipes.GroupMatchCache.TryGetValue(craftingRecipePairCacheKey, out Dictionary<string, bool> value) && value.TryGetValue(key, out var value2))
				{
					return value2;
				}
				bool flag = RecipeMatchesCraftingGroupUncached(pair, filter);
				if (!CraftingRecipes.GroupMatchCache.TryGetValue(craftingRecipePairCacheKey, out value))
				{
					value = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
					CraftingRecipes.GroupMatchCache[craftingRecipePairCacheKey] = value;
				}
				value[key] = flag;
				return flag;
			}
			return RecipeMatchesCraftingGroupUncached(pair, filter);
		}

		private static bool RecipeMatchesCraftingGroupUncached(RecipeDataPair pair, CraftingRecipeGroupFilter filter)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ItemData craftingRecipeItemData = GetCraftingRecipeItemData(pair);
			if (craftingRecipeItemData != null && filter.Matches(craftingRecipeItemData))
			{
				return IsFirstMatchingCraftingGroup(craftingRecipeItemData, filter);
			}
			return false;
		}

		private static bool IsFirstMatchingCraftingGroup(ItemData item, CraftingRecipeGroupFilter targetFilter)
		{
			foreach (CraftingRecipeGroupFilter craftingRecipeGroupFilter in CraftingRecipeGroupFilters)
			{
				if (!(craftingRecipeGroupFilter.Id == "favorite"))
				{
					if (string.Equals(craftingRecipeGroupFilter.Id, targetFilter.Id, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
					if (craftingRecipeGroupFilter.Matches(item))
					{
						return false;
					}
				}
			}
			return true;
		}

		private static ItemData? GetCraftingRecipeItemData(RecipeDataPair pair)
		{
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				return ((RecipeDataPair)(ref pair)).ItemData;
			}
			if (!((Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null) || !((Object)(object)((RecipeDataPair)(ref pair)).Recipe.m_item != (Object)null))
			{
				return null;
			}
			return ((RecipeDataPair)(ref pair)).Recipe.m_item.m_itemData;
		}

		private static CraftingRecipePairCacheKey GetCraftingRecipePairCacheKey(RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ItemData craftingRecipeItemData = GetCraftingRecipeItemData(pair);
			string itemKey = ((craftingRecipeItemData?.m_shared == null) ? "" : $"{GetItemPrefabName(craftingRecipeItemData)}|{craftingRecipeItemData.m_shared.m_name}|{craftingRecipeItemData.m_variant}|{craftingRecipeItemData.m_quality}");
			return new CraftingRecipePairCacheKey(((RecipeDataPair)(ref pair)).Recipe, itemKey);
		}

		internal static void UpdateCraftingPanelRedesign(InventoryGui gui, CraftingPanelUpdateReason reason = CraftingPanelUpdateReason.FrameTick)
		{
			PrepareCraftingTabAdapterPreflight(gui);
			CraftingTabAdapterState craftingTabAdapterState = GetCraftingTabAdapterState(gui);
			if (reason == CraftingPanelUpdateReason.RecipeListChanged)
			{
				ClearCraftingRecipeCaches();
				InvalidateCraftingRecipeView();
				InvalidateCraftingVanillaHiddenState();
			}
			if (!ShouldShowCraftingPanelRedesign(gui, craftingTabAdapterState))
			{
				UpdateCraftingTabAdapterSuppression(gui, shouldSuppress: false, craftingTabAdapterState);
				if (_craftingRedesignApplied)
				{
					HideCraftingPanelRedesign();
				}
				if (craftingTabAdapterState.IsForeign)
				{
					HideForeignCraftingRedesignResidue(gui);
				}
				return;
			}
			UpdateCraftingTabAdapterSuppression(gui, shouldSuppress: true, craftingTabAdapterState);
			if (reason == CraftingPanelUpdateReason.FrameTick && TryRunCraftingPanelFrameFastPath(gui, craftingTabAdapterState))
			{
				return;
			}
			bool firstApply = !_craftingRedesignApplied;
			bool flag = CraftingController.NeedsModelRefresh(reason, firstApply);
			RectTransform val = EnsureCraftingRecipeGrid(gui, flag);
			if (!((Object)(object)val == (Object)null))
			{
				if (flag)
				{
					RebuildStationInputTokens();
				}
				_craftingRedesignApplied = true;
				SyncPinnedTooltipContextWithCraftingTab(gui);
				EnsureCraftingVanillaRecipeElementsHidden(gui);
				ApplyCraftingTabAdapterVisibility(gui, craftingTabAdapterState);
				UpdateCraftingPanelHeightExtension(gui);
				ResetCraftingCountIfSelectionChanged(gui);
				HandleCraftingCountWheel();
				UpdateCraftingQueueLifecycle(gui);
				TryContinueCraftingQueue(gui);
				EnsureCraftingFavoritesLoaded(Player.m_localPlayer);
				HandleCraftingGroupFavoriteClearShortcut();
				UpdateCraftingSearchInput(gui, val);
				UpdateCraftingSortModeButtons(gui, val);
				if (craftingTabAdapterState.UsesDefaultGroupRail)
				{
					UpdateCraftingGroupRail(gui, val);
				}
				else
				{
					HideCraftingGroupRail();
				}
				bool viewChanged = UpdateCraftingRecipeView(gui);
				EnsureSelectedCraftingRecipeVisible(gui);
				if (!HandleCraftingPinnedTooltipWheel() && !HandleCraftingHoverTooltipWheel() && !HandleCraftingRecipeGridZoomWheel(gui, val) && !HandleCraftingRecipeGridWheel(gui, val))
				{
					SyncCraftingRecipePageToSelected(gui);
				}
				ClampCraftingRecipePage(gui);
				UpdateCraftingGridLayering(gui, val);
				LayoutCraftingRecipeGrid(gui, val);
				UpdateCraftingRecipeScrollbar(gui, val);
				UpdateCraftingTooltipRecipeOverlay(gui);
				LayoutCraftingTabAdapterBottomControls(gui, val, craftingTabAdapterState);
				UpdateCraftingRecipeGridZoomHint(gui, val);
				RepairCraftingPinnedTooltipTextVisibility();
				FinalizeCraftingTabAdapterFrame(gui, craftingTabAdapterState, firstApply, reason, viewChanged);
				StoreCraftingFrameFastPathSignature(gui, craftingTabAdapterState);
			}
		}

		private static void UpdateCraftingPanelHeightExtension(InventoryGui gui)
		{
			if (!((Object)(object)gui.m_crafting == (Object)null))
			{
				float num = 84f;
				if (num <= 0.01f)
				{
					RestoreCraftingPanelExtension(gui);
				}
				else
				{
					ApplyCraftingPanelExtension(gui, num);
				}
			}
		}

		private static void RestoreCraftingPanelHeightExtension(InventoryGui? gui = null)
		{
			RestoreCraftingPanelExtension(gui);
		}

		private static void ApplyCraftingPanelExtension(InventoryGui gui, float extension)
		{
			//IL_0021: 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_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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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)
			RectTransform crafting = gui.m_crafting;
			Vector2 val = ((_craftingPanelRootSnapshot != null && (Object)(object)_craftingPanelRootSnapshot.Rect == (Object)(object)crafting) ? _craftingPanelOriginalSizeDelta : crafting.sizeDelta);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(val.x, val.y + extension);
			string text = $"{((Object)crafting).GetInstanceID()}|{extension:0.###}|{((Transform)crafting).childCount}";
			Vector2 val3;
			if (_craftingPanelRootSnapshot != null && (Object)(object)_craftingPanelRootSnapshot.Rect == (Object)(object)crafting && string.Equals(_craftingPanelExtensionSignature, text, StringComparison.Ordinal))
			{
				val3 = crafting.sizeDelta - val2;
				if (((Vector2)(ref val3)).sqrMagnitude <= 0.0001f)
				{
					return;
				}
			}
			if (_craftingPanelRootSnapshot == null || (Object)(object)_craftingPanelRootSnapshot.Rect != (Object)(object)crafting)
			{
				_craftingPanelRootSnapshot = new RectTransformSnapshot(crafting);
				_craftingPanelOriginalSizeDelta = crafting.sizeDelta;
				val = _craftingPanelOriginalSizeDelta;
				((Vector2)(ref val2))..ctor(val.x, val.y + extension);
				CraftingPanelResizeProtectedSnapshots.Clear();
				CaptureCraftingPanelResizeProtectedSnapshots(gui);
			}
			else
			{
				CaptureCraftingPanelResizeProtectedSnapshots(gui);
			}
			Dictionary<RectTransform, Vector3> dictionary = CaptureCraftingPanelResizeProtectedWorldPositions(gui);
			val3 = crafting.sizeDelta - val2;
			if (((Vector2)(ref val3)).sqrMagnitude > 0.0001f)
			{
				crafting.sizeDelta = val2;
			}
			foreach (KeyValuePair<RectTransform, Vector3> item in dictionary)
			{
				RectTransform key = item.Key;
				if (!((Object)(object)key == (Object)null) && !IsUnityNull((Object?)(object)key))
				{
					((Transform)key).position = item.Value;
				}
			}
			_craftingPanelExtensionSignature = text;
		}

		private static void RestoreCraftingPanelExtension(InventoryGui? gui)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (_craftingPanelRootSnapshot != null && ((Object)(object)gui == (Object)null || (Object)(object)gui.m_crafting == (Object)null || (Object)(object)_craftingPanelRootSnapshot.Rect == (Object)(object)gui.m_crafting))
			{
				_craftingPanelRootSnapshot.Restore();
			}
			foreach (RectTransformSnapshot value in CraftingPanelResizeProtectedSnapshots.Values)
			{
				value.Restore();
			}
			CraftingPanelResizeProtectedSnapshots.Clear();
			_craftingPanelRootSnapshot = null;
			_craftingPanelOriginalSizeDelta = Vector2.zero;
			_craftingPanelExtensionSignature = "";
		}

		private static void CaptureCraftingPanelResizeProtectedSnapshots(InventoryGui gui)
		{
			foreach (RectTransform item in FindCraftingPanelResizeProtectedChildren(gui))
			{
				if (!((Object)(object)item == (Object)null) && !IsUnityNull((Object?)(object)item) && !CraftingPanelResizeProtectedSnapshots.ContainsKey(item))
				{
					CraftingPanelResizeProtectedSnapshots[item] = new RectTransformSnapshot(item);
				}
			}
		}

		private static Dictionary<RectTransform, Vector3> CaptureCraftingPanelResizeProtectedWorldPositions(InventoryGui gui)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<RectTransform, Vector3> dictionary = new Dictionary<RectTransform, Vector3>();
			foreach (RectTransform item in FindCraftingPanelResizeProtectedChildren(gui))
			{
				if (!((Object)(object)item == (Object)null) && !IsUnityNull((Object?)(object)item))
				{
					dictionary[item] = ((Transform)item).position;
				}
			}
			return dictionary;
		}

		private static IEnumerable<RectTransform> FindCraftingPanelResizeProtectedChildren(InventoryGui gui)
		{
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				yield break;
			}
			for (int i = 0; i < ((Transform)gui.m_crafting).childCount; i++)
			{
				Transform child = ((Transform)gui.m_crafting).GetChild(i);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null && ShouldProtectCraftingPanelResizeChild(gui, val))
				{
					yield return val;
				}
			}
		}

		private static bool ShouldProtectCraftingPanelResizeChild(InventoryGui gui, RectTransform rect)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect) || (Object)(object)rect == (Object)(object)gui.m_crafting || IsOwnedCraftingUiTransform((Transform)(object)rect) || IsCraftingPanelStretchBackground(rect))
			{
				return false;
			}
			if (!(rect.anchorMin.y < 0.999f))
			{
				return rect.anchorMax.y < 0.999f;
			}
			return true;
		}

		private static bool IsCraftingPanelStretchBackground(RectTransform rect)
		{
			//IL_003f: 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)
			string text = ((Object)rect).name.ToLowerInvariant();
			bool flag;
			switch (text)
			{
			case "bkg":
			case "darken":
			case "selected_frame":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag)
			{
				return true;
			}
			if (!(rect.anchorMin.y <= 0.001f) || !(rect.anchorMax.y >= 0.999f))
			{
				return false;
			}
			if ((Object)(object)((Component)rect).GetComponent<Image>() == (Object)null)
			{
				if (!text.Contains("background") && !text.Contains("panel"))
				{
					return text.Contains("frame");
				}
				return true;
			}
			if (!text.Contains("bkg") && !text.Contains("background") && !text.Contains("darken") && !text.Contains("panel"))
			{
				return text.Contains("frame");
			}
			return true;
		}

		private static void InvalidateCraftingRecipeView()
		{
			CraftingController.MarkRecipeViewDirty();
			CraftingController.MarkGroupRailDirty();
			CraftingController.MarkRecipeGridLayoutDirty();
		}

		private static void ClearCraftingRecipeCaches()
		{
			CraftingRecipes.SearchTextCache.Clear();
			CraftingRecipes.HoverTooltipContentCache.Clear();
			CraftingRecipes.SortKeyCache.Clear();
			CraftingRecipes.GroupMatchCache.Clear();
			ClearInventorySortCaches();
			ClearItemClassifierCaches();
			ClearCraftingRequirementAvailabilityCache();
			ClearCraftingGroupAvailabilityCache();
			ClearRecycleNReclaimSignatureCaches();
		}

		private static void HideCraftingPanelRedesign()
		{
			InventoryGui instance = InventoryGui.instance;
			CraftingTabAdapterState craftingTabAdapterState = GetCraftingTabAdapterState(instance);
			bool isForeign = craftingTabAdapterState.IsForeign;
			HideOwnedCraftingRedesignUi();
			UpdateMyLittleUICraftingObjectSuppression(instance, shouldSuppress: false, craftingTabAdapterState);
			if ((Object)(object)instance != (Object)null)
			{
				bool flag = isForeign && ShouldPreserveForeignCraftingControls(instance);
				RestoreCraftingPanelHeightExtension(instance);
				RestoreCraftingVanillaState(instance, !isForeign || flag);
				if (flag)
				{
					ForceRestoreForeignCraftingVanillaState(instance);
					RestoreJewelcraftingCraftingSocketUiForVanilla(instance);
				}
				else if (isForeign)
				{
					HideCraftingRedesignBottomControls(instance);
				}
			}
			CraftingController.ClearHoveredRecipe();
			CraftingController.ResetRecipeListChangeSignature();
			CraftingRecipes.View.Clear();
			CraftingRecipes.ViewIndexByOriginal.Clear();
			InvalidateCraftingRecipeView();
			ClearCraftingQueue();
			_craftingRedesignApplied = false;
		}

		private static void HideForeignCraftingRedesignResidue(InventoryGui gui)
		{
			HideOwnedCraftingRedesignUi();
			RestoreCraftingPanelHeightExtension(gui);
			if (ShouldPreserveForeignCraftingControls(gui))
			{
				RestoreCraftingVanillaState(gui, restoreRecipeUi: true);
				ForceRestoreForeignCraftingVanillaState(gui);
				RestoreJewelcraftingCraftingSocketUiForVanilla(gui);
			}
			else
			{
				HideCraftingRedesignBottomControls(gui);
			}
		}

		private static void ForceRestoreForeignCraftingVanillaState(InventoryGui gui)
		{
			if ((Object)(object)gui.m_crafting != (Object)null && !((Component)gui.m_crafting).gameObject.activeSelf)
			{
				((Component)gui.m_crafting).gameObject.SetActive(true);
			}
			SetCraftingVanillaRecipeElementsVisible(gui, visible: true);
			SetCraftingVanillaDetailVisible(gui, visible: true);
			SetCraftingVanillaRecipeScrollbarsVisible(gui, visible: true);
			SetCraftingVanillaPanelBackgroundsVisible(gui, visible: true);
			_craftingVanillaRecipeElementsHidden = false;
			_craftingVanillaDetailHidden = false;
			_craftingVanillaRecipeScrollbarsHidden = false;
			_craftingVanillaPanelBackgroundsHidden = false;
		}

		private static void RestoreCraftingVanillaState(InventoryGui gui, bool restoreRecipeUi)
		{
			if (_craftingVanillaPanelBackgroundsHidden || CraftingVanillaPanelBackgroundStates.Count > 0)
			{
				SetCraftingVanillaPanelBackgroundsVisible(gui, visible: true);
			}
			if (restoreRecipeUi)
			{
				if (_craftingVanillaRecipeElementsHidden)
				{
					SetCraftingVanillaRecipeElementsVisible(gui, visible: true);
					_craftingVanillaRecipeElementsHidden = false;
				}
				if (_craftingVanillaDetailHidden)
				{
					SetCraftingVanillaDetailVisible(gui, visible: true);
					_craftingVanillaDetailHidden = false;
				}
				if (_craftingVanillaRecipeScrollbarsHidden)
				{
					SetCraftingVanillaRecipeScrollbarsVisible(gui, visible: true);
					_craftingVanillaRecipeScrollbarsHidden = false;
				}
			}
		}

		private static void HideOwnedCraftingRedesignUi()
		{
			if ((Object)(object)_craftingRecipeGrid != (Object)null)
			{
				((Component)_craftingRecipeGrid).gameObject.SetActive(false);
			}
			HideCraftingTooltipRecipeOverlay();
			if ((Object)(object)_craftingCountInputRect != (Object)null)
			{
				((Component)_craftingCountInputRect).gameObject.SetActive(false);
			}
			if ((Object)(object)CraftingUi.SearchInputRect != (Object)null)
			{
				((Component)CraftingUi.SearchInputRect).gameObject.SetActive(false);
			}
			if ((Object)(object)_craftingSortModeButtonGroup != (Object)null)
			{
				((Component)_craftingSortModeButtonGroup).gameObject.SetActive(false);
			}
			if ((Object)(object)_craftingRecipeScrollbar != (Object)null)
			{
				((Component)_craftingRecipeScrollbar).gameObject.SetActive(false);
			}
			if ((Object)(object)_craftingGroupRail != (Object)null)
			{
				((Component)_craftingGroupRail).gameObject.SetActive(false);
			}
			HideCraftingPinnedTooltips();
			HideRecycleNReclaimHud();
			HideOwnedCraftingRequirementSlots();
			if ((Object)(object)_craftingControlsBackground != (Object)null)
			{
				((Component)_craftingControlsBackground).gameObject.SetActive(false);
			}
			if ((Object)(object)CraftingUi.RecipeGridZoomHint != (Object)null)
			{
				((Component)CraftingUi.RecipeGridZoomHint).gameObject.SetActive(false);
			}
			HideCraftingSocketWarning();
		}

		internal static void PrepareCraftingQueue(InventoryGui gui)
		{
			if (CraftingQueue.ContinuingQueue)
			{
				return;
			}
			ClearCraftingQueue();
			if (ShouldShowCraftingPanelRedesign(gui) && !((Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)null) && ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null)
			{
				bool num = IsVanillaMultiCraftModifierHeld();
				int num2 = (num ? Mathf.Max(1, gui.m_multiCraftAmount) : GetCraftingCount());
				CaptureCraftingProgressLabelCount(gui, num2);
				if (!num && num2 > 1)
				{
					CraftingQueue.QueueRemaining = num2 - 1;
					CraftingQueue.QueueTotal = num2;
					CraftingQueue.QueueRecipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
					CraftingQueue.QueueVariant = gui.m_selectedVariant;
				}
			}
		}

		internal static void ValidateCraftingQueueStarted(InventoryGui gui)
		{
			if (!CraftingQueue.ContinuingQueue && CraftingQueue.QueueRemaining > 0 && gui.m_craftTimer < 0f)
			{
				ClearCraftingQueue(clearProgressLabel: false);
			}
		}

		private static void TryContinueCraftingQueue(InventoryGui gui)
		{
			if (CraftingQueue.ContinuingQueue || CraftingQueue.QueueRemaining <= 0 || gui.m_craftTimer >= 0f)
			{
				return;
			}
			if (!CanContinueCraftingQueue(gui))
			{
				ClearCraftingQueue();
				return;
			}
			CraftingQueue.QueueRemaining--;
			CraftingQueue.ContinuingQueue = true;
			int multiCraftAmount = gui.m_multiCraftAmount;
			try
			{
				gui.m_multiCraftAmount = 1;
				gui.OnCraftPressed();
				gui.m_multiCrafting = false;
				if (gui.m_craftTimer < 0f)
				{
					ClearCraftingQueue();
				}
			}
			finally
			{
				gui.m_multiCraftAmount = multiCraftAmount;
				CraftingQueue.ContinuingQueue = false;
			}
		}

		internal static void ClearCraftingQueue(bool clearProgressLabel = true)
		{
			CraftingQueue.QueueTotal = 0;
			CraftingQueue.QueueRemaining = 0;
			CraftingQueue.QueueRecipe = null;
			CraftingQueue.QueueVariant = 0;
			if (clearProgressLabel)
			{
				ClearCraftingProgressLabelCount();
			}
		}

		private static void UpdateCraftingQueueLifecycle(InventoryGui gui)
		{
			UpdateCraftingProgressLabelLifecycle(gui);
			if (!((Object)(object)CraftingQueue.QueueRecipe == (Object)null))
			{
				if ((Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe != (Object)(object)CraftingQueue.QueueRecipe || ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null || gui.m_selectedVariant != CraftingQueue.QueueVariant)
				{
					ClearCraftingQueue();
				}
				else if (CraftingQueue.QueueRemaining <= 0 && gui.m_craftTimer < 0f)
				{
					ClearCraftingQueue();
				}
			}
		}

		private static void CaptureCraftingProgressLabelCount(InventoryGui gui, int count)
		{
			if (count <= 1 || (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)null || ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null)
			{
				ClearCraftingProgressLabelCount();
				return;
			}
			CraftingQueue.ProgressLabelCount = Mathf.Clamp(count, 1, 99);
			CraftingQueue.ProgressLabelRecipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			CraftingQueue.ProgressLabelVariant = gui.m_selectedVariant;
		}

		private static void ClearCraftingProgressLabelCount()
		{
			CraftingQueue.ProgressLabelCount = 0;
			CraftingQueue.ProgressLabelRecipe = null;
			CraftingQueue.ProgressLabelVariant = 0;
		}

		private static void UpdateCraftingProgressLabelLifecycle(InventoryGui gui)
		{
			if (!((Object)(object)CraftingQueue.ProgressLabelRecipe == (Object)null))
			{
				bool num = (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)(object)CraftingQueue.ProgressLabelRecipe && ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null && gui.m_selectedVariant == CraftingQueue.ProgressLabelVariant;
				bool flag = (Object)(object)CraftingQueue.QueueRecipe == (Object)(object)CraftingQueue.ProgressLabelRecipe && CraftingQueue.QueueRemaining > 0;
				if (!num || (gui.m_craftTimer < 0f && !flag))
				{
					ClearCraftingProgressLabelCount();
				}
			}
		}

		private static void ResetCraftingCountIfSelectionChanged(InventoryGui gui)
		{
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			int selectedVariant = gui.m_selectedVariant;
			if (!((Object)(object)recipe == (Object)(object)_lastCraftingSelectedRecipe) || selectedVariant != _lastCraftingSelectedVariant)
			{
				_lastCraftingSelectedRecipe = recipe;
				_lastCraftingSelectedVariant = selectedVariant;
				if (!((Object)(object)recipe == (Object)null))
				{
					ClearCraftingQueue();
					SetCraftingCount(1);
				}
			}
		}

		private static bool ShouldShowCraftingPanelRedesign(InventoryGui? gui)
		{
			return ShouldShowCraftingPanelRedesign(gui, GetCraftingTabAdapterState(gui));
		}

		private static bool ShouldShowCraftingPanelRedesign(InventoryGui? gui, CraftingTabAdapterState adapter)
		{
			if (!IsDedicatedServer && (Object)(object)gui != (Object)null && (Object)(object)gui.m_crafting != (Object)null && ((Component)gui.m_crafting).gameObject.activeInHierarchy)
			{
				return adapter.IsRedesign;
			}
			return false;
		}

		private static bool ShouldPreserveForeignCraftingControls(InventoryGui gui)
		{
			return ShouldPreserveJewelcraftingForeignCraftingControls(gui);
		}

		private static bool HasActiveForeignCraftingTab(InventoryGui gui)
		{
			if ((Object)(object)gui.m_tabCraft == (Object)null || (Object)(object)gui.m_tabUpgrade == (Object)null)
			{
				return false;
			}
			Transform parent = ((Component)gui.m_tabCraft).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				return false;
			}
			Button[] componentsInChildren = ((Component)parent).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && !((Object)(object)val == (Object)(object)gui.m_tabCraft) && !((Object)(object)val == (Object)(object)gui.m_tabUpgrade) && ((Component)val).gameObject.activeInHierarchy && !((Selectable)val).interactable && (!IsCraftingPrimaryTabSelected(gui) || !IsJewelcraftingSocketTabButton(val)))
				{
					return true;
				}
			}
			return false;
		}

		private static RectTransform? EnsureCraftingRecipeGrid(InventoryGui gui, bool syncCells = true)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_craftingRecipeGrid != (Object)null && !IsUnityNull((Object?)(object)_craftingRecipeGrid) && (Object)(object)((Transform)_craftingRecipeGrid).parent == (Object)(object)gui.m_crafting)
			{
				ConfigureCraftingRecipeGrid(_craftingRecipeGrid);
				((Transform)_craftingRecipeGrid).SetAsLastSibling();
				if (syncCells || CraftingGrid.RecipeGridCellCapacity != GetCraftingRecipeGridCapacity())
				{
					EnsureCraftingRecipeCells(gui, _craftingRecipeGrid);
				}
				((Component)_craftingRecipeGrid).gameObject.SetActive(true);
				return _craftingRecipeGrid;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingRecipeGrid");
			_craftingRecipeGrid = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingRecipeGrid == (Object)null)
			{
				_craftingRecipeGrid = new GameObject("InventorySlots_CraftingRecipeGrid", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)_craftingRecipeGrid).SetParent((Transform)(object)gui.m_crafting, false);
			}
			CraftingGrid.RecipeGridLayoutSignature = "";
			ConfigureCraftingRecipeGrid(_craftingRecipeGrid);
			EnsureCraftingRecipeCells(gui, _craftingRecipeGrid);
			((Component)_craftingRecipeGrid).gameObject.SetActive(true);
			return _craftingRecipeGrid;
		}

		private static void ConfigureCraftingRecipeGrid(RectTransform grid)
		{
			//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_001c: 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_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_008d: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 craftingRecipeGridFixedOffset = CraftingRecipeGridFixedOffset;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(576f, 648f);
			string text = $"{craftingRecipeGridFixedOffset}|{val}";
			if (!string.Equals(CraftingGrid.RecipeGridLayoutSignature, text, StringComparison.Ordinal))
			{
				grid.anchorMin = new Vector2(0f, 1f);
				grid.anchorMax = new Vector2(0f, 1f);
				grid.pivot = new Vector2(0f, 1f);
				((Transform)grid).localScale = Vector3.one;
				((Transform)grid).localRotation = Quaternion.identity;
				grid.anchoredPosition = craftingRecipeGridFixedOffset;
				grid.sizeDelta = val;
				((Transform)grid).SetAsLastSibling();
				CraftingGrid.RecipeGridLayoutSignature = text;
			}
		}

		private static int GetCraftingRecipeGridDimension()
		{
			return Mathf.Clamp(_craftingRecipeGridSize?.Value ?? 8, 4, 8);
		}

		private static int GetCraftingRecipeGridCapacity()
		{
			int craftingRecipeGridDimension = GetCraftingRecipeGridDimension();
			return craftingRecipeGridDimension * craftingRecipeGridDimension;
		}

		private static float GetCraftingRecipeIconAreaSize()
		{
			return 576f;
		}

		private static float GetCraftingRecipeDynamicCellSpace()
		{
			int craftingRecipeGridDimension = GetCraftingRecipeGridDimension();
			return GetCraftingRecipeIconAreaSize() / (float)craftingRecipeGridDimension;
		}

		private static float GetCraftingRecipeDynamicCellSize(float cellSpace)
		{
			return Mathf.Max(24f, cellSpace - 8f);
		}

		private static void EnsureCraftingRecipeCells(InventoryGui gui, RectTransform grid)
		{
			HideForeignCraftingGridChildren(grid);
			int craftingRecipeGridCapacity = GetCraftingRecipeGridCapacity();
			CraftingGrid.RecipeGridCellCapacity = craftingRecipeGridCapacity;
			for (int num = CraftingRecipes.GridCells.Count - 1; num >= 0; num--)
			{
				CraftingRecipeGridCell craftingRecipeGridCell = CraftingRecipes.GridCells[num];
				if ((Object)(object)craftingRecipeGridCell.Rect == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGridCell.Rect) || (Object)(object)((Transform)craftingRecipeGridCell.Rect).parent != (Object)(object)grid)
				{
					CraftingRecipes.GridCells.RemoveAt(num);
				}
			}
			for (int i = CraftingRecipes.GridCells.Count; i < craftingRecipeGridCapacity; i++)
			{
				CraftingRecipes.GridCells.Add(CreateCraftingRecipeCell(gui, grid, i));
			}
			while (CraftingRecipes.GridCells.Count > craftingRecipeGridCapacity)
			{
				int index = CraftingRecipes.GridCells.Count - 1;
				CraftingRecipeGridCell craftingRecipeGridCell2 = CraftingRecipes.GridCells[index];
				CraftingRecipes.GridCells.RemoveAt(index);
				if ((Object)(object)craftingRecipeGridCell2.Go != (Object)null && !IsUnityNull((Object?)(object)craftingRecipeGridCell2.Go))
				{
					Object.Destroy((Object)(object)craftingRecipeGridCell2.Go);
				}
			}
		}

		private static void HideForeignCraftingGridChildren(RectTransform grid)
		{
			for (int i = 0; i < ((Transform)grid).childCount; i++)
			{
				Transform child = ((Transform)grid).GetChild(i);
				if (!((Object)child).name.StartsWith("InventorySlots_CraftingRecipeCell_", StringComparison.Ordinal))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		private static CraftingRecipeGridCell CreateCraftingRecipeCell(InventoryGui gui, RectTransform grid, int slotIndex)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0055: 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_006a: 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_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)
			GameObject obj = CreateCleanCraftingRecipeCell(grid);
			((Object)obj).name = "InventorySlots_CraftingRecipeCell_" + slotIndex;
			obj.SetActive(false);
			ApplyDefaultFontAssetToChildren(obj);
			RectTransform val = (RectTransform)obj.transform;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			Button component = obj.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((Selectable)component).interactable = false;
			}
			obj.SetActive(true);
			return new CraftingRecipeGridCell(obj, slotIndex);
		}

		private static GameObject CreateCleanCraftingRecipeCell(RectTransform parent)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_0128: 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_016a: 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)
			GameObject val = new GameObject("InventorySlots_CraftingRecipeCell_clean", new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(UIInputHandler),
				typeof(UITooltip)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).color = new Color(0.055f, 0.035f, 0.025f, 0.42f);
			((Graphic)component).raycastTarget = true;
			CreateCleanCraftingOverlay("equiped", val.transform, new Color(0.42f, 0.68f, 0.92f, 0.34f), active: false);
			CreateCleanCraftingOverlay("queued", val.transform, new Color(1f, 0.68f, 0.18f, 0.28f), active: false);
			CreateCleanCraftingOverlay("selected", val.transform, new Color(0.42f, 0.68f, 0.92f, 0f), active: true);
			CreateCleanCraftingOverlay("noteleport", val.transform, new Color(0.9f, 0.2f, 0.2f, 0.45f), active: false);
			CreateCleanCraftingOverlay("durability", val.transform, new Color(0.08f, 0.02f, 0.02f, 0.55f), active: false);
			((Graphic)((Component)CreateTopLeftImageChild("icon", val.transform, Color.white, active: true)).GetComponent<Image>()).raycastTarget = false;
			Image component2 = ((Component)CreateTopLeftImageChild("foodicon", val.transform, Color.white, active: false)).GetComponent<Image>();
			component2.sprite = null;
			component2.preserveAspect = true;
			((Graphic)component2).raycastTarget = false;
			CreateTextRect("amount", val.transform);
			CreateTextRect("quality", val.transform);
			return val;
		}

		private static RectTransform CreateCleanCraftingOverlay(string name, Transform parent, Color color, bool active)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = CreateTopLeftImageChild(name, parent, color, active);
			Image component = ((Component)obj).GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).raycastTarget = false;
			return obj;
		}

		private static void UpdateCraftingGridLayering(InventoryGui gui, RectTransform grid)
		{
			if ((Object)(object)_craftingControlsBackground == (Object)null || IsUnityNull((Object?)(object)_craftingControlsBackground))
			{
				Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingControlsBackground");
				_craftingControlsBackground = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			}
			if ((Object)(object)_craftingControlsBackground != (Object)null && !IsUnityNull((Object?)(object)_craftingControlsBackground))
			{
				((Component)_craftingControlsBackground).gameObject.SetActive(false);
			}
		}

		private static RectTransform? EnsureOwnedCraftingRequirementSlot(InventoryGui gui, int index)
		{
			if ((Object)(object)gui.m_crafting == (Object)null || IsUnityNull((Object?)(object)gui.m_crafting))
			{
				return null;
			}
			while (CraftingRequirements.OwnedSlots.Count <= index)
			{
				CraftingRequirements.OwnedSlots.Add(null);
			}
			RectTransform val = CraftingRequirements.OwnedSlots[index];
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && (Object)(object)((Transform)val).parent == (Object)(object)gui.m_crafting)
			{
				return val;
			}
			string text = string.Format("{0}{1}", "InventorySlots_CraftingRequirementSlot_", index);
			Transform obj = ((Transform)gui.m_crafting).Find(text);
			RectTransform val2 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			RectTransform val3 = (RectTransform)(((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2)) ? ((object)val2) : ((object)CreateOwnedCraftingRequirementSlot(gui, text)));
			((Object)val3).name = text;
			((Transform)val3).SetParent((Transform)(object)gui.m_crafting, false);
			CraftingRequirements.OwnedSlots[index] = val3;
			return val3;
		}

		private static RectTransform CreateOwnedCraftingRequirementSlot(InventoryGui gui, string name)
		{
			GameObject craftingRequirementTemplate = GetCraftingRequirementTemplate(gui);
			GameObject val = (GameObject)(((Object)(object)craftingRequirementTemplate != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementTemplate)) ? ((object)Object.Instantiate<GameObject>(craftingRequirementTemplate, (Transform)(object)gui.m_crafting, false)) : ((object)CreateFallbackCraftingRequirementSlot(name, (Transform)(object)gui.m_crafting)));
			((Object)val).name = name;
			val.SetActive(false);
			return val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
		}

		private static GameObject? GetCraftingRequirementTemplate(InventoryGui gui)
		{
			if (gui.m_recipeRequirementList == null)
			{
				return null;
			}
			GameObject[] recipeRequirementList = gui.m_recipeRequirementList;
			foreach (GameObject val in recipeRequirementList)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
				{
					return val;
				}
			}
			return null;
		}

		private static GameObject CreateFallbackCraftingRequirementSlot(string name, Transform parent)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Behaviour)component).enabled = false;
			((Graphic)component).raycastTarget = false;
			RectTransform component2 = new GameObject("res_icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>();
			((Transform)component2).SetParent(val.transform, false);
			Image component3 = ((Component)component2).GetComponent<Image>();
			RectTransform name2 = CreateTextRect("res_name", val.transform, active: false);
			TMP_Text text;
			RectTransform amount = CreateTextRect("res_amount", val.transform, out text);
			CraftingRequirementUiMarker craftingRequirementUiMarker = val.AddComponent<CraftingRequirementUiMarker>();
			craftingRequirementUiMarker.ChildSignature = val.transform.childCount.ToString();
			craftingRequirementUiMarker.Name = (Transform?)(object)name2;
			craftingRequirementUiMarker.Icon = component2;
			craftingRequirementUiMarker.IconImage = component3;
			craftingRequirementUiMarker.Amount = amount;
			craftingRequirementUiMarker.AmountText = text;
			craftingRequirementUiMarker.BackgroundImages = (Image[])(object)new Image[1] { component };
			return val;
		}

		private static void HideOwnedCraftingRequirementSlots()
		{
			foreach (RectTransform ownedSlot in CraftingRequirements.OwnedSlots)
			{
				if ((Object)(object)ownedSlot != (Object)null && !IsUnityNull((Object?)(object)ownedSlot))
				{
					((Component)ownedSlot).gameObject.SetActive(false);
				}
			}
		}

		private static void HideCraftingVanillaRequirementSlots(InventoryGui gui)
		{
			if (gui.m_recipeRequirementList == null)
			{
				return;
			}
			GameObject[] recipeRequirementList = gui.m_recipeRequirementList;
			foreach (GameObject val in recipeRequirementList)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
				{
					val.SetActive(false);
				}
			}
		}

		private static string FormatCompactRequirementAmount(int available, int required)
		{
			return $"{available}/{required}";
		}

		private static Color GetCompactRequirementAmountColor(bool availableEnough)
		{
			//IL_0003: 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_0031: 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)
			if (availableEnough)
			{
				return Color.white;
			}
			if (TryGetAzuCraftyBoxesRequirementFlashColor(out var color))
			{
				return color;
			}
			if (!(Mathf.Sin(Time.time * 10f) > 0f))
			{
				return Color.white;
			}
			return Color.red;
		}

		private static bool RequirementAmountTextMatches(TMP_Text text, string label, Color color)
		{
			//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)
			if (string.Equals(text.text, label, StringComparison.Ordinal))
			{
				return ColorsApproximatelyEqual(((Graphic)text).color, color);
			}
			return false;
		}

		private static bool ColorsApproximatelyEqual(Color left, Color right)
		{
			//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_0019: 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_0038: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Abs(left.r - right.r) <= 0.001f && Mathf.Abs(left.g - right.g) <= 0.001f && Mathf.Abs(left.b - right.b) <= 0.001f)
			{
				return Mathf.Abs(left.a - right.a) <= 0.001f;
			}
			return false;
		}

		private static CraftingRequirementUiMarker GetCraftingRequirementUiMarker(RectTransform rect)
		{
			CraftingRequirementUiMarker craftingRequirementUiMarker = ((Component)rect).GetComponent<CraftingRequirementUiMarker>() ?? ((Component)rect).gameObject.AddComponent<CraftingRequirementUiMarker>();
			string text = ((Transform)rect).childCount.ToString();
			if (string.Equals(craftingRequirementUiMarker.ChildSignature, text, StringComparison.Ordinal) && (Object)(object)craftingRequirementUiMarker.Name != (Object)null && (Object)(object)craftingRequirementUiMarker.Icon != (Object)null && (Object)(object)craftingRequirementUiMarker.Amount != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Name) && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Icon) && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Amount))
			{
				return craftingRequirementUiMarker;
			}
			craftingRequirementUiMarker.Name = ((Transform)rect).Find("res_name");
			Transform obj = ((Transform)rect).Find("res_icon");
			craftingRequirementUiMarker.Icon = (RectTransform?)(object)((obj is RectTransform) ? obj : null);
			craftingRequirementUiMarker.IconImage = (((Object)(object)craftingRequirementUiMarker.Icon != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Icon)) ? ((Component)craftingRequirementUiMarker.Icon).GetComponent<Image>() : null);
			Transform obj2 = ((Transform)rect).Find("res_amount");
			craftingRequirementUiMarker.Amount = (RectTransform?)(object)((obj2 is RectTransform) ? obj2 : null);
			craftingRequirementUiMarker.AmountText = (((Object)(object)craftingRequirementUiMarker.Amount != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Amount)) ? ((Component)craftingRequirementUiMarker.Amount).GetComponent<TMP_Text>() : null);
			Transform obj3 = ((Transform)rect).Find("InventorySlots_CraftingRequirementHitbox");
			craftingRequirementUiMarker.Hitbox = (RectTransform?)(object)((obj3 is RectTransform) ? obj3 : null);
			craftingRequirementUiMarker.BackgroundImages = FindCraftingRequirementBackgroundImages(rect);
			craftingRequirementUiMarker.CompetingTooltipSignature = "";
			craftingRequirementUiMarker.CompetingTooltips = Array.Empty<UITooltip>();
			craftingRequirementUiMarker.ChildSignature = text;
			craftingRequirementUiMarker.LayoutSignature = "";
			craftingRequirementUiMarker.AmountSignature = "";
			return craftingRequirementUiMarker;
		}

		private static Image[] FindCraftingRequirementBackgroundImages(RectTransform rect)
		{
			return (from image in ((Component)rect).GetComponentsInChildren<Image>(true)
				where IsCraftingRequirementBackgroundImage(rect, image)
				select image).ToArray();
		}

		private static bool IsCraftingRequirementBackgroundImage(RectTransform root, Image image)
		{
			if ((Object)(object)image == (Object)null || IsUnityNull((Object?)(object)image))
			{
				return false;
			}
			Transform transform = ((Component)image).transform;
			string text = ((Object)transform).name.ToLowerInvariant();
			if (text == "res_icon" || text == "res_amount" || string.Equals(((Object)transform).name, "InventorySlots_CraftingRequirementHitbox", StringComparison.Ordinal))
			{
				return false;
			}
			if (!((Object)(object)transform == (Object)(object)root) && !text.Contains("bkg") && !text.Contains("background") && !text.Contains("border"))
			{
				return text.Contains("frame");
			}
			return true;
		}

		private static void HideCraftingRequirementSlotBackground(CraftingRequirementUiMarker marker)
		{
			Image[] backgroundImages = marker.BackgroundImages;
			foreach (Image val in backgroundImages)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					((Behaviour)val).enabled = false;
					((Graphic)val).raycastTarget = false;
				}
			}
		}

		private static RectTransform EnsureCraftingRequirementHitbox(RectTransform rect, CraftingRequirementUiMarker marker)
		{
			//IL_005f: 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_0090: 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)
			RectTransform val = marker.Hitbox;
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
			{
				Transform obj = ((Transform)rect).Find("InventorySlots_CraftingRequirementHitbox");
				val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			}
			RectTransform val2 = (((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val)) ? val : new GameObject("InventorySlots_CraftingRequirementHitbox", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>());
			if ((Object)(object)((Transform)val2).parent != (Object)(object)rect)
			{
				((Transform)val2).SetParent((Transform)(object)rect, false);
			}
			marker.Hitbox = val2;
			SetStretchRectLayout(val2, Vector2.zero, Vector2.zero);
			((Transform)val2).SetAsLastSibling();
			Image component = ((Component)val2).GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)component).raycastTarget = true;
			return val2;
		}

		private static void ConfigureCraftingRequirementTooltip(InventoryGui gui, GameObject target, Requirement requirement, int quality, int craftMultiplier)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null) && !IsUnityNull((Object?)(object)target) && !((Object)(object)requirement.m_resItem == (Object)null))
			{
				bool flag = (Object)(object)gui != (Object)null && IsVeiledRecipeMasked(gui.m_selectedRecipe);
				ConfigureSimpleTooltip(target, (flag && !IsVeiledRecipeRequirementKnown(requirement)) ? GetVeiledRecipeUnknownNameText() : GetRequirementDisplayName(requirement), enabled: true);
			}
		}

		private static void DisableCompetingCraftingRequirementTooltips(RectTransform root, RectTransform allowed, CraftingRequirementUiMarker marker)
		{
			string text = $"{((Transform)root).childCount}|{((Object)allowed).GetInstanceID()}";
			if (!string.Equals(marker.CompetingTooltipSignature, text, StringComparison.Ordinal))
			{
				marker.CompetingTooltips = (from tooltip in ((Component)root).GetComponentsInChildren<UITooltip>(true)
					where (Object)(object)tooltip != (Object)null && !IsUnityNull((Object?)(object)tooltip) && (Object)(object)((Component)tooltip).transform != (Object)(object)allowed
					select tooltip).ToArray();
				marker.CompetingTooltipSignature = text;
			}
			UITooltip[] competingTooltips = marker.CompetingTooltips;
			CraftingTooltipState craftingTooltipState = default(CraftingTooltipState);
			foreach (UITooltip val in competingTooltips)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					val.m_topic = "";
					val.m_text = "";
					((Behaviour)val).enabled = false;
					if (((Component)val).TryGetComponent<CraftingTooltipState>(ref craftingTooltipState))
					{
						craftingTooltipState.Stamp = default(CraftingSimpleTooltipStamp);
					}
				}
			}
		}

		private static int GetAvailableCraftingRequirementAmount(Requirement requirement)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)requirement.m_resItem == (Object)null || requirement.m_resItem.m_itemData?.m_shared == null)
			{
				return 0;
			}
			string name = requirement.m_resItem.m_itemData.m_shared.m_name;
			if (string.IsNullOrWhiteSpace(name))
			{
				return 0;
			}
			string craftingRequirementAvailabilityCacheKey = GetCraftingRequirementAvailabilityCacheKey(localPlayer, requirement, name);
			float unscaledTime = Time.unscaledTime;
			if (CraftingRequirements.AvailabilityCache.TryGetValue(craftingRequirementAvailabilityCacheKey, out var value) && value.ExpiresAt >= unscaledTime)
			{
				return value.Amount;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			int num = ((inventory != null) ? inventory.CountItems(name, -1, true) : 0);
			num += GetAzuCraftyBoxesAvailableCraftingRequirementAmount(requirement, name);
			CraftingRequirements.AvailabilityCache[craftingRequirementAvailabilityCacheKey] = new CraftingRequirementAvailabilityCacheEntry(num, unscaledTime + 0.25f);
			return num;
		}

		private static string GetCraftingRequirementAvailabilityCacheKey(Player player, Requirement requirement, string sharedName)
		{
			string arg = (((Object)(object)requirement.m_resItem != (Object)null) ? GetPrefabNameForAzuCraftyBoxes(((Object)requirement.m_resItem).name) : "");
			long num = (((Object)(object)player != (Object)null) ? player.GetPlayerID() : 0);
			return $"{num}|{arg}|{sharedName}";
		}

		private static void ClearCraftingRequirementAvailabilityCache()
		{
			CraftingRequirements.AvailabilityCache.Clear();
			CraftingRequirements.AvailabilityVersion++;
		}

		private static bool HasNoCraftCost()
		{
			if (!((Object)(object)Player.m_localPlayer != (Object)null) || !Player.m_localPlayer.NoCostCheat())
			{
				if ((Object)(object)ZoneSystem.instance != (Object)null)
				{
					return ZoneSystem.instance.GetGlobalKey((GlobalKeys)20);
				}
				return false;
			}
			return true;
		}

		private static void UpdateCraftingRecipeScrollbar(InventoryGui gui, RectTransform grid)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = EnsureCraftingRecipeScrollbar(gui);
			if ((Object)(object)val == (Object)null || (Object)(object)CraftingScrollbar.RecipeScrollbarComponent == (Object)null)
			{
				return;
			}
			EnsureCraftingVanillaRecipeScrollbarsHidden(gui);
			int craftingRecipePageCount = GetCraftingRecipePageCount(gui);
			bool flag = craftingRecipePageCount > 1;
			CraftingRecipeScrollbarStamp stamp = new CraftingRecipeScrollbarStamp(craftingRecipePageCount, _craftingRecipePage, flag, grid.anchoredPosition.x, grid.anchoredPosition.y);
			if (CraftingController.CanReuseRecipeScrollbar(stamp))
			{
				return;
			}
			((Component)val).gameObject.SetActive(flag);
			if (!flag)
			{
				CraftingController.StoreRecipeScrollbarStamp(stamp);
				return;
			}
			Scrollbar recipeScrollbarComponent = CraftingScrollbar.RecipeScrollbarComponent;
			CraftingRecipeScrollbarMarker craftingRecipeScrollbarMarker = ((Component)val).GetComponent<CraftingRecipeScrollbarMarker>() ?? ((Component)val).gameObject.AddComponent<CraftingRecipeScrollbarMarker>();
			if (!craftingRecipeScrollbarMarker.Initialized)
			{
				((UnityEvent<float>)(object)recipeScrollbarComponent.onValueChanged).AddListener((UnityAction<float>)OnCraftingRecipeScrollbarChanged);
				craftingRecipeScrollbarMarker.Initialized = true;
			}
			SetCraftingTopLeftRect(gui.m_crafting, val, GetCraftingRecipeScrollbarPosition(gui, grid), new Vector2(16f, 570f));
			SetCraftingRecipeScrollbarGraphicsVisible(val, visible: true);
			recipeScrollbarComponent.direction = (Direction)2;
			recipeScrollbarComponent.size = Mathf.Clamp01(1f / (float)craftingRecipePageCount);
			CraftingScrollbar.UpdatingRecipeScrollbar = true;
			recipeScrollbarComponent.value = ((craftingRecipePageCount <= 1) ? 1f : (1f - (float)_craftingRecipePage / (float)(craftingRecipePageCount - 1)));
			CraftingScrollbar.UpdatingRecipeScrollbar = false;
			CraftingController.StoreRecipeScrollbarStamp(stamp);
		}

		private static void EnsureCraftingVanillaRecipeScrollbarsHidden(InventoryGui gui)
		{
			if (!_craftingVanillaRecipeScrollbarsHidden)
			{
				SetCraftingVanillaRecipeScrollbarsVisible(gui, visible: false);
				_craftingVanillaRecipeScrollbarsHidden = true;
			}
		}

		private static Vector2 GetCraftingRecipeScrollbarPosition(InventoryGui gui, RectTransform grid)
		{
			//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_002d: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 craftingRecipeScrollbarFixedOffset = CraftingRecipeScrollbarFixedOffset;
			float num = GetRectWidth(gui.m_crafting);
			if (num <= 1f)
			{
				num = grid.anchoredPosition.x + 576f;
			}
			return new Vector2(num + craftingRecipeScrollbarFixedOffset.x, grid.anchoredPosition.y + craftingRecipeScrollbarFixedOffset.y);
		}

		private static RectTransform? EnsureCraftingRecipeScrollbar(InventoryGui gui)
		{
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_craftingRecipeScrollbar != (Object)null && !IsUnityNull((Object?)(object)_craftingRecipeScrollbar) && (Object)(object)((Transform)_craftingRecipeScrollbar).parent == (Object)(object)gui.m_crafting)
			{
				CraftingScrollbar.RecipeScrollbarComponent = ((Component)_craftingRecipeScrollbar).GetComponent<Scrollbar>();
				return _craftingRecipeScrollbar;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingRecipeScrollbar");
			_craftingRecipeScrollbar = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingRecipeScrollbar == (Object)null)
			{
				_craftingRecipeScrollbar = CreateCraftingRecipeScrollbar(gui);
			}
			((Transform)_craftingRecipeScrollbar).SetParent((Transform)(object)gui.m_crafting, false);
			CraftingScrollbar.RecipeScrollbarComponent = ((Component)_craftingRecipeScrollbar).GetComponent<Scrollbar>();
			return _craftingRecipeScrollbar;
		}

		private static RectTransform CreateCraftingRecipeScrollbar(InventoryGui gui)
		{
			//IL_0092: 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_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: 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_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: 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_02b1: 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)
			RectTransform rect;
			if ((Object)(object)gui.m_recipeListScroll != (Object)null && !IsUnityNull((Object?)(object)gui.m_recipeListScroll))
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)gui.m_recipeListScroll).gameObject, (Transform)(object)gui.m_crafting, false);
				((Object)val).name = "InventorySlots_CraftingRecipeScrollbar";
				rect = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
			}
			else
			{
				rect = new GameObject("InventorySlots_CraftingRecipeScrollbar", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Scrollbar)
				}).GetComponent<RectTransform>();
				((Transform)rect).SetParent((Transform)(object)gui.m_crafting, false);
				Image component = ((Component)rect).GetComponent<Image>();
				component.sprite = GetSolidUiSprite();
				((Graphic)component).color = new Color(0.06f, 0.035f, 0.015f, 0.88f);
				((Graphic)component).raycastTarget = true;
			}
			Scrollbar val2 = ((Component)rect).GetComponent<Scrollbar>() ?? ((Component)rect).gameObject.AddComponent<Scrollbar>();
			((UnityEventBase)val2.onValueChanged).RemoveAllListeners();
			val2.direction = (Direction)2;
			if ((Object)(object)val2.handleRect == (Object)null)
			{
				Transform val3 = ((Transform)rect).Find("Sliding Area/Handle") ?? (from image in ((Component)rect).GetComponentsInChildren<Image>(true)
					select ((Component)image).transform).FirstOrDefault((Func<Transform, bool>)((Transform transform) => (Object)(object)transform != (Object)(object)rect));
				val2.handleRect = (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponent<RectTransform>() : null);
			}
			if ((Object)(object)((Selectable)val2).targetGraphic == (Object)null && (Object)(object)val2.handleRect != (Object)null)
			{
				((Selectable)val2).targetGraphic = ((Component)val2.handleRect).GetComponent<Graphic>();
			}
			if ((Object)(object)val2.handleRect == (Object)null)
			{
				RectTransform component2 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)component2).SetParent((Transform)(object)rect, false);
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.offsetMin = new Vector2(3f, 3f);
				component2.offsetMax = new Vector2(-3f, -3f);
				RectTransform component3 = new GameObject("Handle", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				}).GetComponent<RectTransform>();
				((Transform)component3).SetParent((Transform)(object)component2, false);
				component3.anchorMin = Vector2.zero;
				component3.anchorMax = Vector2.one;
				component3.offsetMin = Vector2.zero;
				component3.offsetMax = Vector2.zero;
				Image component4 = ((Component)component3).GetComponent<Image>();
				component4.sprite = GetSolidUiSprite();
				((Graphic)component4).color = new Color(1f, 0.67f, 0.24f, 0.94f);
				((Graphic)component4).raycastTarget = true;
				val2.handleRect = component3;
				((Selectable)val2).targetGraphic = (Graphic)(object)component4;
			}
			SetCraftingRecipeScrollbarGraphicsVisible(rect, visible: true);
			return rect;
		}

		private static void SetCraftingRecipeScrollbarGraphicsVisible(RectTransform rect, bool visible)
		{
			Graphic[] componentsInChildren = ((Component)rect).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					((Behaviour)val).enabled = visible;
					val.raycastTarget = visible;
				}
			}
			Scrollbar component = ((Component)rect).GetComponent<Scrollbar>();
			if ((Object)(object)component != (Object)null)
			{
				((Selectable)component).interactable = visible;
				if ((Object)(object)((Selectable)component).targetGraphic != (Object)null)
				{
					((Behaviour)((Selectable)component).targetGraphic).enabled = visible;
					((Selectable)component).targetGraphic.raycastTarget = visible;
				}
			}
		}

		private static void SetCraftingVanillaRecipeScrollbarsVisible(InventoryGui gui, bool visible)
		{
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return;
			}
			Scrollbar[] componentsInChildren = ((Component)gui.m_crafting).GetComponentsInChildren<Scrollbar>(true);
			foreach (Scrollbar val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && !((Object)(object)val == (Object)(object)CraftingScrollbar.RecipeScrollbarComponent))
				{
					Transform transform = ((Component)val).transform;
					if (!((Object)transform).name.StartsWith("InventorySlots_", StringComparison.Ordinal) && !IsForeignCraftingUiTransform(gui, transform))
					{
						((Component)val).gameObject.SetActive(visible);
					}
				}
			}
			Graphic[] componentsInChildren2 = ((Component)gui.m_crafting).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2) && ShouldControlVanillaCraftingScrollGraphic(gui, ((Component)val2).transform))
				{
					((Behaviour)val2).enabled = visible;
					if (!visible)
					{
						val2.raycastTarget = false;
					}
				}
			}
		}

		private static bool ShouldControlVanillaCraftingScrollGraphic(InventoryGui gui, Transform transform)
		{
			if ((Object)(object)transform == (Object)null || (Object)(object)gui.m_crafting == (Object)null || !transform.IsChildOf((Transform)(object)gui.m_crafting))
			{
				return false;
			}
			if (IsOwnedCraftingUiTransform(transform) || IsForeignCraftingUiTransform(gui, transform))
			{
				return false;
			}
			if ((Object)(object)gui.m_recipeListScroll != (Object)null && ((Object)(object)transform == (Object)(object)((Component)gui.m_recipeListScroll).transform || transform.IsChildOf(((Component)gui.m_recipeListScroll).transform)))
			{
				return true;
			}
			Transform val = transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)gui.m_crafting)
			{
				if (((Object)val).name.ToLowerInvariant().Contains("scroll"))
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static void OnCraftingRecipeScrollbarChanged(float value)
		{
			if (CraftingScrollbar.UpdatingRecipeScrollbar || (Object)(object)InventoryGui.instance == (Object)null || !ShouldShowCraftingPanelRedesign(InventoryGui.instance))
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			UpdateCraftingRecipeView(instance);
			int craftingRecipePageCount = GetCraftingRecipePageCount(instance);
			if (craftingRecipePageCount <= 1)
			{
				_craftingRecipePage = 0;
				return;
			}
			int num = Mathf.Clamp(Mathf.RoundToInt((1f - value) * (float)(craftingRecipePageCount - 1)), 0, craftingRecipePageCount - 1);
			if (num != _craftingRecipePage)
			{
				_craftingRecipePage = num;
				CraftingController.ClearHoveredRecipe();
				CraftingController.MarkRecipeGridLayoutDirty();
				int num2 = _craftingRecipePage * GetCraftingRecipeGridCapacity();
				if (num2 >= 0 && num2 < CraftingRecipes.View.Count)
				{
					SetCraftingRecipeWithStoredVariant(instance, CraftingRecipes.View[num2].OriginalIndex, center: false);
				}
			}
		}

		private static void PrepareCraftingTabAdapterPreflight(InventoryGui gui)
		{
			EnsureJewelcraftingCraftingPanelVisible(gui);
		}

		private static CraftingTabAdapterState GetCraftingTabAdapterState(InventoryGui? gui)
		{
			if ((Object)(object)gui == (Object)null || IsUnityNull((Object?)(object)gui) || (Object)(object)gui.m_crafting == (Object)null || IsUnityNull((Object?)(object)gui.m_crafting) || !((Component)gui.m_crafting).gameObject.activeInHierarchy)
			{
				return new CraftingTabAdapterState(CraftingTabAdapterKind.None);
			}
			if (IsJewelcraftingCraftingRedesignTab(gui))
			{
				return new CraftingTabAdapterState(CraftingTabAdapterKind.JewelcraftingSocket);
			}
			if (IsRecycleNReclaimReclaimTabActive(gui))
			{
				return new CraftingTabAdapterState(CraftingTabAdapterKind.RecycleNReclaim);
			}
			if (HasActiveForeignCraftingTab(gui) || (!gui.InCraftTab() && !gui.InUpradeTab()))
			{
				return new CraftingTabAdapterState(CraftingTabAdapterKind.Foreign);
			}
			return new CraftingTabAdapterState(CraftingTabAdapterKind.Vanilla);
		}

		private static void UpdateCraftingTabAdapterSuppression(InventoryGui gui, bool shouldSuppress, CraftingTabAdapterState adapter)
		{
			UpdateMyLittleUICraftingObjectSuppression(gui, shouldSuppress, adapter);
		}

		private static void ApplyCraftingTabAdapterVisibility(InventoryGui gui, CraftingTabAdapterState adapter)
		{
			if (adapter.IsJewelcraftingSocket)
			{
				ApplyJewelcraftingCraftingRedesignVisibility(gui);
				return;
			}
			if (adapter.IsRecycleNReclaim)
			{
				ApplyRecycleNReclaimCraftingRedesignVisibility(gui);
				return;
			}
			SetCraftingVanillaDetailVisible(gui, visible: false);
			_craftingVanillaDetailHidden = true;
			SuppressJewelcraftingCraftingSocketUiForRedesign(gui, adapter.IsJewelcraftingSocket);
			EnsureCraftingVanillaPanelBackgroundsHidden(gui);
		}

		private static void SuppressCraftingTabAdapterFrameResidue(InventoryGui gui, CraftingTabAdapterState adapter)
		{
			if (adapter.IsRedesign)
			{
				SetCraftingVanillaDetailVisible(gui, visible: false);
				_craftingVanillaDetailHidden = true;
			}
		}

		private static void LayoutCraftingTabAdapterBottomControls(InventoryGui gui, RectTransform grid, CraftingTabAdapterState adapter)
		{
			if (adapter.UsesRecycleNReclaimBottomControls)
			{
				LayoutRecycleNReclaimBottomControls(gui, grid);
			}
			else
			{
				LayoutCraftingBottomControls(gui, grid);
			}
		}

		private static void FinalizeCraftingTabAdapterFrame(InventoryGui gui, CraftingTabAdapterState adapter, bool firstApply, CraftingPanelUpdateReason reason, bool viewChanged)
		{
			if (ShouldFinalizeJewelcraftingCraftingSocketSuppression(adapter.IsJewelcraftingSocket, firstApply, reason, viewChanged))
			{
				SuppressJewelcraftingCraftingSocketUiForRedesign(gui);
			}
			if (adapter.IsJewelcraftingSocket)
			{
				SuppressJewelcraftingCraftingSocketUiForRedesign(gui, includeSocketTab: true);
			}
		}

		private static bool ShouldIncludeRecipeInCraftingTabView(CraftingTabAdapterState adapter, RecipeDataPair pair)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			return adapter.Kind switch
			{
				CraftingTabAdapterKind.JewelcraftingSocket => ((RecipeDataPair)(ref pair)).ItemData != null, 
				CraftingTabAdapterKind.RecycleNReclaim => ShouldIncludeRecycleNReclaimRecipeInView(pair), 
				CraftingTabAdapterKind.Vanilla => RecipeMatchesSelectedCraftingGroup(pair) && RecipeMatchesCraftingSearch(pair), 
				_ => false, 
			};
		}

		private static int CompareCraftingRecipeViewEntriesForAdapter(CraftingTabAdapterState adapter, CraftingRecipeViewEntry a, CraftingRecipeViewEntry b)
		{
			//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)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (adapter.IsRecycleNReclaim)
			{
				return CompareRecycleNReclaimRecipeViewEntries(a, b);
			}
			int num = CompareVeiledRecipeMaskGrouping(a.IsVeiledRecipePreview, b.IsVeiledRecipePreview);
			if (num != 0)
			{
				return num;
			}
			CraftingRecipeSortMode mode = _craftingRecipeSortMode?.Value ?? CraftingRecipeSortMode.TierThenGroup;
			bool isFavorite = a.IsFavorite;
			bool isFavorite2 = b.IsFavorite;
			RecipeDataPair pair = a.Pair;
			bool canCraft = ((RecipeDataPair)(ref pair)).CanCraft;
			pair = b.Pair;
			return CraftingRecipeViewCore.CompareWithSortKey(isFavorite, isFavorite2, canCraft, ((RecipeDataPair)(ref pair)).CanCraft, a.SortKey, b.SortKey, a.OriginalIndex, b.OriginalIndex, mode);
		}

		private static bool IsCraftingRecipeActionAvailable(InventoryGui? gui, RecipeDataPair pair)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return IsCraftingRecipeActionAvailable(gui, pair, -1);
		}

		private static bool IsCraftingRecipeActionAvailable(InventoryGui? gui, RecipeDataPair pair, int originalIndex)
		{
			//IL_0000: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			if (IsVeiledRecipeMasked(pair))
			{
				return false;
			}
			bool available;
			return GetCraftingTabAdapterState(gui).Kind switch
			{
				CraftingTabAdapterKind.JewelcraftingSocket => CanAttemptJewelcraftingSocket(pair), 
				CraftingTabAdapterKind.RecycleNReclaim => TryGetRecycleNReclaimRecipeActionAvailable(originalIndex, pair, out available) ? available : ((RecipeDataPair)(ref pair)).CanCraft, 
				_ => ((RecipeDataPair)(ref pair)).CanCraft, 
			};
		}

		private static string GetCraftingRecipeDisplayName(RecipeDataPair pair)
		{
			//IL_0029: 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)
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null || (Object)(object)((RecipeDataPair)(ref pair)).Recipe.m_item == (Object)null)
			{
				return "";
			}
			if (IsVeiledRecipeMasked(pair))
			{
				return GetVeiledRecipeUnknownNameText();
			}
			if (GetCraftingTabAdapterState(InventoryGui.instance).IsRecycleNReclaim && ((RecipeDataPair)(ref pair)).ItemData != null)
			{
				return GetRecycleNReclaimRecipeDisplayName(pair);
			}
			string text = Localization.instance.Localize(((RecipeDataPair)(ref pair)).Recipe.m_item.m_itemData.m_shared.m_name);
			if (((RecipeDataPair)(ref pair)).Recipe.m_amount > 1)
			{
				text += $" x{((RecipeDataPair)(ref pair)).Recipe.m_amount}";
			}
			return text;
		}

		private static string GetCraftingRecipeTooltip(RecipeDataPair pair)
		{
			//IL_0029: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null || (Object)(object)((RecipeDataPair)(ref pair)).Recipe.m_item == (Object)null)
			{
				return "";
			}
			if (IsVeiledRecipeMasked(pair))
			{
				return GetVeiledRecipeUnknownDescriptionText();
			}
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				CraftingTabAdapterState craftingTabAdapterState = GetCraftingTabAdapterState(InventoryGui.instance);
				if (craftingTabAdapterState.IsRecycleNReclaim)
				{
					return GetRecycleNReclaimRecipeTooltip(pair);
				}
				if (craftingTabAdapterState.IsJewelcraftingSocket)
				{
					return GetSocketRecipeItemTooltip(pair);
				}
				return GetUpgradeRecipeComparisonTooltip(pair);
			}
			int quality = 1;
			int amount = ((RecipeDataPair)(ref pair)).Recipe.m_amount;
			string localizedStaticItemTooltip = GetLocalizedStaticItemTooltip(((RecipeDataPair)(ref pair)).Recipe.m_item.m_itemData, quality, crafting: true, amount);
			return AppendItemRequiresSkillLevelCraftingTooltip(pair, localizedStaticItemTooltip);
		}

		private static void UpdateCraftingTooltipRecipeOverlay(InventoryGui gui)
		{
			//IL_0095: 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_00b2: 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_0160: 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_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			SyncCraftingRecipeHoverWithMouseIfRequested();
			if (!IsCraftingHoverTooltipEnabled() || CraftingController.HoveredRecipeIndex < 0 || !IsCraftingTooltipRecipeOverlayTargetValid() || !TryGetCraftingRecipePair(gui, CraftingController.HoveredRecipeIndex, out var pair))
			{
				HideCraftingTooltipRecipeOverlay();
				return;
			}
			GameObject val = EnsureCraftingHoverTooltip(gui);
			RectTransform val2 = (RectTransform)(((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val)) ? /*isinst with value type is only supported in some contexts*/: null);
			RectTransform hoverTooltipPanel = CraftingUi.HoverTooltipPanel;
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)hoverTooltipPanel == (Object)null || IsUnityNull((Object?)(object)hoverTooltipPanel))
			{
				HideCraftingTooltipRecipeOverlay();
				return;
			}
			bool flag = GetCraftingHoverTooltipMode() == CraftingHoverTooltipMode.Full;
			CraftingHoverTooltipContent craftingHoverTooltipContent = GetCraftingHoverTooltipContent(pair, flag);
			bool flag2 = IsVeiledRecipeMasked(pair);
			ItemData? item = ((flag && !flag2) ? GetCraftingJewelcraftingTooltipItem(pair) : null);
			string craftingHoverGemIconSignature = GetCraftingHoverGemIconSignature(item);
			List<JewelcraftingGemIconData> craftingHoverGemIcons = GetCraftingHoverGemIcons(item, craftingHoverGemIconSignature);
			bool flag3 = flag && craftingHoverGemIcons.Count > 0;
			val.SetActive(true);
			ApplyCraftingHoverTooltipBackground(val.GetComponent<Image>());
			UpdateCraftingHoverTooltipText(craftingHoverTooltipContent.Topic, craftingHoverTooltipContent.Body);
			float num = 234f;
			float num2 = Mathf.Max(410f, num + 16f);
			float effectiveSlotSize = 42f;
			float effectiveGap = 6f;
			float effectiveGemIconSize = 24f;
			float effectiveGemGap = 5f;
			ApplyCraftingTooltipOverlayWidth(num2, num, 8f, 30f, 4f, ref effectiveSlotSize, ref effectiveGap, ref effectiveGemIconSize, ref effectiveGemGap);
			Rect rect = hoverTooltipPanel.rect;
			if (Mathf.Abs(((Rect)(ref rect)).width - num2) > 0.5f)
			{
				hoverTooltipPanel.SetSizeWithCurrentAnchors((Axis)0, num2);
			}
			float overlayHeight = (flag ? (effectiveSlotSize + 16f + (flag3 ? (5f + effectiveGemIconSize) : 0f)) : 0f);
			RectTransform val3 = EnsureCraftingTooltipRecipeOverlay(val2, hoverTooltipPanel);
			LayoutCraftingHoverTooltipPanel(hoverTooltipPanel, val3, num2, overlayHeight, 8f, flag && !string.IsNullOrWhiteSpace(craftingHoverTooltipContent.Body), flag);
			DisableCraftingTooltipRecipeOverlayBackground(((Component)val3).GetComponent<Image>());
			((Transform)hoverTooltipPanel).position = ZInput.mousePosition;
			Utils.ClampUIToScreen(hoverTooltipPanel);
			val.transform.SetAsLastSibling();
			if (!flag)
			{
				((Component)val3).gameObject.SetActive(false);
				HideCraftingGemIconRow(ref CraftingUi.TooltipGemIconRow);
				CraftingUi.HoverTooltipVisualSignature = "";
				return;
			}
			((Transform)val3).SetAsLastSibling();
			((Component)val3).gameObject.SetActive(true);
			string craftingHoverTooltipVisualSignature = GetCraftingHoverTooltipVisualSignature(pair, craftingHoverGemIconSignature, effectiveSlotSize, effectiveGap, effectiveGemIconSize, effectiveGemGap, flag3);
			if (!string.Equals(CraftingUi.HoverTooltipVisualSignature, craftingHoverTooltipVisualSignature, StringComparison.Ordinal) || (Object)(object)((Transform)val3).Find("RecipeRow") == (Object)null || (flag3 && (Object)(object)((Transform)val3).Find("InventorySlots_CraftingGemIconRow") == (Object)null))
			{
				ConfigureCraftingTooltipRecipeRow(val3, pair, Vector2.zero, effectiveSlotSize, effectiveGap, enableSlotTooltips: false);
				if (flag3)
				{
					UpdateCraftingGemIconRow(val3, craftingHoverGemIcons, ref CraftingUi.TooltipGemIconRow, new Vector2(0f, effectiveSlotSize + effectiveGemGap), effectiveGemIconSize, effectiveGemGap, enableIconTooltips: false);
				}
				else
				{
					HideCraftingGemIconRow(ref CraftingUi.TooltipGemIconRow);
				}
				CraftingUi.HoverTooltipVisualSignature = craftingHoverTooltipVisualSignature;
			}
		}

		private static CraftingHoverTooltipMode GetCraftingHoverTooltipMode()
		{
			if (_showCraftingHoverTooltip == null)
			{
				return CraftingHoverTooltipMode.Full;
			}
			return _showCraftingHoverTooltip.Value;
		}

		private static bool IsCraftingHoverTooltipEnabled()
		{
			return GetCraftingHoverTooltipMode() != CraftingHoverTooltipMode.Off;
		}

		private static void OnCraftingHoverTooltipConfigChanged()
		{
			if (!IsCraftingHoverTooltipEnabled())
			{
				HideCraftingTooltipRecipeOverlay();
			}
			else
			{
				RefreshCraftingHoverTooltipBackground();
			}
		}

		private static bool IsCraftingTooltipRecipeOverlayTargetValid()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			RectTransform craftingRecipeGrid = _craftingRecipeGrid;
			if ((Object)(object)craftingRecipeGrid == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGrid) || !((Component)craftingRecipeGrid).gameObject.activeInHierarchy)
			{
				return false;
			}
			int num = FindCraftingRecipeViewIndex(CraftingController.HoveredRecipeIndex);
			if (num < 0)
			{
				return false;
			}
			int craftingRecipeGridCapacity = GetCraftingRecipeGridCapacity();
			int num2 = _craftingRecipePage * craftingRecipeGridCapacity;
			int num3 = num - num2;
			if (num3 < 0 || num3 >= craftingRecipeGridCapacity || num3 >= CraftingRecipes.GridCells.Count)
			{
				return false;
			}
			CraftingRecipeGridCell craftingRecipeGridCell = CraftingRecipes.GridCells[num3];
			if ((Object)(object)craftingRecipeGridCell.Go == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGridCell.Go) || !craftingRecipeGridCell.Go.activeInHierarchy)
			{
				return false;
			}
			return RectContainsScreenPoint(craftingRecipeGridCell.Rect, GetUiMousePosition());
		}

		private static CraftingHoverTooltipContent GetCraftingHoverTooltipContent(RecipeDataPair pair, bool includeBody)
		{
			//IL_0014: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!includeBody)
			{
				return new CraftingHoverTooltipContent(GetCraftingRecipeDisplayName(pair), "");
			}
			string craftingHoverTooltipContentKey = GetCraftingHoverTooltipContentKey(pair);
			if (!string.IsNullOrEmpty(craftingHoverTooltipContentKey) && CraftingRecipes.HoverTooltipContentCache.TryGetValue(craftingHoverTooltipContentKey, out var value))
			{
				return value;
			}
			CraftingHoverTooltipContent craftingHoverTooltipContent = new CraftingHoverTooltipContent(GetCraftingRecipeDisplayName(pair), GetCraftingRecipeTooltip(pair));
			if (!string.IsNullOrEmpty(craftingHoverTooltipContentKey))
			{
				CraftingRecipes.HoverTooltipContentCache[craftingHoverTooltipContentKey] = craftingHoverTooltipContent;
			}
			return craftingHoverTooltipContent;
		}

		private static string GetCraftingHoverTooltipContentKey(RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			CraftingRecipePairCacheKey craftingRecipePairCacheKey = GetCraftingRecipePairCacheKey(pair);
			Recipe recipe = ((RecipeDataPair)(ref pair)).Recipe;
			ItemData itemData = ((RecipeDataPair)(ref pair)).ItemData;
			int worldLevel = Game.m_worldLevel;
			int num = ((!((Object)(object)recipe != (Object)null)) ? 1 : recipe.m_amount);
			CraftingTabAdapterKind kind = GetCraftingTabAdapterState(InventoryGui.instance).Kind;
			string itemRequiresSkillLevelCraftingTooltipSignature = GetItemRequiresSkillLevelCraftingTooltipSignature(pair);
			string veiledRecipeDisplaySignature = GetVeiledRecipeDisplaySignature(pair);
			if (itemData == null)
			{
				return $"{craftingRecipePairCacheKey.RecipeId}|{craftingRecipePairCacheKey.ItemKey}|adapter:{kind}|craft|{num}|{worldLevel}|irsl:{itemRequiresSkillLevelCraftingTooltipSignature}|{veiledRecipeDisplaySignature}";
			}
			string text = ((kind == CraftingTabAdapterKind.JewelcraftingSocket) ? "socket" : "upgrade");
			return $"{craftingRecipePairCacheKey.RecipeId}|{craftingRecipePairCacheKey.ItemKey}|adapter:{kind}|{text}|{num}|{worldLevel}|{GetCraftingTooltipItemSignature(itemData)}|irsl:{itemRequiresSkillLevelCraftingTooltipSignature}|{veiledRecipeDisplaySignature}";
		}

		private static string GetCraftingTooltipItemSignature(ItemData item)
		{
			int num = 17;
			if (item.m_customData != null)
			{
				foreach (KeyValuePair<string, string> customDatum in item.m_customData)
				{
					num = num * 31 + StringComparer.Ordinal.GetHashCode(customDatum.Key);
					num = num * 31 + StringComparer.Ordinal.GetHashCode(customDatum.Value ?? "");
				}
			}
			int num2 = ((item.m_shared != null) ? ((object)item.m_shared).GetHashCode() : 0);
			return $"{num2}|{item.m_quality}|{item.m_variant}|{item.m_stack}|{item.m_durability:0.###}|{num}";
		}

		private static GameObject? EnsureCraftingHoverTooltip(InventoryGui gui)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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)
			//IL_012c: 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)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CraftingUi.HoverTooltip != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltip) && (Object)(object)CraftingUi.HoverTooltipPanel != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipPanel))
			{
				return CraftingUi.HoverTooltip;
			}
			Canvas componentInParent = ((Component)gui).GetComponentInParent<Canvas>();
			Transform val = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).transform : ((Component)gui).transform);
			CraftingUi.HoverTooltip = new GameObject("InventorySlots_CraftingHoverTooltipRoot", new Type[1] { typeof(RectTransform) });
			CraftingUi.HoverTooltip.transform.SetParent(val, false);
			((Object)CraftingUi.HoverTooltip).name = "InventorySlots_CraftingHoverTooltip";
			CraftingUi.HoverTooltip.SetActive(false);
			RectTransform component = CraftingUi.HoverTooltip.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			((Transform)component).localScale = Vector3.one;
			((Transform)component).localRotation = Quaternion.identity;
			ApplyCraftingHoverTooltipBackground(CraftingUi.HoverTooltip.AddComponent<Image>());
			CreateTextRect("Topic", (Transform)(object)component, out TMP_Text text);
			ApplyTooltipSourceFont(text, "Topic");
			text.alignment = (TextAlignmentOptions)514;
			text.fontSize = 22f;
			text.fontStyle = (FontStyles)1;
			((Graphic)text).color = new Color(1f, 0.82f, 0.42f, 1f);
			text.textWrappingMode = (TextWrappingModes)1;
			text.overflowMode = (TextOverflowModes)0;
			((Graphic)text).raycastTarget = false;
			CreateTextRect("Text", (Transform)(object)component, out TMP_Text text2);
			ApplyTooltipSourceFont(text2, "Text");
			text2.alignment = (TextAlignmentOptions)257;
			text2.fontSize = 18f;
			((Graphic)text2).color = Color.white;
			text2.textWrappingMode = (TextWrappingModes)1;
			text2.overflowMode = (TextOverflowModes)0;
			((Graphic)text2).raycastTarget = false;
			EnsureCraftingHoverTooltipTextScrollContent(component, text2);
			CraftingUi.HoverTooltipPanel = component;
			CraftingUi.HoverTooltipTopic = text;
			CraftingUi.HoverTooltipText = text2;
			CraftingUi.HoverTooltipSignature = "";
			CraftingUi.HoverTooltipLayoutSignature = "";
			CraftingUi.HoverTooltipVisualSignature = "";
			return CraftingUi.HoverTooltip;
		}

		private static bool UpdateCraftingHoverTooltipText(string topic, string body)
		{
			string text = topic + "\n---\n" + body;
			if (string.Equals(CraftingUi.HoverTooltipSignature, text, StringComparison.Ordinal))
			{
				return false;
			}
			ApplyTooltipSourceFont(CraftingUi.HoverTooltipTopic, "Topic");
			ApplyTooltipSourceFont(CraftingUi.HoverTooltipText, "Text");
			if ((Object)(object)CraftingUi.HoverTooltipTopic != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipTopic))
			{
				CraftingUi.HoverTooltipTopic.text = topic;
				CraftingUi.HoverTooltipTopic.ForceMeshUpdate(true, true);
			}
			if ((Object)(object)CraftingUi.HoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipText))
			{
				CraftingUi.HoverTooltipText.text = body;
				CraftingUi.HoverTooltipScrollOffset = 0f;
				CraftingUi.HoverTooltipText.ForceMeshUpdate(true, true);
			}
			CraftingUi.HoverTooltipSignature = text;
			CraftingUi.HoverTooltipLayoutSignature = "";
			return true;
		}

		private static void LayoutCraftingHoverTooltipPanel(RectTransform panel, RectTransform overlay, float width, float overlayHeight, float padding, bool showBody, bool showOverlay)
		{
			//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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: 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_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			string craftingHoverTooltipLayoutSignature = GetCraftingHoverTooltipLayoutSignature(width, overlayHeight, padding, showBody, showOverlay);
			if (string.Equals(CraftingUi.HoverTooltipLayoutSignature, craftingHoverTooltipLayoutSignature, StringComparison.Ordinal))
			{
				ApplyCraftingHoverTooltipScrollPosition();
				return;
			}
			float num = (showBody ? 6f : 0f);
			float num2 = (showOverlay ? 8f : 0f);
			float num3 = Mathf.Max(40f, width - padding * 2f);
			float num4 = 0f;
			float num5 = 0f;
			float num6 = 0f;
			if ((Object)(object)CraftingUi.HoverTooltipTopic != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipTopic))
			{
				TMP_Text hoverTooltipTopic = CraftingUi.HoverTooltipTopic;
				((Component)hoverTooltipTopic).gameObject.SetActive(true);
				hoverTooltipTopic.rectTransform.SetSizeWithCurrentAnchors((Axis)0, num3);
				hoverTooltipTopic.ForceMeshUpdate(true, false);
				num4 = Mathf.Max(28f, hoverTooltipTopic.preferredHeight);
			}
			if ((Object)(object)CraftingUi.HoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipText))
			{
				TMP_Text hoverTooltipText = CraftingUi.HoverTooltipText;
				EnsureCraftingHoverTooltipTextScrollContent(panel, hoverTooltipText);
				((Component)hoverTooltipText).gameObject.SetActive(showBody);
				hoverTooltipText.rectTransform.SetSizeWithCurrentAnchors((Axis)0, num3);
				if (showBody)
				{
					hoverTooltipText.ForceMeshUpdate(true, false);
					num6 = GetCraftingHoverTooltipPreferredTextHeight(hoverTooltipText, num3);
				}
			}
			float num7 = padding + num4 + num;
			float num8 = num7 + num2 + (showOverlay ? overlayHeight : 0f) + padding;
			if (showBody)
			{
				float num9 = Mathf.Max(80f, GetCraftingHoverTooltipMaxPanelHeight() - num8);
				num5 = ((num6 > 0f) ? Mathf.Min(num6, num9) : 0f);
			}
			float num10 = num7 + num5 + num2 + overlayHeight + padding;
			panel.anchorMin = new Vector2(0f, 1f);
			panel.anchorMax = new Vector2(0f, 1f);
			panel.pivot = new Vector2(0f, 1f);
			panel.sizeDelta = new Vector2(width, num10);
			((Transform)panel).localScale = Vector3.one;
			((Transform)panel).localRotation = Quaternion.identity;
			if ((Object)(object)CraftingUi.HoverTooltipTopic != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipTopic))
			{
				LayoutCraftingHoverTextRect(CraftingUi.HoverTooltipTopic.rectTransform, padding, padding, num4);
			}
			if ((Object)(object)CraftingUi.HoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipText))
			{
				if (showBody)
				{
					LayoutCraftingHoverTooltipTextScroll(panel, num3, padding, num7, num5, num6);
				}
				else
				{
					HideCraftingHoverTooltipBodyScroll();
				}
			}
			overlay.anchorMin = new Vector2(0f, 0f);
			overlay.anchorMax = new Vector2(1f, 0f);
			overlay.pivot = new Vector2(0.5f, 0f);
			overlay.anchoredPosition = new Vector2(0f, padding);
			overlay.sizeDelta = new Vector2((0f - padding) * 2f, overlayHeight);
			((Transform)overlay).localScale = Vector3.one;
			((Transform)overlay).localRotation = Quaternion.identity;
			CraftingUi.HoverTooltipLayoutSignature = craftingHoverTooltipLayoutSignature;
		}

		private static string GetCraftingHoverTooltipLayoutSignature(float width, float overlayHeight, float padding, bool showBody, bool showOverlay)
		{
			return string.Join("|", CraftingUi.HoverTooltipSignature, Screen.width, Screen.height, GetCraftingHoverTooltipMaxPanelHeight().ToString("0.###"), width.ToString("0.###"), overlayHeight.ToString("0.###"), padding.ToString("0.###"), showBody, showOverlay);
		}

		private static void LayoutCraftingHoverTextRect(RectTransform rect, float horizontalPadding, float top, float height)
		{
			//IL_000b: 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_0035: 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_005b: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = new Vector2(1f, 1f);
			rect.pivot = new Vector2(0.5f, 1f);
			rect.anchoredPosition = new Vector2(0f, 0f - top);
			rect.sizeDelta = new Vector2((0f - horizontalPadding) * 2f, height);
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		private static RectTransform EnsureCraftingHoverTooltipTextScrollContent(RectTransform panel, TMP_Text text)
		{
			return ScrollableTooltipBody.Ensure(panel, text, CraftingUi.HoverTooltipTextScroll, GetSolidUiSprite(), 96f, scrollRectEnabled: false, inertia: false, handleRaycastTarget: false, scrollbarRaycastTarget: false);
		}

		private static void LayoutCraftingHoverTooltipTextScroll(RectTransform panel, float textWidth, float padding, float top, float viewportHeight, float contentHeight)
		{
			if (!((Object)(object)CraftingUi.HoverTooltipText == (Object)null) && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipText))
			{
				EnsureCraftingHoverTooltipTextScrollContent(panel, CraftingUi.HoverTooltipText);
				ScrollableTooltipBodyLayoutResult scrollableTooltipBodyLayoutResult = ScrollableTooltipBody.LayoutPixelScroll(CraftingUi.HoverTooltipTextScroll, CraftingUi.HoverTooltipText, textWidth, padding, top, viewportHeight, contentHeight, CraftingUi.HoverTooltipScrollOffset, 2f, 3f, enableScrollRectWhenNeeded: false);
				CraftingUi.HoverTooltipScrollOffset = scrollableTooltipBodyLayoutResult.ScrollOffset;
				CraftingUi.HoverTooltipMaxScroll = scrollableTooltipBodyLayoutResult.MaxScroll;
			}
		}

		private static void ApplyCraftingHoverTooltipScrollPosition()
		{
			ScrollableTooltipBody.ApplyPixelScrollPosition(CraftingUi.HoverTooltipTextScroll, CraftingUi.HoverTooltipScrollOffset, CraftingUi.HoverTooltipMaxScroll);
		}

		private static void HideCraftingHoverTooltipBodyScroll()
		{
			CraftingUi.HoverTooltipScrollOffset = 0f;
			CraftingUi.HoverTooltipMaxScroll = 0f;
			if ((Object)(object)CraftingUi.HoverTooltipTextScroll.Scrollbar != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipTextScroll.Scrollbar))
			{
				((Component)CraftingUi.HoverTooltipTextScroll.Scrollbar).gameObject.SetActive(false);
			}
			if ((Object)(object)CraftingUi.HoverTooltipTextScroll.ScrollView != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipTextScroll.ScrollView))
			{
				((Component)CraftingUi.HoverTooltipTextScroll.ScrollView).gameObject.SetActive(false);
			}
		}

		private static bool HandleCraftingHoverTooltipWheel()
		{
			if ((Object)(object)CraftingUi.HoverTooltip == (Object)null || IsUnityNull((Object?)(object)CraftingUi.HoverTooltip) || !CraftingUi.HoverTooltip.activeInHierarchy || (Object)(object)CraftingUi.HoverTooltipPanel == (Object)null || IsUnityNull((Object?)(object)CraftingUi.HoverTooltipPanel) || CraftingUi.HoverTooltipMaxScroll <= 1f || IsCraftingRecipeGridZoomModifierHeld() || !IsUiScrollTargetActive(CraftingUi.HoverTooltipPanel))
			{
				return false;
			}
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Continuous);
			if (Mathf.Abs(uiScrollDelta) < 0.01f)
			{
				return false;
			}
			CraftingUi.HoverTooltipScrollOffset = Mathf.Clamp(CraftingUi.HoverTooltipScrollOffset - uiScrollDelta * 96f, 0f, CraftingUi.HoverTooltipMaxScroll);
			ApplyCraftingHoverTooltipScrollPosition();
			return true;
		}

		private static float GetCraftingHoverTooltipPreferredTextHeight(TMP_Text text, float textWidth)
		{
			//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_001c: 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_0036: 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)
			Vector2 preferredValues = text.GetPreferredValues(text.text ?? "", textWidth, 0f);
			if (float.IsNaN(preferredValues.y) || float.IsInfinity(preferredValues.y) || preferredValues.y < 1f)
			{
				return Mathf.Max(1f, text.preferredHeight);
			}
			return Mathf.Max(1f, preferredValues.y);
		}

		private static float GetCraftingHoverTooltipMaxPanelHeight()
		{
			return Mathf.Clamp(((Screen.height > 0) ? ((float)Screen.height) : 720f) * 0.62f, 260f, 720f);
		}

		private static string GetCraftingHoverGemIconSignature(ItemData? item)
		{
			if (item?.m_shared != null)
			{
				return string.Join("|", _uiLocalizationVersion, GetEquipmentSlotTooltipSignature(item));
			}
			return "";
		}

		private static List<JewelcraftingGemIconData> GetCraftingHoverGemIcons(ItemData? item, string signature)
		{
			if (item?.m_shared == null || string.IsNullOrEmpty(signature))
			{
				if (CraftingRecipes.HoverGemIconCache.Count > 0)
				{
					CraftingRecipes.HoverGemIconCache.Clear();
				}
				CraftingUi.HoverGemIconSignature = "";
				return CraftingRecipes.HoverGemIconCache;
			}
			if (string.Equals(CraftingUi.HoverGemIconSignature, signature, StringComparison.Ordinal))
			{
				return CraftingRecipes.HoverGemIconCache;
			}
			CraftingRecipes.HoverGemIconCache.Clear();
			CraftingRecipes.HoverGemIconCache.AddRange(GetJewelcraftingGemIconData(item));
			CraftingUi.HoverGemIconSignature = signature;
			return CraftingRecipes.HoverGemIconCache;
		}

		private static string GetCraftingHoverTooltipVisualSignature(RecipeDataPair pair, string gemSignature, float slotSize, float gap, float gemIconSize, float gemGap, bool hasGemRow)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return string.Join("|", GetCraftingTooltipRecipeRowSignature(pair), gemSignature, slotSize.ToString("0.###"), gap.ToString("0.###"), gemIconSize.ToString("0.###"), gemGap.ToString("0.###"), hasGemRow);
		}

		private static string GetCraftingTooltipRecipeRowSignature(RecipeDataPair pair)
		{
			//IL_0023: 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)
			Recipe recipe = ((RecipeDataPair)(ref pair)).Recipe;
			int num = ((((RecipeDataPair)(ref pair)).ItemData == null) ? 1 : (((RecipeDataPair)(ref pair)).ItemData.m_quality + 1));
			bool flag = IsVeiledRecipeMasked(pair);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(GetCraftingHoverTooltipContentKey(pair));
			int num2 = 0;
			if (recipe?.m_resources != null)
			{
				for (int i = 0; i < recipe.m_resources.Length; i++)
				{
					if (num2 >= 4)
					{
						break;
					}
					Requirement val = recipe.m_resources[i];
					if (val != null && !((Object)(object)val.m_resItem == (Object)null))
					{
						int amount = val.GetAmount(num);
						if (amount > 0)
						{
							int availableCraftingRequirementAmount = GetAvailableCraftingRequirementAmount(val);
							bool flag2 = !flag || IsVeiledRecipeRequirementKnown(val);
							stringBuilder.Append('|').Append(flag2 ? ((Object)val.m_resItem).name : "?").Append(':')
								.Append(flag2 ? availableCraftingRequirementAmount.ToString() : "?")
								.Append('/')
								.Append(flag2 ? amount.ToString() : "?");
							num2++;
						}
					}
				}
			}
			CraftingStation val2 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStation(num) : null);
			int num3 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStationLevel(num) : 0);
			bool flag3 = !flag || (Object)(object)recipe == (Object)null || KnowsVeiledRecipeStationRequirement(recipe, num);
			CraftingStation val3 = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetCurrentCraftingStation() : null);
			bool value = (Object)(object)val2 == (Object)null || HasNoCraftCost() || (flag3 && (Object)(object)val3 != (Object)null && val3.m_name == val2.m_name && val3.GetLevel(true) >= num3);
			stringBuilder.Append("|station:").Append(((Object)(object)val2 != (Object)null && flag3) ? val2.m_name : "").Append(':')
				.Append(flag3 ? num3.ToString() : "?")
				.Append(':')
				.Append(value);
			return stringBuilder.ToString();
		}

		private static bool ApplyCraftingTooltipOverlayWidth(float overlayWidth, float contentWidth, float padding, float minSlotSize, float minGap, ref float effectiveSlotSize, ref float effectiveGap, ref float effectiveGemIconSize, ref float effectiveGemGap)
		{
			float num = 5f * minSlotSize + 4f * minGap + padding * 2f;
			if (overlayWidth < num)
			{
				return false;
			}
			if (overlayWidth >= contentWidth + padding * 2f)
			{
				return true;
			}
			float num2 = Mathf.Max(0f, overlayWidth - padding * 2f);
			effectiveSlotSize = (num2 - 4f * effectiveGap) / 5f;
			if (effectiveSlotSize < minSlotSize)
			{
				effectiveGap = Mathf.Max(minGap, (num2 - 5f * minSlotSize) / 4f);
				effectiveSlotSize = (num2 - 4f * effectiveGap) / 5f;
			}
			effectiveSlotSize = Mathf.Clamp(effectiveSlotSize, minSlotSize, 42f);
			effectiveGemIconSize = Mathf.Min(24f, Mathf.Max(18f, effectiveSlotSize * 0.58f));
			effectiveGemGap = Mathf.Min(5f, Mathf.Max(3f, effectiveSlotSize * 0.12f));
			return true;
		}

		private static RectTransform EnsureCraftingTooltipRecipeOverlay(RectTransform tooltipRect, RectTransform parent)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CraftingUi.TooltipRecipeOverlay != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.TooltipRecipeOverlay) && (Object)(object)((Transform)CraftingUi.TooltipRecipeOverlay).parent == (Object)(object)parent)
			{
				return CraftingUi.TooltipRecipeOverlay;
			}
			Transform val = ((Transform)parent).Find("InventorySlots_CraftingTooltipRecipeOverlay") ?? ((Transform)tooltipRect).Find("InventorySlots_CraftingTooltipRecipeOverlay");
			RectTransform tooltipRecipeOverlay = (RectTransform)(((Object)(object)CraftingUi.TooltipRecipeOverlay != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.TooltipRecipeOverlay)) ? ((object)CraftingUi.TooltipRecipeOverlay) : ((object)(((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null)));
			CraftingUi.TooltipRecipeOverlay = tooltipRecipeOverlay;
			if ((Object)(object)CraftingUi.TooltipRecipeOverlay == (Object)null)
			{
				CraftingUi.TooltipRecipeOverlay = new GameObject("InventorySlots_CraftingTooltipRecipeOverlay", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				}).GetComponent<RectTransform>();
			}
			else if ((Object)(object)((Component)CraftingUi.TooltipRecipeOverlay).GetComponent<Image>() == (Object)null)
			{
				((Component)CraftingUi.TooltipRecipeOverlay).gameObject.AddComponent<Image>();
			}
			((Transform)CraftingUi.TooltipRecipeOverlay).SetParent((Transform)(object)parent, false);
			return CraftingUi.TooltipRecipeOverlay;
		}

		private static void DisableCraftingTooltipRecipeOverlayBackground(Image? image)
		{
			if (!((Object)(object)image == (Object)null))
			{
				((Behaviour)image).enabled = false;
				((Graphic)image).raycastTarget = false;
			}
		}

		private static void HideCraftingTooltipRecipeOverlay()
		{
			if ((Object)(object)CraftingUi.HoverTooltip != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltip))
			{
				CraftingUi.HoverTooltip.SetActive(false);
			}
			if ((Object)(object)CraftingUi.TooltipRecipeOverlay != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.TooltipRecipeOverlay))
			{
				((Component)CraftingUi.TooltipRecipeOverlay).gameObject.SetActive(false);
			}
			CraftingUi.HoverTooltipSignature = "";
			CraftingUi.HoverTooltipLayoutSignature = "";
			CraftingUi.HoverTooltipVisualSignature = "";
			CraftingUi.HoverGemIconSignature = "";
			CraftingRecipes.HoverGemIconCache.Clear();
			HideCraftingHoverTooltipBodyScroll();
			HideCraftingGemIconRow(ref CraftingUi.TooltipGemIconRow);
		}

		private static void ConfigureCraftingTooltipRecipeRow(RectTransform owner, RecipeDataPair pair, Vector2 bottomLeft, float slotSize, float gap, bool enableSlotTooltips = true)
		{
			//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_001e: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = EnsureCraftingTooltipRecipeRow(owner);
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.zero;
			val.pivot = Vector2.zero;
			val.anchoredPosition = bottomLeft;
			val.sizeDelta = new Vector2(5f * slotSize + 4f * gap, slotSize);
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			((Component)val).gameObject.SetActive(true);
			Recipe recipe = ((RecipeDataPair)(ref pair)).Recipe;
			int num = ((((RecipeDataPair)(ref pair)).ItemData == null) ? 1 : (((RecipeDataPair)(ref pair)).ItemData.m_quality + 1));
			bool flag = IsVeiledRecipeMasked(pair);
			for (int i = 0; i < 4; i++)
			{
				int num2 = i;
				EnsureCraftingTooltipRecipeSlot(val, num2).anchoredPosition = new Vector2((float)num2 * (slotSize + gap), 0f);
				if (!TryGetCraftingTooltipRequirement(recipe, num, i, out Requirement requirement))
				{
					ConfigureCraftingTooltipRecipeSlot(val, num2, null, "", available: true, slotSize, "", enableSlotTooltips);
					continue;
				}
				int amount = requirement.GetAmount(num);
				int availableCraftingRequirementAmount = GetAvailableCraftingRequirementAmount(requirement);
				bool flag2 = !flag || IsVeiledRecipeRequirementKnown(requirement);
				string tooltipTopic = (flag2 ? GetRequirementDisplayName(requirement) : GetVeiledRecipeUnknownNameText());
				ConfigureCraftingTooltipRecipeSlot(val, num2, requirement.m_resItem.m_itemData.GetIcon(), flag2 ? $"{availableCraftingRequirementAmount}/{amount}" : GetVeiledRecipeUnknownRequirementText(), flag2 && (HasNoCraftCost() || availableCraftingRequirementAmount >= amount), slotSize, tooltipTopic, enableSlotTooltips, flag2 ? ((Color?)null) : new Color?(Color.black), flag2 ? ((Color?)null) : new Color?(Color.white));
			}
			CraftingStation val2 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStation(num) : null);
			int num3 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStationLevel(num) : 0);
			bool flag3 = !flag || (Object)(object)recipe == (Object)null || KnowsVeiledRecipeStationRequirement(recipe, num);
			CraftingStation val3 = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetCurrentCraftingStation() : null);
			bool available = (Object)(object)val2 == (Object)null || HasNoCraftCost() || (flag3 && (Object)(object)val3 != (Object)null && val3.m_name == val2.m_name && val3.GetLevel(true) >= num3);
			int num4 = 4;
			EnsureCraftingTooltipRecipeSlot(val, num4).anchoredPosition = new Vector2((float)num4 * (slotSize + gap), 0f);
			ConfigureCraftingTooltipRecipeSlot(val, num4, ((Object)(object)val2 != (Object)null) ? val2.m_icon : null, (!((Object)(object)val2 != (Object)null) || num3 <= 0) ? "" : (flag3 ? num3.ToString() : GetVeiledRecipeUnknownRequirementText()), available, slotSize, (!((Object)(object)val2 != (Object)null)) ? "" : (flag3 ? GetCraftingStationDisplayName(val2) : GetVeiledRecipeUnknownNameText()), enableSlotTooltips, flag3 ? ((Color?)null) : new Color?(Color.black), flag3 ? ((Color?)null) : new Color?(Color.white));
		}

		private static bool TryGetCraftingTooltipRequirement(Recipe? recipe, int quality, int index, out Requirement requirement)
		{
			requirement = null;
			if (recipe?.m_resources == null)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < recipe.m_resources.Length; i++)
			{
				Requirement val = recipe.m_resources[i];
				if (val != null && !((Object)(object)val.m_resItem == (Object)null) && val.GetAmount(quality) > 0)
				{
					if (num == index)
					{
						requirement = val;
						return true;
					}
					num++;
					if (num > index)
					{
						return false;
					}
				}
			}
			return false;
		}

		private static RectTransform EnsureCraftingTooltipRecipeRow(RectTransform owner)
		{
			//IL_003a: 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)
			Transform val = ((Transform)owner).Find("RecipeRow");
			RectTransform val2 = (RectTransform)((!((Object)(object)val != (Object)null)) ? ((object)new GameObject("RecipeRow", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>()) : ((object)(RectTransform)val));
			if ((Object)(object)((Transform)val2).parent != (Object)(object)owner)
			{
				((Transform)val2).SetParent((Transform)(object)owner, false);
			}
			return val2;
		}

		private static void ConfigureCraftingTooltipRecipeSlot(RectTransform row, int index, Sprite? icon, string amount, bool available, float slotSize, string tooltipTopic, bool enableTooltip, Color? iconColor = null, Color? amountColor = null)
		{
			//IL_0019: 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_00e7: 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_0111: 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_0140: 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_017d: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: 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_01fe: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = EnsureCraftingTooltipRecipeSlot(row, index);
			((Component)val).gameObject.SetActive(true);
			val.sizeDelta = new Vector2(slotSize, slotSize);
			Image obj = ((Component)val).GetComponent<Image>() ?? ((Component)val).gameObject.AddComponent<Image>();
			obj.sprite = GetSolidUiSprite();
			((Graphic)obj).color = new Color(0.12f, 0.075f, 0.045f, 0.62f);
			((Graphic)obj).raycastTarget = enableTooltip && !string.IsNullOrWhiteSpace(tooltipTopic);
			ConfigureSimpleTooltip(((Component)val).gameObject, tooltipTopic, enableTooltip && !string.IsNullOrWhiteSpace(tooltipTopic));
			Transform obj2 = ((Transform)val).Find("Icon");
			Image val2 = ((obj2 != null) ? ((Component)obj2).GetComponent<Image>() : null) ?? CreateTooltipRecipeSlotImage(val);
			((Component)val2).gameObject.SetActive((Object)(object)icon != (Object)null);
			if ((Object)(object)icon != (Object)null)
			{
				RectTransform rectTransform = ((Graphic)val2).rectTransform;
				rectTransform.anchorMin = new Vector2(0f, 1f);
				rectTransform.anchorMax = new Vector2(0f, 1f);
				rectTransform.pivot = new Vector2(0f, 1f);
				rectTransform.anchoredPosition = new Vector2(5f, -5f);
				rectTransform.sizeDelta = new Vector2(slotSize - 10f, slotSize - 10f);
				val2.sprite = icon;
				((Graphic)val2).color = (Color)(((??)iconColor) ?? (available ? Color.white : new Color(0.72f, 0.72f, 0.72f, 0.62f)));
				((Graphic)val2).raycastTarget = false;
			}
			Transform obj3 = ((Transform)val).Find("Amount");
			TMP_Text obj4 = ((obj3 != null) ? ((Component)obj3).GetComponent<TMP_Text>() : null) ?? CreateTooltipRecipeSlotText(val);
			ApplyDefaultFontAsset(obj4);
			obj4.text = amount;
			((Component)obj4).gameObject.SetActive(!string.IsNullOrEmpty(amount));
			((Graphic)obj4).color = (Color)(((??)amountColor) ?? (available ? new Color(1f, 0.84f, 0.42f, 1f) : new Color(1f, 0.32f, 0.24f, 1f)));
			obj4.alignment = (TextAlignmentOptions)1028;
			obj4.textWrappingMode = (TextWrappingModes)0;
			obj4.enableAutoSizing = true;
			obj4.fontSizeMin = 9f;
			obj4.fontSizeMax = 16f;
			RectTransform rectTransform2 = obj4.rectTransform;
			rectTransform2.anchorMin = Vector2.zero;
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = new Vector2(3f, 2f);
			rectTransform2.offsetMax = new Vector2(-3f, -2f);
		}

		private static RectTransform EnsureCraftingTooltipRecipeSlot(RectTransform row, int index)
		{
			//IL_0051: 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_006e: 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_0084: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			string text = "RecipeSlot" + index;
			Transform val = ((Transform)row).Find(text);
			RectTransform val2 = (RectTransform)((!((Object)(object)val != (Object)null)) ? ((object)new GameObject(text, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>()) : ((object)(RectTransform)val));
			if ((Object)(object)((Transform)val2).parent != (Object)(object)row)
			{
				((Transform)val2).SetParent((Transform)(object)row, false);
			}
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.zero;
			val2.pivot = Vector2.zero;
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			return val2;
		}

		private static Image CreateTooltipRecipeSlotImage(RectTransform slot)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject("Icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)slot, false);
			return ((Component)component).GetComponent<Image>();
		}

		private static TMP_Text CreateTooltipRecipeSlotText(RectTransform slot)
		{
			CreateTextRect("Amount", (Transform)(object)slot, out TMP_Text text);
			return text;
		}

		private static bool IsForeignCraftingUiTransform(InventoryGui gui, Transform transform)
		{
			if ((Object)(object)transform == (Object)null || (Object)(object)gui.m_crafting == (Object)null || !transform.IsChildOf((Transform)(object)gui.m_crafting))
			{
				return false;
			}
			if (IsOwnedCraftingUiTransform(transform))
			{
				return false;
			}
			if (IsKnownVanillaCraftingTransform(gui, transform))
			{
				return false;
			}
			Transform val = transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)gui.m_crafting)
			{
				string text = ((Object)val).name.ToLowerInvariant();
				if (text.Contains("vnei") || text.Contains("jewelcrafting") || text.Contains("augment") || text.Contains("synergy"))
				{
					return true;
				}
				MonoBehaviour[] components = ((Component)val).GetComponents<MonoBehaviour>();
				foreach (MonoBehaviour val2 in components)
				{
					string text2 = (((Object)(object)val2 != (Object)null) ? ((object)val2).GetType() : null)?.Namespace ?? "";
					if (text2.StartsWith("VNEI", StringComparison.Ordinal) || text2.StartsWith("Jewelcrafting", StringComparison.Ordinal))
					{
						return true;
					}
				}
				val = val.parent;
			}
			return false;
		}

		private static bool IsKnownVanillaCraftingTransform(InventoryGui gui, Transform transform)
		{
			//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)
			if ((Object)(object)transform == (Object)(object)gui.m_recipeListRoot)
			{
				return true;
			}
			if (gui.m_availableRecipes != null)
			{
				foreach (RecipeDataPair availableRecipe in gui.m_availableRecipes)
				{
					RecipeDataPair current = availableRecipe;
					Transform val = (((Object)(object)((RecipeDataPair)(ref current)).InterfaceElement != (Object)null && !IsUnityNull((Object?)(object)((RecipeDataPair)(ref current)).InterfaceElement)) ? ((RecipeDataPair)(ref current)).InterfaceElement.transform : null);
					if ((Object)(object)val != (Object)null && transform.IsChildOf(val))
					{
						return true;
					}
				}
			}
			foreach (Transform knownVanillaCraftingRoot in GetKnownVanillaCraftingRoots(gui))
			{
				if ((Object)(object)knownVanillaCraftingRoot != (Object)null && !IsUnityNull((Object?)(object)knownVanillaCraftingRoot) && transform.IsChildOf(knownVanillaCraftingRoot))
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<Transform?> GetKnownVanillaCraftingRoots(InventoryGui gui)
		{
			yield return ((Object)(object)gui.m_recipeListScroll != (Object)null) ? ((Component)gui.m_recipeListScroll).transform : null;
			yield return ((Object)(object)gui.m_recipeIcon != (Object)null) ? ((Component)gui.m_recipeIcon).transform : null;
			yield return ((Object)(object)gui.m_recipeName != (Object)null) ? gui.m_recipeName.transform : null;
			yield return ((Object)(object)gui.m_recipeDecription != (Object)null) ? gui.m_recipeDecription.transform : null;
			yield return ((Object)(object)gui.m_itemCraftType != (Object)null) ? gui.m_itemCraftType.transform : null;
			yield return ((Object)(object)gui.m_variantButton != (Object)null) ? ((Component)gui.m_variantButton).transform : null;
			yield return ((Object)(object)gui.m_minStationLevelIcon != (Object)null) ? ((Component)gui.m_minStationLevelIcon).transform : null;
			yield return ((Object)(object)gui.m_minStationLevelText != (Object)null) ? gui.m_minStationLevelText.transform : null;
			yield return ((Object)(object)gui.m_craftButton != (Object)null) ? ((Component)gui.m_craftButton).transform : null;
			yield return ((Object)(object)gui.m_repairButton != (Object)null) ? ((Component)gui.m_repairButton).transform : null;
			yield return ((Object)(object)gui.m_repairButtonGlow != (Object)null) ? ((Component)gui.m_repairButtonGlow).transform : null;
			yield return ((Object)(object)gui.m_tabCraft != (Object)null) ? ((Component)gui.m_tabCraft).transform : null;
			yield return ((Object)(object)gui.m_tabUpgrade != (Object)null) ? ((Component)gui.m_tabUpgrade).transform : null;
		}

		private static bool IsOwnedCraftingUiTransform(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return false;
			}
			if (((Object)transform).name.StartsWith("InventorySlots_", StringComparison.Ordinal))
			{
				return true;
			}
			RectTransform[] array = (RectTransform[])(object)new RectTransform[8] { _craftingRecipeGrid, CraftingUi.TooltipRecipeOverlay, _craftingRecipeScrollbar, _craftingGroupRail, _craftingCountInputRect, CraftingUi.SearchInputRect, _craftingSortModeButtonGroup, _craftingControlsBackground };
			foreach (RectTransform val in array)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && transform.IsChildOf((Transform)(object)val))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsVneiCraftingTransform(Transform? transform)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)transform == (Object)null || (Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance) || (Object)(object)instance.m_crafting == (Object)null || !transform.IsChildOf((Transform)(object)instance.m_crafting))
			{
				return false;
			}
			return IsVneiUiTransform(transform, (Transform?)(object)instance.m_crafting);
		}

		private static bool IsVneiCraftingTabActive(InventoryGui gui)
		{
			if ((Object)(object)gui.m_tabCraft == (Object)null || (Object)(object)gui.m_tabUpgrade == (Object)null)
			{
				return false;
			}
			Transform parent = ((Component)gui.m_tabCraft).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				return false;
			}
			Button[] componentsInChildren = ((Component)parent).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && !((Object)(object)val == (Object)(object)gui.m_tabCraft) && !((Object)(object)val == (Object)(object)gui.m_tabUpgrade) && !((Selectable)val).interactable && ((Component)val).gameObject.activeInHierarchy && IsVneiUiTransform(((Component)val).transform, parent.parent))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsVneiUiTransform(Transform? transform, Transform? stopAt = null)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)stopAt)
			{
				if (((Object)val).name.ToLowerInvariant().Contains("vnei"))
				{
					return true;
				}
				MonoBehaviour[] components = ((Component)val).GetComponents<MonoBehaviour>();
				foreach (MonoBehaviour val2 in components)
				{
					Type obj = (((Object)(object)val2 != (Object)null) ? ((object)val2).GetType() : null);
					string text = obj?.Namespace ?? "";
					string text2 = obj?.Assembly.GetName().Name ?? "";
					if (text.StartsWith("VNEI", StringComparison.Ordinal) || text2.IndexOf("VNEI", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
				val = val.parent;
			}
			return false;
		}

		private static void SetCraftingVanillaDetailVisible(InventoryGui gui, bool visible)
		{
			if ((Object)(object)gui.m_recipeIcon != (Object)null)
			{
				((Component)gui.m_recipeIcon).gameObject.SetActive(visible);
			}
			if ((Object)(object)gui.m_recipeName != (Object)null)
			{
				((Component)gui.m_recipeName).gameObject.SetActive(visible);
			}
			if ((Object)(object)gui.m_recipeDecription != (Object)null)
			{
				((Component)gui.m_recipeDecription).gameObject.SetActive(visible);
			}
			if ((Object)(object)gui.m_itemCraftType != (Object)null)
			{
				((Component)gui.m_itemCraftType).gameObject.SetActive(visible);
			}
			if ((Object)(object)gui.m_variantButton != (Object)null)
			{
				((Component)gui.m_variantButton).gameObject.SetActive(visible);
			}
			if ((Object)(object)gui.m_minStationLevelIcon != (Object)null)
			{
				((Component)gui.m_minStationLevelIcon).gameObject.SetActive(visible);
			}
			if ((Object)(object)gui.m_minStationLevelText != (Object)null)
			{
				((Component)gui.m_minStationLevelText).gameObject.SetActive(visible);
			}
		}

		private static void EnsureCraftingVanillaRecipeElementsHidden(InventoryGui gui)
		{
			if (!_craftingVanillaRecipeElementsHidden || (!((Object)(object)gui.m_recipeListRoot == (Object)null) && !IsUnityNull((Object?)(object)gui.m_recipeListRoot) && ((Component)gui.m_recipeListRoot).gameObject.activeSelf))
			{
				SetCraftingVanillaRecipeListRootVisible(gui, visible: false);
				SetCraftingVanillaRecipeElementsVisible(gui, visible: false);
				_craftingVanillaRecipeElementsHidden = true;
			}
		}

		internal static void InvalidateCraftingVanillaHiddenState()
		{
			_craftingVanillaRecipeElementsHidden = false;
			_craftingVanillaPanelBackgroundsHidden = false;
		}

		private static void SetCraftingVanillaRecipeListRootVisible(InventoryGui gui, bool visible)
		{
			if ((Object)(object)gui.m_recipeListRoot != (Object)null && !IsUnityNull((Object?)(object)gui.m_recipeListRoot))
			{
				((Component)gui.m_recipeListRoot).gameObject.SetActive(visible);
			}
		}

		private static void SetCraftingVanillaRecipeElementsVisible(InventoryGui gui, bool visible)
		{
			//IL_0020: 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)
			SetCraftingVanillaRecipeListRootVisible(gui, visible);
			if (gui.m_availableRecipes == null)
			{
				return;
			}
			foreach (RecipeDataPair availableRecipe in gui.m_availableRecipes)
			{
				RecipeDataPair current = availableRecipe;
				if ((Object)(object)((RecipeDataPair)(ref current)).InterfaceElement != (Object)null && !IsUnityNull((Object?)(object)((RecipeDataPair)(ref current)).InterfaceElement))
				{
					((RecipeDataPair)(ref current)).InterfaceElement.SetActive(visible);
				}
			}
		}

		private static void EnsureCraftingVanillaPanelBackgroundsHidden(InventoryGui gui)
		{
			SuppressCraftingRequiredStationLevelOriginalBackground(gui);
			if (!_craftingVanillaPanelBackgroundsHidden || CraftingVanillaPanelBackgroundStates.Count <= 0)
			{
				SetCraftingVanillaPanelBackgroundsVisible(gui, visible: false);
				_craftingVanillaPanelBackgroundsHidden = true;
			}
		}

		private static void SetCraftingVanillaPanelBackgroundsVisible(InventoryGui gui, bool visible)
		{
			if (visible)
			{
				KeyValuePair<Image, bool>[] array = CraftingVanillaPanelBackgroundStates.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					KeyValuePair<Image, bool> keyValuePair = array[i];
					Image key = keyValuePair.Key;
					if (!((Object)(object)key == (Object)null) && !IsUnityNull((Object?)(object)key))
					{
						((Behaviour)key).enabled = keyValuePair.Value;
					}
				}
				CraftingVanillaPanelBackgroundStates.Clear();
				_craftingVanillaPanelBackgroundsHidden = false;
				return;
			}
			foreach (Image item in FindCraftingVanillaPanelBackgroundImages(gui))
			{
				if (!((Object)(object)item == (Object)null) && !IsUnityNull((Object?)(object)item))
				{
					if (!CraftingVanillaPanelBackgroundStates.ContainsKey(item))
					{
						CraftingVanillaPanelBackgroundStates[item] = ((Behaviour)item).enabled;
					}
					((Behaviour)item).enabled = false;
				}
			}
		}

		private static IEnumerable<Image> FindCraftingVanillaPanelBackgroundImages(InventoryGui gui)
		{
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				yield break;
			}
			HashSet<Image> yielded = new HashSet<Image>();
			foreach (Image item in FindCraftingPanelNamedBackgroundImages(gui))
			{
				if (yielded.Add(item))
				{
					yield return item;
				}
			}
			foreach (Image item2 in FindCraftingPanelFieldBackgroundImages(gui))
			{
				if (yielded.Add(item2))
				{
					yield return item2;
				}
			}
		}

		private static IEnumerable<Image> FindCraftingPanelNamedBackgroundImages(InventoryGui gui)
		{
			string[] array = new string[3] { "RecipeList", "Decription", "Description" };
			foreach (string text in array)
			{
				Transform panel = ((Transform)gui.m_crafting).Find(text);
				if ((Object)(object)panel == (Object)null)
				{
					continue;
				}
				Image panelImage = ((Component)panel).GetComponent<Image>();
				if ((Object)(object)panelImage != (Object)null && ShouldHideCraftingPanelBackgroundImage(gui, panelImage))
				{
					yield return panelImage;
				}
				Image[] componentsInChildren = ((Component)panel).GetComponentsInChildren<Image>(true);
				foreach (Image val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)(object)panelImage && ShouldHideCraftingPanelBackgroundImage(gui, val) && IsCraftingBackgroundLikeImage(((Component)val).transform))
					{
						yield return val;
					}
				}
			}
		}

		private static IEnumerable<Image> FindCraftingPanelFieldBackgroundImages(InventoryGui gui)
		{
			Transform[] array = (Transform[])(object)new Transform[4]
			{
				(Transform)gui.m_recipeListRoot,
				((Object)(object)gui.m_recipeListScroll != (Object)null) ? ((Component)gui.m_recipeListScroll).transform : null,
				((Object)(object)gui.m_minStationLevelIcon != (Object)null) ? ((Component)gui.m_minStationLevelIcon).transform : null,
				((Object)(object)gui.m_minStationLevelText != (Object)null) ? gui.m_minStationLevelText.transform : null
			};
			foreach (Transform anchor in array)
			{
				Transform cursor = anchor;
				while ((Object)(object)cursor != (Object)null && (Object)(object)cursor != (Object)(object)gui.m_crafting)
				{
					Image[] components = ((Component)cursor).GetComponents<Image>();
					foreach (Image val in components)
					{
						if (ShouldHideCraftingPanelBackgroundImage(gui, val))
						{
							yield return val;
						}
					}
					Transform parent = cursor.parent;
					if ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)gui.m_crafting)
					{
						components = ((Component)parent).GetComponentsInChildren<Image>(true);
						foreach (Image val2 in components)
						{
							if (ShouldHideCraftingPanelBackgroundImage(gui, val2) && IsNearCraftingFieldBackground(anchor, ((Component)val2).transform, parent))
							{
								yield return val2;
							}
						}
					}
					cursor = cursor.parent;
				}
			}
		}

		private static bool ShouldHideCraftingPanelBackgroundImage(InventoryGui gui, Image image)
		{
			if ((Object)(object)image == (Object)null || IsUnityNull((Object?)(object)image) || (Object)(object)image == (Object)(object)gui.m_minStationLevelIcon)
			{
				return false;
			}
			Transform transform = ((Component)image).transform;
			if ((Object)(object)transform == (Object)(object)gui.m_crafting || IsOwnedCraftingUiTransform(transform))
			{
				return false;
			}
			if ((Object)(object)gui.m_recipeListScroll != (Object)null && transform.IsChildOf(((Component)gui.m_recipeListScroll).transform))
			{
				return false;
			}
			return transform.IsChildOf((Transform)(object)gui.m_crafting);
		}

		private static bool IsCraftingBackgroundLikeImage(Transform imageTransform)
		{
			string text = ((Object)imageTransform).name.ToLowerInvariant();
			if (!text.Contains("bkg") && !text.Contains("background") && !text.Contains("frame") && !text.Contains("border"))
			{
				return text.Contains("panel");
			}
			return true;
		}

		private static bool IsNearCraftingFieldBackground(Transform? anchor, Transform imageTransform, Transform parent)
		{
			if ((Object)(object)anchor == (Object)null)
			{
				return false;
			}
			if ((Object)(object)imageTransform == (Object)(object)anchor || imageTransform.IsChildOf(anchor) || anchor.IsChildOf(imageTransform))
			{
				return true;
			}
			if (IsCraftingBackgroundLikeImage(imageTransform))
			{
				return true;
			}
			return false;
		}

		private static void InvalidateCustomEquipmentProjectionCache()
		{
			_customEquipmentCacheVersion++;
		}

		private static IReadOnlyList<ItemData> GetCustomEquippedItems(Player player)
		{
			EnsureCustomEquipmentProjectionCache(player);
			return CustomEquippedItemsCache;
		}

		private static float GetCachedCustomEquipmentWeight(Player player)
		{
			EnsureCustomEquipmentProjectionCache(player);
			return _customEquipmentCacheWeight;
		}

		private static float GetCachedCustomEquipmentEitrRegen(Player player)
		{
			EnsureCustomEquipmentProjectionCache(player);
			return _customEquipmentCacheEitrRegen;
		}

		private static float GetCachedCustomEquipmentArmor(Player player)
		{
			EnsureCustomEquipmentProjectionCache(player);
			return _customEquipmentCacheArmor;
		}

		private static float[]? GetCachedCustomEquipmentModifierValues(Player player)
		{
			EnsureCustomEquipmentProjectionCache(player);
			return _customEquipmentModifierValuesCache;
		}

		private static int GetCachedCustomEquipmentSetCount(Player player, string setName)
		{
			EnsureCustomEquipmentProjectionCache(player);
			if (!CustomEquipmentSetCountCache.TryGetValue(setName, out var value))
			{
				return 0;
			}
			return value;
		}

		private static void EnsureCustomEquipmentProjectionCache(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				ClearCustomEquipmentProjectionCache();
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			string playerId = GetPlayerId(player);
			if (inventory != null && (Object)(object)_customEquipmentCachePlayer == (Object)(object)player && _customEquipmentCacheInventory == inventory && string.Equals(_customEquipmentCachePlayerId, playerId, StringComparison.Ordinal) && _customEquipmentCacheBuiltVersion == _customEquipmentCacheVersion)
			{
				return;
			}
			ClearCustomEquipmentProjectionCache();
			_customEquipmentCachePlayer = player;
			_customEquipmentCacheInventory = inventory;
			_customEquipmentCachePlayerId = playerId;
			_customEquipmentCacheBuiltVersion = _customEquipmentCacheVersion;
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item == null || !IsInventorySlotsCustomEquipped(item) || !item.m_customData.TryGetValue("InventorySlotsEquippedBy", out var value) || value != playerId)
				{
					continue;
				}
				CustomEquippedItemsCache.Add(item);
				if (item.m_shared != null)
				{
					_customEquipmentCacheWeight += item.m_shared.m_weight;
					_customEquipmentCacheEitrRegen += item.m_shared.m_eitrRegenModifier;
					if (item.m_shared.m_armor > 0f)
					{
						_customEquipmentCacheArmor += item.GetArmor();
					}
					string setName = item.m_shared.m_setName;
					if (!string.IsNullOrEmpty(setName))
					{
						CustomEquipmentSetCountCache.TryGetValue(setName, out var value2);
						CustomEquipmentSetCountCache[setName] = value2 + 1;
					}
					AddCachedCustomEquipmentModifierValues(item);
				}
			}
		}

		private static void AddCachedCustomEquipmentModifierValues(ItemData item)
		{
			FieldInfo[] s_equipmentModifierSourceFields = Player.s_equipmentModifierSourceFields;
			if (s_equipmentModifierSourceFields == null || item.m_shared == null)
			{
				return;
			}
			if (_customEquipmentModifierValuesCache == null || _customEquipmentModifierValuesCache.Length != s_equipmentModifierSourceFields.Length)
			{
				_customEquipmentModifierValuesCache = new float[s_equipmentModifierSourceFields.Length];
			}
			for (int i = 0; i < s_equipmentModifierSourceFields.Length; i++)
			{
				if (s_equipmentModifierSourceFields[i].GetValue(item.m_shared) is float num)
				{
					_customEquipmentModifierValuesCache[i] += num;
				}
			}
		}

		private static void ClearCustomEquipmentProjectionCache()
		{
			CustomEquippedItemsCache.Clear();
			CustomEquipmentSetCountCache.Clear();
			_customEquipmentCachePlayer = null;
			_customEquipmentCacheInventory = null;
			_customEquipmentCachePlayerId = "";
			_customEquipmentCacheBuiltVersion = -1;
			_customEquipmentCacheWeight = 0f;
			_customEquipmentCacheEitrRegen = 0f;
			_customEquipmentCacheArmor = 0f;
			if (_customEquipmentModifierValuesCache != null)
			{
				Array.Clear(_customEquipmentModifierValuesCache, 0, _customEquipmentModifierValuesCache.Length);
			}
		}

		internal static void UpdateCustomEquipmentVisuals(Player player)
		{
			if (IsDedicatedServer || IsUnityNull((Object?)(object)player) || player.m_isLoading)
			{
				if (!IsUnityNull((Object?)(object)((Humanoid)(player?)).m_visEquipment))
				{
					ClearCustomEquipmentVisuals(((Humanoid)player).m_visEquipment);
				}
				return;
			}
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (IsUnityNull((Object?)(object)visEquipment) || IsUnityNull((Object?)(object)ObjectDB.instance))
			{
				if (!IsUnityNull((Object?)(object)visEquipment))
				{
					ClearCustomEquipmentVisuals(visEquipment);
				}
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				ClearCustomEquipmentVisuals(visEquipment);
				return;
			}
			SyncBackpackCompatState(player);
			SyncMagicSupremacyCompatState(player);
			int updateSignature = ComputeCustomEquipmentVisualUpdateSignature(inventory, visEquipment);
			if (!TrySkipCustomEquipmentVisualUpdate(updateSignature, out int _, out string _))
			{
				if (!HasCustomEquipmentVisualCandidate(inventory) && !HasCustomEquipmentVisualsForOwner(visEquipment))
				{
					ClearCustomEquipmentVisualZdoValues(visEquipment);
					RememberCustomEquipmentVisualUpdate(updateSignature, 0);
					return;
				}
				List<CustomEquipmentVisualState> list = BuildCustomEquipmentVisualStatesFromInventory(player, inventory, visEquipment);
				SuppressJewelcraftingNativeVisualSlots(player, inventory);
				ApplyCustomEquipmentVisualStates(visEquipment, list);
				RememberCustomEquipmentVisualUpdate(updateSignature, list.Count);
			}
		}

		internal static void UpdateCustomEquipmentVisualsFromZdo(VisEquipment visEquipment)
		{
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			if (IsDedicatedServer || IsUnityNull((Object?)(object)visEquipment) || IsUnityNull((Object?)(object)ObjectDB.instance))
			{
				return;
			}
			ZDO val = (((Object)(object)visEquipment.m_nview != (Object)null && visEquipment.m_nview.IsValid()) ? visEquipment.m_nview.GetZDO() : null);
			if (val == null)
			{
				ClearCustomEquipmentVisuals(visEquipment);
				return;
			}
			List<CustomEquipmentVisualState> list = new List<CustomEquipmentVisualState>();
			foreach (SlotDefinition item in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind == SlotKind.CustomEquipment))
			{
				int num = val.GetInt(GetCustomEquipmentVisualItemZdoKey(item.Id), 0);
				if (num == 0)
				{
					continue;
				}
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(num);
				if (!IsUnityNull((Object?)(object)itemPrefab))
				{
					ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
					if (!IsUnityNull((Object?)(object)component) && component.m_itemData?.m_shared != null && ShouldAttachCustomEquipmentVisual(component.m_itemData))
					{
						int variant = val.GetInt(GetCustomEquipmentVisualVariantZdoKey(item.Id), 0);
						list.Add(new CustomEquipmentVisualState(item.Id, num, variant, ((Object)itemPrefab).name, component.m_itemData.m_shared.m_itemType, IsAdventureBackpackItem(component.m_itemData)));
					}
				}
			}
			ApplyCustomEquipmentVisualStates(visEquipment, list);
		}

		private static List<CustomEquipmentVisualState> BuildCustomEquipmentVisualStatesFromInventory(Player player, Inventory inventory, VisEquipment visEquipment)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			List<CustomEquipmentVisualState> list = new List<CustomEquipmentVisualState>();
			foreach (SlotDefinition item in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind == SlotKind.CustomEquipment))
			{
				ItemData val = FindItemForSlot(player, inventory, item);
				int itemHash = 0;
				int variant = 0;
				if (val != null && ShouldAttachCustomEquipmentVisual(val))
				{
					itemHash = StringExtensionMethods.GetStableHashCode(((Object)val.m_dropPrefab).name);
					variant = val.m_variant;
					list.Add(new CustomEquipmentVisualState(item.Id, itemHash, variant, ((Object)val.m_dropPrefab).name, val.m_shared.m_itemType, IsAdventureBackpackItem(val)));
				}
				SetCustomEquipmentVisualZdoValue(visEquipment, item.Id, itemHash, variant);
			}
			return list;
		}

		private static bool TrySkipCustomEquipmentVisualUpdate(int updateSignature, out int stateCount, out string outcome)
		{
			if (EquipmentVisuals.LocalPlayerUpdateFrame >= 0 && EquipmentVisuals.LocalPlayerUpdateSignature == updateSignature)
			{
				stateCount = EquipmentVisuals.LocalPlayerUpdateStateCount;
				outcome = ((EquipmentVisuals.LocalPlayerUpdateFrame == Time.frameCount) ? "sameFrameCached" : "signatureCached");
				EquipmentVisuals.LocalPlayerUpdateFrame = Time.frameCount;
				return true;
			}
			stateCount = -1;
			outcome = "";
			return false;
		}

		private static void RememberCustomEquipmentVisualUpdate(int updateSignature, int stateCount)
		{
			EquipmentVisuals.LocalPlayerUpdateFrame = Time.frameCount;
			EquipmentVisuals.LocalPlayerUpdateSignature = updateSignature;
			EquipmentVisuals.LocalPlayerUpdateStateCount = stateCount;
		}

		private static void InvalidateCustomEquipmentVisualUpdateCache()
		{
			EquipmentVisuals.LocalPlayerUpdateFrame = -1;
			EquipmentVisuals.LocalPlayerUpdateSignature = int.MinValue;
			EquipmentVisuals.LocalPlayerUpdateStateCount = 0;
		}

		private static int ComputeCustomEquipmentVisualUpdateSignature(Inventory inventory, VisEquipment visEquipment)
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected I4, but got Unknown
			int num = 17;
			num = num * 31 + InventoryDefinitions.SlotDefinitionVersion;
			num = num * 31 + ((!IsUnityNull((Object?)(object)visEquipment)) ? ((Object)visEquipment).GetInstanceID() : 0);
			num = num * 31 + ComputeCustomEquipmentVisualOwnerSignature(visEquipment);
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item?.m_shared != null && item.m_customData != null && item.m_customData.ContainsKey("InventorySlotsSlotId"))
				{
					string value;
					string obj = (item.m_customData.TryGetValue("InventorySlotsSlotId", out value) ? value : "");
					num = num * 31 + (item.m_equipped ? 1 : 0);
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(obj);
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(GetItemPrefabName(item));
					num = num * 31 + item.m_variant;
					num = num * 31 + item.m_shared.m_itemType;
				}
			}
			return num;
		}

		private static int ComputeCustomEquipmentVisualOwnerSignature(VisEquipment visEquipment)
		{
			int num = 17;
			foreach (CustomEquipmentVisual value in EquipmentVisuals.Visuals.Values)
			{
				if (value.IsOwnedBy(visEquipment))
				{
					num = num * 31 + StringComparer.Ordinal.GetHashCode(value.Key);
					num = num * 31 + StringComparer.Ordinal.GetHashCode(value.PrefabName);
					num = num * 31 + value.Variant;
				}
			}
			return num;
		}

		private static bool HasCustomEquipmentVisualCandidate(Inventory inventory)
		{
			foreach (ItemData item in inventory.m_inventory)
			{
				if (IsInventorySlotsCustomEquipped(item) && ShouldAttachCustomEquipmentVisual(item))
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasCustomEquipmentVisualsForOwner(VisEquipment visEquipment)
		{
			foreach (CustomEquipmentVisual value in EquipmentVisuals.Visuals.Values)
			{
				if (value.IsOwnedBy(visEquipment))
				{
					return true;
				}
			}
			return false;
		}

		private static void ClearCustomEquipmentVisualZdoValues(VisEquipment visEquipment)
		{
			foreach (SlotDefinition item in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind == SlotKind.CustomEquipment))
			{
				SetCustomEquipmentVisualZdoValue(visEquipment, item.Id, 0, 0);
			}
		}

		private static void ApplyCustomEquipmentVisualStates(VisEquipment visEquipment, IEnumerable<CustomEquipmentVisualState> states)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			bool flag = false;
			foreach (CustomEquipmentVisualState state in states)
			{
				string customEquipmentVisualKey = GetCustomEquipmentVisualKey(visEquipment, state);
				hashSet.Add(customEquipmentVisualKey);
				if (!EquipmentVisuals.Visuals.TryGetValue(customEquipmentVisualKey, out CustomEquipmentVisual value) || !value.Matches(visEquipment, state.PrefabName, state.Variant))
				{
					value?.Destroy();
					EquipmentVisuals.Visuals[customEquipmentVisualKey] = CreateCustomEquipmentVisual(visEquipment, state, customEquipmentVisualKey);
					flag = true;
				}
			}
			foreach (string item in EquipmentVisuals.Visuals.Keys.ToList())
			{
				if (EquipmentVisuals.Visuals[item].IsOwnedBy(visEquipment) && !hashSet.Contains(item))
				{
					EquipmentVisuals.Visuals[item].Destroy();
					EquipmentVisuals.Visuals.Remove(item);
					flag = true;
				}
			}
			if (flag)
			{
				RefreshVisEquipmentLodGroup(visEquipment);
			}
		}

		internal static void ClearCustomEquipmentVisuals()
		{
			List<VisEquipment> list = (from visual in EquipmentVisuals.Visuals.Values
				select visual.Owner into owner
				where !IsUnityNull((Object?)(object)owner)
				select owner).Distinct().ToList();
			foreach (CustomEquipmentVisual value in EquipmentVisuals.Visuals.Values)
			{
				value.Destroy();
			}
			EquipmentVisuals.Visuals.Clear();
			InvalidateCustomEquipmentVisualUpdateCache();
			foreach (VisEquipment item in list)
			{
				RefreshVisEquipmentLodGroup(item);
			}
		}

		private static void ClearCustomEquipmentVisuals(VisEquipment visEquipment)
		{
			bool flag = false;
			foreach (string item in EquipmentVisuals.Visuals.Keys.ToList())
			{
				if (EquipmentVisuals.Visuals[item].IsOwnedBy(visEquipment))
				{
					EquipmentVisuals.Visuals[item].Destroy();
					EquipmentVisuals.Visuals.Remove(item);
					flag = true;
				}
			}
			if (flag)
			{
				InvalidateCustomEquipmentVisualUpdateCache();
				RefreshVisEquipmentLodGroup(visEquipment);
			}
		}

		private static void RefreshVisEquipmentLodGroup(VisEquipment visEquipment)
		{
			if (!IsUnityNull((Object?)(object)visEquipment) && !IsUnityNull((Object?)(object)visEquipment.m_lodGroup))
			{
				visEquipment.UpdateLodgroup();
			}
		}

		private static bool ShouldAttachCustomEquipmentVisual(ItemData item)
		{
			//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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_005d: 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_0062: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			if (item?.m_shared == null || IsUnityNull((Object?)(object)item.m_dropPrefab))
			{
				return false;
			}
			if (IsSmoothbrainBackpackItem(item))
			{
				return false;
			}
			if (IsAdventureBackpackItem(item))
			{
				return true;
			}
			if (IsRustyBagItem(item) || IsRustyQuiverItem(item))
			{
				return false;
			}
			if (IsMagicSupremacyBeltItem(item))
			{
				return false;
			}
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType == 6 || itemType - 17 <= 1 || (int)itemType == 24)
			{
				return true;
			}
			return false;
		}

		private static string GetCustomEquipmentVisualKey(VisEquipment visEquipment, CustomEquipmentVisualState state)
		{
			return $"{((Object)visEquipment).GetInstanceID()}:{state.SlotId}:{state.ItemHash}";
		}

		private static CustomEquipmentVisual CreateCustomEquipmentVisual(VisEquipment visEquipment, CustomEquipmentVisualState state, string key)
		{
			//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_001d: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			CustomEquipmentVisual customEquipmentVisual = new CustomEquipmentVisual(key, visEquipment, state.PrefabName, state.Variant);
			try
			{
				ItemType itemType = state.ItemType;
				if ((int)itemType != 6)
				{
					if (itemType - 17 <= 1 || (int)itemType == 24)
					{
						List<GameObject> instances = visEquipment.AttachArmor(state.ItemHash, state.Variant);
						ReorderAdventureBackpackBones(visEquipment, state, instances);
						customEquipmentVisual.AddRange(instances);
					}
				}
				else if (!IsUnityNull((Object?)(object)visEquipment.m_helmet))
				{
					GameObject instance = visEquipment.AttachItem(state.ItemHash, state.Variant, visEquipment.m_helmet, true, false);
					customEquipmentVisual.Add(instance);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to attach custom equipment visual for " + state.PrefabName + ": " + ex.Message));
			}
			return customEquipmentVisual;
		}

		internal static bool TryGetCustomEquipmentVisualRootsForApi(VisEquipment visEquipment, ItemData item, List<GameObject> roots)
		{
			roots.Clear();
			if (IsUnityNull((Object?)(object)visEquipment) || item == null || IsUnityNull((Object?)(object)item.m_dropPrefab))
			{
				return false;
			}
			string name = ((Object)item.m_dropPrefab).name;
			foreach (CustomEquipmentVisual value in EquipmentVisuals.Visuals.Values)
			{
				if (value.Matches(visEquipment, name, item.m_variant))
				{
					value.AddActiveInstancesTo(roots);
				}
			}
			return roots.Count > 0;
		}

		private static void SetCustomEquipmentVisualZdoValue(VisEquipment visEquipment, string slotId, int itemHash, int variant)
		{
			if (IsUnityNull((Object?)(object)visEquipment) || (Object)(object)visEquipment.m_nview == (Object)null || !visEquipment.m_nview.IsValid() || !visEquipment.m_nview.IsOwner())
			{
				return;
			}
			ZDO zDO = visEquipment.m_nview.GetZDO();
			if (zDO != null)
			{
				int customEquipmentVisualItemZdoKey = GetCustomEquipmentVisualItemZdoKey(slotId);
				int customEquipmentVisualVariantZdoKey = GetCustomEquipmentVisualVariantZdoKey(slotId);
				if (zDO.GetInt(customEquipmentVisualItemZdoKey, 0) != itemHash)
				{
					zDO.Set(customEquipmentVisualItemZdoKey, itemHash, false);
				}
				if (zDO.GetInt(customEquipmentVisualVariantZdoKey, 0) != variant)
				{
					zDO.Set(customEquipmentVisualVariantZdoKey, variant, false);
				}
			}
		}

		private static int GetCustomEquipmentVisualItemZdoKey(string slotId)
		{
			return StringExtensionMethods.GetStableHashCode("InventorySlots_CustomEquipmentVisual_Item_" + slotId);
		}

		private static int GetCustomEquipmentVisualVariantZdoKey(string slotId)
		{
			return StringExtensionMethods.GetStableHashCode("InventorySlots_CustomEquipmentVisual_Variant_" + slotId);
		}

		private static void ReorderAdventureBackpackBones(VisEquipment visEquipment, CustomEquipmentVisualState state, List<GameObject>? instances)
		{
			if (state.ReorderAdventureBackpackBones && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api))
			{
				api?.ReorderBones(visEquipment, state.ItemHash, instances);
			}
		}

		internal static TombStonePreparationState PrepareCreateTombStone(Player player)
		{
			List<KeepOnDeathItemState> keptItems = PrepareKeepOnDeathItems(player);
			bool deathDropUnequipPrepared = PreparePlayerDeathDropUnequip(player);
			return new TombStonePreparationState(keptItems, deathDropUnequipPrepared);
		}

		internal static void CompleteCreateTombStone(Player player, TombStonePreparationState? state)
		{
			if (state == null || state.Completed)
			{
				return;
			}
			try
			{
				RestoreKeepOnDeathItems(player, state.KeptItems);
			}
			finally
			{
				CompletePlayerDeathDropUnequip(state.DeathDropUnequipPrepared);
				state.Completed = true;
			}
		}

		internal static List<KeepOnDeathItemState> PrepareKeepOnDeathItems(Player player)
		{
			//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_0093: 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)
			List<KeepOnDeathItemState> list = new List<KeepOnDeathItemState>();
			if (!DeathKeepRulesEnabled() || (Object)(object)player == (Object)null || player.m_isLoading || _yamlConfig.KeepOnDeath == null || _yamlConfig.KeepOnDeath.Count == 0)
			{
				return list;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return list;
			}
			ItemData[] array = inventory.m_inventory.ToArray();
			foreach (ItemData val in array)
			{
				if (val?.m_shared != null && ShouldKeepOnDeath(val))
				{
					Vector2i gridPos = val.m_gridPos;
					string originalSlotId = "";
					SlotKind? originalSlotKind = null;
					if (TryGetSlotAtGridPos(inventory, gridPos, out SlotDefinition slot) && slot != null)
					{
						originalSlotId = slot.Id;
						originalSlotKind = slot.Kind;
					}
					if (inventory.m_inventory.Remove(val))
					{
						KeepOnDeathItemState item = new KeepOnDeathItemState(val, gridPos, originalSlotId, originalSlotKind);
						list.Add(item);
					}
				}
			}
			return list;
		}

		internal static void RestoreKeepOnDeathItems(Player player, List<KeepOnDeathItemState>? keptItems)
		{
			if ((Object)(object)player == (Object)null || keptItems == null || keptItems.Count == 0)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				keptItems.Clear();
				return;
			}
			bool flag = false;
			EnsureInventoryHeightForLoad(inventory);
			foreach (KeepOnDeathItemState keptItem in keptItems)
			{
				ItemData item = keptItem.Item;
				bool num = item?.m_shared == null;
				bool flag2 = !num && inventory.ContainsItem(item);
				if (!(num || flag2))
				{
					bool flag3 = RestoreKeepOnDeathItem(player, inventory, keptItem);
					flag = flag || flag3;
				}
			}
			keptItems.Clear();
			if (flag)
			{
				inventory.Changed();
				if (!player.m_isLoading)
				{
					EnsureInventoryState(player, InventoryStateEnsureReason.Tombstone);
				}
				ReloadEpicLootRuntimeItemData(player);
				RefreshExternalEquipmentEffects(player);
			}
		}

		private static bool RestoreKeepOnDeathItem(Player player, Inventory inventory, KeepOnDeathItemState state)
		{
			//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_0026: 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_00a3: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
			ItemData item = state.Item;
			Vector2i val = (item.m_gridPos = state.OriginalGridPos);
			SlotDefinition slot;
			bool originalSlotAvailable = TryGetKeepOnDeathOriginalSlot(state, item, out slot) && CanRestoreKeepOnDeathItemToSlot(player, inventory, item, slot);
			SlotDefinition foundSlot;
			bool emptyQuickSlotAvailable = TryFindKeepOnDeathEmptySpecialSlot(player, inventory, item, (SlotDefinition slotDefinition) => slotDefinition.Kind == SlotKind.Quick, out foundSlot);
			SlotDefinition foundSlot2 = null;
			bool emptySameSpecialKindSlotAvailable = !state.WasQuickSlot && TryFindKeepOnDeathEmptySpecialSlot(player, inventory, item, (SlotDefinition slotDefinition) => slotDefinition.Kind == state.OriginalSlotKind, out foundSlot2);
			bool originalCellAvailable = CanRestoreKeepOnDeathItemAtCell(player, inventory, item, val, state);
			Vector2i pos;
			bool freeRegularCellAvailable = TryFindFreeRegularCell(player, inventory, out pos);
			SlotDefinition foundSlot3;
			bool emptyNonQuickSpecialSlotAvailable = TryFindKeepOnDeathEmptySpecialSlot(player, inventory, item, (SlotDefinition slotDefinition) => slotDefinition.Kind != SlotKind.Quick, out foundSlot3);
			switch (InventorySlotSafetyCore.SelectKeepOnDeathRestorePlan(new InventorySlotSafetyCore.KeepOnDeathRestoreOptions(state.WasSpecialSlot, state.WasQuickSlot, originalSlotAvailable, emptyQuickSlotAvailable, emptySameSpecialKindSlotAvailable, originalCellAvailable, freeRegularCellAvailable, emptyNonQuickSpecialSlotAvailable)))
			{
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.OriginalSlot:
				if (slot != null)
				{
					return TryRestoreKeepOnDeathItemToSlot(player, inventory, item, slot);
				}
				return false;
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.EmptyQuickSlot:
				if (foundSlot != null)
				{
					return TryRestoreKeepOnDeathItemToSlot(player, inventory, item, foundSlot);
				}
				return false;
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.EmptySameSpecialKindSlot:
				if (foundSlot2 != null)
				{
					return TryRestoreKeepOnDeathItemToSlot(player, inventory, item, foundSlot2);
				}
				return false;
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.OriginalCell:
				return TryRestoreKeepOnDeathItemAtCell(player, inventory, item, val, state);
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.FirstFreeRegularCell:
				item.m_equipped = false;
				ClearItemSlot(item);
				if (TryMoveToFirstFreeRegularCell(player, inventory, item))
				{
					inventory.m_inventory.Add(item);
					return true;
				}
				break;
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.EmptyNonQuickSpecialSlot:
				if (foundSlot3 != null)
				{
					return TryRestoreKeepOnDeathItemToSlot(player, inventory, item, foundSlot3);
				}
				return false;
			}
			return PreserveKeepOnDeathItemWithoutOverwriting(inventory, item, val);
		}

		private static bool TryRestoreKeepOnDeathItemAtCell(Player player, Inventory inventory, ItemData item, Vector2i target, KeepOnDeathItemState state)
		{
			//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)
			//IL_0016: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!CanRestoreKeepOnDeathItemAtCell(player, inventory, item, target, state))
			{
				return false;
			}
			if (inventory.GetItemAt(target.x, target.y) != null)
			{
				return false;
			}
			item.m_gridPos = target;
			inventory.m_inventory.Add(item);
			return true;
		}

		private static bool TryGetKeepOnDeathOriginalSlot(KeepOnDeathItemState state, ItemData item, out SlotDefinition? slot)
		{
			slot = null;
			if (string.IsNullOrWhiteSpace(state.OriginalSlotId) || !TryGetSlotById(state.OriginalSlotId, out SlotDefinition slot2) || slot2 == null || !slot2.Accepts(item))
			{
				return false;
			}
			slot = slot2;
			return true;
		}

		private static bool CanRestoreKeepOnDeathItemToSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			//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_0019: 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_0028: 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 (slot == null || !CanUseKeepOnDeathSpecialSlot(player, inventory, item, slot))
			{
				return false;
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			if (!IsOutOfBounds(inventory, slotGridPos) && inventory.GetItemAt(slotGridPos.x, slotGridPos.y) == null)
			{
				return CanRestoreKeepOnDeathItemAtCell(player, inventory, item, slotGridPos, slot.Id);
			}
			return false;
		}

		private static bool TryRestoreKeepOnDeathItemToSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!CanRestoreKeepOnDeathItemToSlot(player, inventory, item, slot))
			{
				return false;
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			item.m_gridPos = slotGridPos;
			inventory.m_inventory.Add(item);
			RestoreKeepOnDeathSlotState(player, inventory, item, slot);
			return true;
		}

		private static void RestoreKeepOnDeathSlotState(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if (item != null && slot != null && slot.Kind != SlotKind.Quick)
			{
				RestoreSlotEquipmentState(player, inventory, item, slot);
			}
		}

		private static bool TryFindKeepOnDeathEmptySpecialSlot(Player player, Inventory inventory, ItemData item, Func<SlotDefinition, bool>? slotFilter, out SlotDefinition? foundSlot)
		{
			//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_0042: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			foundSlot = null;
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if ((slotFilter == null || slotFilter(slotDefinition)) && CanUseKeepOnDeathSpecialSlot(player, inventory, item, slotDefinition))
				{
					Vector2i slotGridPos = GetSlotGridPos(inventory, slotDefinition);
					if (!IsOutOfBounds(inventory, slotGridPos) && inventory.GetItemAt(slotGridPos.x, slotGridPos.y) == null && CanRestoreKeepOnDeathItemAtCell(player, inventory, item, slotGridPos, slotDefinition.Id))
					{
						foundSlot = slotDefinition;
						return true;
					}
				}
			}
			return false;
		}

		private static bool PreserveKeepOnDeathItemWithoutOverwriting(Inventory inventory, ItemData item, Vector2i originalGridPos)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//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_00b7: Unknown result type (might be due to invalid IL or missing references)
			EnsureInventoryHeightForLoad(inventory);
			InventorySlotSafetyCore.GridCell gridCell = InventorySlotSafetyCore.SelectNonOverlappingPreservationCell(inventory.GetWidth(), inventory.GetHeight(), new InventorySlotSafetyCore.GridCell(originalGridPos.x, originalGridPos.y), (int x, int y) => inventory.m_inventory.Any((ItemData other) => other != null && other.m_gridPos.x == x && other.m_gridPos.y == y));
			item.m_gridPos = new Vector2i(gridCell.X, gridCell.Y);
			inventory.m_inventory.Add(item);
			Log.LogWarning((object)("Preserved keep-on-death item " + (item.m_shared?.m_name ?? "<unknown>") + " at " + FormatGridPos(item.m_gridPos) + " because no regular inventory cell was free. No item was overwritten."));
			return true;
		}

		private static bool CanRestoreKeepOnDeathItemAtCell(Player player, Inventory inventory, ItemData item, Vector2i target, KeepOnDeathItemState state)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			string expectedSlotId = (state.WasSpecialSlot ? state.OriginalSlotId : "");
			return CanRestoreKeepOnDeathItemAtCell(player, inventory, item, target, expectedSlotId);
		}

		private static bool CanRestoreKeepOnDeathItemAtCell(Player player, Inventory inventory, ItemData item, Vector2i target, string expectedSlotId)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			if (IsOutOfBounds(inventory, target))
			{
				return false;
			}
			if (TryGetSlotAtGridPos(inventory, target, out SlotDefinition slot))
			{
				if (!string.IsNullOrWhiteSpace(expectedSlotId) && !string.Equals(slot.Id, expectedSlotId, StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				return CanUseKeepOnDeathSpecialSlot(player, inventory, item, slot);
			}
			return IsUsableRegularCell(inventory, player, target);
		}

		private static bool CanUseKeepOnDeathSpecialSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if (CanUseSpecialSlot(player, inventory, item, slot))
			{
				return true;
			}
			if (item != null && slot != null && slot.Kind != SlotKind.Quick && slot.Accepts(item) && !IsJewelcraftingUtilityGemBlockedForSlot(item, slot))
			{
				return IsEquipmentSlotProgressionEnabled();
			}
			return false;
		}

		private static bool ShouldKeepOnDeath(ItemData item)
		{
			foreach (string item2 in _yamlConfig.KeepOnDeath ?? new List<string>())
			{
				if (KeepOnDeathTokenMatches(item, item2))
				{
					return true;
				}
			}
			return false;
		}

		private static bool DeathKeepRulesEnabled()
		{
			if (_deathKeepRulesEnabled != null)
			{
				return _deathKeepRulesEnabled.Value.IsOn();
			}
			return true;
		}

		private static bool KeepOnDeathTokenMatches(ItemData item, string token)
		{
			return ItemMatchesYamlReferenceToken(item, token);
		}

		private static bool IsEpicLootLoaded()
		{
			bool valueOrDefault = _epicLootLoaded == true;
			if (!_epicLootLoaded.HasValue)
			{
				valueOrDefault = Chainloader.PluginInfos.ContainsKey("randyknapp.mods.epicloot");
				_epicLootLoaded = valueOrDefault;
			}
			return _epicLootLoaded.Value;
		}

		internal static bool IsEpicLootLoadedForPatches()
		{
			return IsEpicLootLoaded();
		}

		private static void ResetEpicLootEquipmentEffectCache(Player? player)
		{
			if ((Object)(object)player == (Object)null || IsUnityNull((Object?)(object)player) || !IsEpicLootLoaded())
			{
				return;
			}
			ResolveEpicLootEquipmentEffectCacheResetMethod();
			if (_epicLootEquipmentEffectCacheResetMethod == null)
			{
				return;
			}
			try
			{
				_epicLootEquipmentEffectCacheResetMethod.Invoke(null, new object[1] { player });
			}
			catch (Exception ex)
			{
				if (!_epicLootEquipmentEffectCacheResetWarningLogged)
				{
					_epicLootEquipmentEffectCacheResetWarningLogged = true;
					Log.LogWarning((object)("Failed to reset EpicLoot equipment effect cache: " + ex.GetBaseException().Message));
				}
			}
		}

		private static void ScheduleEpicLootRespawnRuntimeReload(Player? player)
		{
			if ((Object)(object)player == (Object)null || IsUnityNull((Object?)(object)player) || (Object)(object)player != (Object)(object)Player.m_localPlayer || !IsEpicLootLoaded() || (Object)(object)_instance == (Object)null || IsUnityNull((Object?)(object)_instance) || Time.frameCount == _lastEpicLootRespawnRuntimeReloadFrame || Time.unscaledTime - _lastEpicLootRespawnRuntimeReloadTime < 0.25f)
			{
				return;
			}
			_lastEpicLootRespawnRuntimeReloadFrame = Time.frameCount;
			_lastEpicLootRespawnRuntimeReloadTime = Time.unscaledTime;
			try
			{
				((MonoBehaviour)_instance).StartCoroutine(DelayedEpicLootRespawnRuntimeReload(player));
			}
			catch (Exception ex)
			{
				if (!_epicLootRuntimeItemDataWarningLogged)
				{
					_epicLootRuntimeItemDataWarningLogged = true;
					Log.LogWarning((object)("Failed to schedule EpicLoot runtime item reload: " + ex.GetBaseException().Message));
				}
			}
		}

		private static IEnumerator DelayedEpicLootRespawnRuntimeReload(Player player)
		{
			yield return (object)new WaitForSecondsRealtime(0.35f);
			if ((Object)(object)player != (Object)null && !IsUnityNull((Object?)(object)player) && (Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				ReloadEpicLootRuntimeItemData(player);
			}
		}

		private static void ReloadEpicLootRuntimeItemData(Player? player)
		{
			if ((Object)(object)player == (Object)null || IsUnityNull((Object?)(object)player) || !IsEpicLootLoaded())
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory?.m_inventory == null)
			{
				return;
			}
			ResolveEpicLootRuntimeItemDataMethods();
			if (_epicLootItemDataMethod == null)
			{
				return;
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (HasNonNullEpicLootMagicData(item))
				{
					LoadEpicLootRuntimeItemData(item);
				}
			}
			ResetEpicLootEquipmentEffectCache(player);
		}

		private static bool HasNonNullEpicLootMagicData(ItemData? item)
		{
			if (item?.m_customData == null || !item.m_customData.TryGetValue("randyknapp.mods.epicloot#EpicLoot.MagicItemComponent", out var value))
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(value))
			{
				return !string.Equals(value.Trim(), "null", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static void LoadEpicLootRuntimeItemData(ItemData item)
		{
			try
			{
				object obj = _epicLootItemDataMethod?.Invoke(null, new object[1] { item });
				if (obj == null)
				{
					return;
				}
				_epicLootItemInfoLoadAllMethod?.Invoke(obj, Array.Empty<object>());
				if (!(_epicLootItemInfoGetMethod == null) && !(_epicLootMagicItemComponentType == null))
				{
					object obj2 = _epicLootItemInfoGetMethod.MakeGenericMethod(_epicLootMagicItemComponentType).Invoke(obj, new object[1] { "" });
					if (obj2 != null)
					{
						_epicLootMagicItemComponentLoadMethod?.Invoke(obj2, Array.Empty<object>());
					}
				}
			}
			catch (Exception ex)
			{
				if (!_epicLootRuntimeItemDataWarningLogged)
				{
					_epicLootRuntimeItemDataWarningLogged = true;
					Log.LogWarning((object)("Failed to reload EpicLoot runtime item data: " + ex.GetBaseException().Message));
				}
			}
		}

		private static void ResolveEpicLootRuntimeItemDataMethods()
		{
			if (_epicLootRuntimeItemDataReflectionResolved)
			{
				return;
			}
			_epicLootRuntimeItemDataReflectionResolved = true;
			_epicLootItemDataMethod = AccessTools.Method("EpicLoot.Data.ItemExtensions:Data", new Type[1] { typeof(ItemData) }, (Type[])null);
			_epicLootMagicItemComponentType = AccessTools.TypeByName("EpicLoot.MagicItemComponent");
			if (_epicLootMagicItemComponentType != null)
			{
				_epicLootMagicItemComponentLoadMethod = AccessTools.Method(_epicLootMagicItemComponentType, "Load", (Type[])null, (Type[])null);
			}
			Type type = _epicLootItemDataMethod?.ReturnType;
			if (type == null)
			{
				return;
			}
			_epicLootItemInfoLoadAllMethod = AccessTools.Method(type, "LoadAll", (Type[])null, (Type[])null);
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == "Get" && methodInfo.IsGenericMethodDefinition && methodInfo.GetParameters().Length == 1)
				{
					_epicLootItemInfoGetMethod = methodInfo;
					break;
				}
			}
		}

		private static void ResolveEpicLootEquipmentEffectCacheResetMethod()
		{
			if (!_epicLootEquipmentEffectCacheResetReflectionResolved)
			{
				_epicLootEquipmentEffectCacheResetReflectionResolved = true;
				_epicLootEquipmentEffectCacheResetMethod = AccessTools.Method("EpicLoot.EquipmentEffectCache:Reset", new Type[1] { typeof(Player) }, (Type[])null);
			}
		}

		internal static bool ShouldUpdateInventorySlotsOwnedHoverTooltip(UITooltip tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip))
			{
				return false;
			}
			if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)null && !IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource) && (Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)(object)tooltip)
			{
				return true;
			}
			if ((Object)(object)UITooltip.m_current == (Object)(object)tooltip)
			{
				return ShouldUseInventorySlotsOwnedHoverTooltip(tooltip);
			}
			return false;
		}

		internal static bool ShouldSuppressEpicLootTooltipLayoutPatch(GameObject? hovered)
		{
			if (!IsEpicLootLoaded())
			{
				return false;
			}
			if (_epicLootInventoryGridTooltipUiPatchScope > 0)
			{
				return true;
			}
			if ((Object)(object)hovered != (Object)null && !IsUnityNull((Object?)(object)hovered) && IsInventoryContainerGridTransform(hovered.transform))
			{
				return true;
			}
			if (ShouldSuppressEpicLootTooltipLayoutPatchForTooltip(UITooltip.m_current))
			{
				return true;
			}
			return ShouldSuppressEpicLootTooltipLayoutPatchForTooltip(((Object)(object)hovered != (Object)null && !IsUnityNull((Object?)(object)hovered)) ? hovered.GetComponentInParent<UITooltip>() : null);
		}

		internal static bool ShouldRunEpicLootComparisonTooltipPatch()
		{
			bool num = ShouldSuppressEpicLootTooltipLayoutPatch(UITooltip.m_hovered);
			if (num)
			{
				ClearEpicLootComparisonTooltip();
			}
			return !num;
		}

		internal static bool ShouldRunEpicLootOnHoverPostfix(GameObject? hovered)
		{
			if (IsUnsafeEpicLootTooltipObject(UITooltip.m_tooltip, out string _))
			{
				return false;
			}
			return !ShouldSuppressEpicLootTooltipLayoutPatch(hovered);
		}

		internal static bool ShouldRunEpicLootAddScrollbarPatch(GameObject? tooltipObject, RectTransform? hoverTransform)
		{
			if (IsUnsafeEpicLootTooltipObject(tooltipObject, out string _))
			{
				return false;
			}
			return !ShouldSuppressEpicLootTooltipLayoutPatch(((Object)(object)hoverTransform != (Object)null) ? ((Component)hoverTransform).gameObject : null);
		}

		internal static void HideTooltipFromEpicLootOnHoverPostfix(GameObject? hovered)
		{
			if (!IsEpicLootLoaded() || (Object)(object)_epicLootSuppressedOnHoverTooltip != (Object)null)
			{
				return;
			}
			GameObject tooltip = UITooltip.m_tooltip;
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip))
			{
				bool flag = ShouldSuppressEpicLootTooltipLayoutPatch(hovered);
				if (!flag && IsUnsafeEpicLootTooltipObject(tooltip, out string _))
				{
					flag = true;
				}
				if (flag)
				{
					_epicLootSuppressedOnHoverTooltip = tooltip;
					UITooltip.m_tooltip = null;
				}
			}
		}

		internal static void RestoreTooltipAfterEpicLootOnHoverPostfix()
		{
			if (!((Object)(object)_epicLootSuppressedOnHoverTooltip == (Object)null))
			{
				if ((Object)(object)UITooltip.m_tooltip == (Object)null || IsUnityNull((Object?)(object)UITooltip.m_tooltip))
				{
					UITooltip.m_tooltip = _epicLootSuppressedOnHoverTooltip;
				}
				_epicLootSuppressedOnHoverTooltip = null;
			}
		}

		internal static void SuppressEpicLootInventoryContainerTooltipArtifacts()
		{
			if (IsEpicLootLoaded())
			{
				ClearEpicLootComparisonTooltip();
				HideEpicLootScrollArtifacts(UITooltip.m_tooltip);
			}
		}

		internal static void BeginEpicLootInventoryGridTooltipUiPatchScope(InventoryGrid grid)
		{
			if (IsEpicLootLoaded() && IsInventoryContainerGrid(grid))
			{
				_epicLootInventoryGridTooltipUiPatchScope++;
			}
		}

		internal static void EndEpicLootInventoryGridTooltipUiPatchScope(InventoryGrid grid)
		{
			if (IsEpicLootLoaded() && IsInventoryContainerGrid(grid) && _epicLootInventoryGridTooltipUiPatchScope > 0)
			{
				_epicLootInventoryGridTooltipUiPatchScope--;
			}
		}

		private static bool ShouldSuppressEpicLootTooltipLayoutPatchForTooltip(UITooltip? tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip))
			{
				return false;
			}
			if (!IsInventorySlotsOwnedTooltipLayoutSource(tooltip))
			{
				return HoverTooltipSourceCore.SuppressesEpicLootTooltipLayout(ResolveHoverTooltipSourceKind(tooltip));
			}
			return true;
		}

		private static bool IsInventorySlotsOwnedTooltipLayoutSource(UITooltip tooltip)
		{
			if (!((Object)(object)_inventoryContainerHoverTooltipSource != (Object)null) || IsUnityNull((Object?)(object)_inventoryContainerHoverTooltipSource) || !((Object)(object)_inventoryContainerHoverTooltipSource == (Object)(object)tooltip))
			{
				if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)null && !IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource))
				{
					return (Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)(object)tooltip;
				}
				return false;
			}
			return true;
		}

		private static bool IsInventoryContainerGrid(InventoryGrid? grid)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)grid != (Object)null && !IsUnityNull((Object?)(object)grid) && (Object)(object)instance != (Object)null && !IsUnityNull((Object?)(object)instance))
			{
				if (!((Object)(object)grid == (Object)(object)instance.m_playerGrid))
				{
					return (Object)(object)grid == (Object)(object)instance.m_containerGrid;
				}
				return true;
			}
			return false;
		}

		private static bool IsInventoryContainerGridTransform(Transform? transform)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)transform == (Object)null || (Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance))
			{
				return false;
			}
			if (!IsTooltipSourceInGrid(transform, instance.m_playerGrid) && !IsTooltipSourceInGrid(transform, instance.m_containerGrid))
			{
				return IsTooltipSourceInInventorySlotsPanel(transform);
			}
			return true;
		}

		private static bool IsUnsafeEpicLootTooltipObject(GameObject? tooltipObject, out string reason)
		{
			reason = "";
			if ((Object)(object)tooltipObject == (Object)null || IsUnityNull((Object?)(object)tooltipObject))
			{
				return false;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance))
			{
				return false;
			}
			Transform transform = tooltipObject.transform;
			if ((Object)(object)instance.m_inventoryRoot != (Object)null && !IsUnityNull((Object?)(object)instance.m_inventoryRoot) && (Object)(object)transform == (Object)(object)instance.m_inventoryRoot)
			{
				reason = "tooltipObject-is-inventoryRoot";
				return true;
			}
			if ((Object)(object)instance.m_player != (Object)null && !IsUnityNull((Object?)(object)instance.m_player) && (Object)(object)transform == (Object)(object)instance.m_player)
			{
				reason = "tooltipObject-is-playerPanel";
				return true;
			}
			Transform val = transform.Find("Bkg");
			Transform val2 = (((Object)(object)instance.m_player != (Object)null && !IsUnityNull((Object?)(object)instance.m_player)) ? ((Transform)instance.m_player).Find("Bkg") : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null && (Object)(object)val == (Object)(object)val2)
			{
				reason = "tooltipObject-would-destroy-playerBkg";
				return true;
			}
			return false;
		}

		private static void ClearEpicLootComparisonTooltip()
		{
			if (!IsEpicLootLoaded())
			{
				return;
			}
			ResolveEpicLootComparisonTooltipFields();
			if (!(_epicLootComparisonTooltipField == null))
			{
				object? value = _epicLootComparisonTooltipField.GetValue(null);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				if (val != null && !IsUnityNull((Object?)(object)val))
				{
					Object.Destroy((Object)(object)val);
				}
				_epicLootComparisonTooltipField.SetValue(null, null);
				_epicLootComparisonAddedField?.SetValue(null, false);
			}
		}

		private static void HideEpicLootScrollArtifacts(GameObject? tooltipObject)
		{
			if ((Object)(object)tooltipObject == (Object)null || IsUnityNull((Object?)(object)tooltipObject))
			{
				return;
			}
			ScrollRect[] componentsInChildren = tooltipObject.GetComponentsInChildren<ScrollRect>(true);
			foreach (ScrollRect val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && IsEpicLootTooltipScrollArtifact(((Component)val).transform))
				{
					((Behaviour)val).enabled = false;
					HideEpicLootArtifactObject(((Component)val).gameObject);
				}
			}
			Scrollbar[] componentsInChildren2 = tooltipObject.GetComponentsInChildren<Scrollbar>(true);
			foreach (Scrollbar val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2) && IsEpicLootTooltipScrollArtifact(((Component)val2).transform))
				{
					((Behaviour)val2).enabled = false;
					HideEpicLootArtifactObject(((Component)val2).gameObject);
				}
			}
		}

		private static bool IsEpicLootTooltipScrollArtifact(Transform transform)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				if (string.Equals(name, "Scroll View", StringComparison.Ordinal) || string.Equals(name, "Scrollbar", StringComparison.Ordinal) || string.Equals(name, "Sliding Area", StringComparison.Ordinal) || string.Equals(name, "Handle", StringComparison.Ordinal))
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static void HideEpicLootArtifactObject(GameObject artifact)
		{
			CanvasGroup obj = artifact.GetComponent<CanvasGroup>() ?? artifact.AddComponent<CanvasGroup>();
			obj.alpha = 0f;
			obj.interactable = false;
			obj.blocksRaycasts = false;
			obj.ignoreParentGroups = false;
		}

		private static void ResolveEpicLootComparisonTooltipFields()
		{
			if (!_epicLootComparisonTooltipReflectionResolved)
			{
				_epicLootComparisonTooltipReflectionResolved = true;
				Type type = AccessTools.TypeByName("EpicLoot.PatchOnHoverFix");
				if (!(type == null))
				{
					_epicLootComparisonTooltipField = AccessTools.Field(type, "ComparisonTT");
					_epicLootComparisonAddedField = AccessTools.Field(type, "ComparisonAdded");
				}
			}
		}

		private static bool HasInventorySlotsCraftingTooltipRoot(Transform transform)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				if (name.StartsWith("InventorySlots_CraftingGroupButton_", StringComparison.Ordinal) || name.StartsWith("InventorySlots_CraftingPinnedTooltip_", StringComparison.Ordinal) || string.Equals(name, "InventorySlots_CraftingTooltipRecipeOverlay", StringComparison.Ordinal) || string.Equals(name, "InventorySlots_CraftingUpgradeProgression", StringComparison.Ordinal))
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		internal static void PrepareCustomEquipmentProjection(Humanoid humanoid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)humanoid != (Object)(object)localPlayer || (Object)(object)localPlayer == (Object)null)
			{
				ClearPreparedCustomEquipmentStatusEffects();
			}
			else
			{
				PrepareCustomEquipmentStatusEffects(humanoid, localPlayer);
			}
		}

		internal static void PrepareCustomEquipmentStatusEffects(Humanoid humanoid, Player player)
		{
			EquipmentVisuals.StatusEffects.Clear();
			EquipmentVisuals.StatusEffectLevels.Clear();
			if ((Object)(object)humanoid == (Object)null || (Object)(object)player == (Object)null)
			{
				return;
			}
			foreach (ItemData customEquippedItem in GetCustomEquippedItems(player))
			{
				PrepareCustomEquipmentStatusEffect(customEquippedItem.m_shared.m_equipStatusEffect, customEquippedItem.m_quality);
				if (humanoid.HaveSetEffect(customEquippedItem))
				{
					PrepareCustomEquipmentStatusEffect(customEquippedItem.m_shared.m_setStatusEffect, customEquippedItem.m_quality);
				}
			}
		}

		private static void PrepareCustomEquipmentStatusEffect(StatusEffect? statusEffect, int itemLevel)
		{
			if (!IsUnityNull((Object?)(object)statusEffect))
			{
				EquipmentVisuals.StatusEffects.Add(statusEffect);
				EquipmentVisuals.StatusEffectLevels.TryGetValue(statusEffect, out var value);
				EquipmentVisuals.StatusEffectLevels[statusEffect] = Math.Max(value, itemLevel);
			}
		}

		internal static void ApplyPreparedCustomEquipmentStatusEffects(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				ClearPreparedCustomEquipmentStatusEffects();
				return;
			}
			foreach (StatusEffect statusEffect in EquipmentVisuals.StatusEffects)
			{
				if (!IsUnityNull((Object?)(object)statusEffect))
				{
					EquipmentVisuals.StatusEffectLevels.TryGetValue(statusEffect, out var value);
					((Character)humanoid).m_seman.AddStatusEffect(statusEffect, false, value, 0f);
					humanoid.m_equipmentStatusEffects.Add(statusEffect);
				}
			}
			ClearPreparedCustomEquipmentStatusEffects();
		}

		internal static void ClearPreparedCustomEquipmentStatusEffects()
		{
			EquipmentVisuals.StatusEffects.Clear();
			EquipmentVisuals.StatusEffectLevels.Clear();
		}

		internal static bool ShouldPreventCustomEquipmentStatusRemoval(SEMan seMan, int nameHash)
		{
			if (nameHash == 0 || EquipmentVisuals.StatusEffects.Count == 0)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || seMan != ((Character)localPlayer).m_seman)
			{
				return false;
			}
			return EquipmentVisuals.StatusEffects.Any((StatusEffect statusEffect) => !IsUnityNull((Object?)(object)statusEffect) && statusEffect.NameHash() == nameHash);
		}

		internal static float GetProjectedCustomEquipmentWeight(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				return GetCachedCustomEquipmentWeight(player);
			}
			return 0f;
		}

		internal static float GetProjectedCustomEquipmentEitrRegenModifier(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				return GetCachedCustomEquipmentEitrRegen(player);
			}
			return 0f;
		}

		internal static float GetCustomEquipmentArmor(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				return GetCachedCustomEquipmentArmor(player);
			}
			return 0f;
		}

		internal static void ApplyCustomEquipmentDamageModifiers(Player player, ref DamageModifiers modifiers)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			foreach (ItemData customEquippedItem in GetCustomEquippedItems(player))
			{
				if (customEquippedItem?.m_shared != null && customEquippedItem.m_shared.m_damageModifiers.Count > 0)
				{
					((DamageModifiers)(ref modifiers)).Apply(customEquippedItem.m_shared.m_damageModifiers);
				}
			}
		}

		internal static void DrainProjectedCustomEquipmentDurability(Humanoid humanoid, Player player, float dt)
		{
			if ((Object)(object)humanoid == (Object)null || (Object)(object)player == (Object)null)
			{
				return;
			}
			foreach (ItemData customEquippedItem in GetCustomEquippedItems(player))
			{
				if (customEquippedItem.m_shared.m_useDurability)
				{
					humanoid.DrainEquipedItemDurability(customEquippedItem, dt);
				}
			}
		}

		internal static int GetProjectedCustomEquipmentSetCount(Player player, string setName)
		{
			if (!((Object)(object)player == (Object)null) && !string.IsNullOrEmpty(setName))
			{
				return GetCachedCustomEquipmentSetCount(player, setName);
			}
			return 0;
		}

		internal static void ApplyProjectedEquipmentModifierValues(Player player)
		{
			if ((Object)(object)player == (Object)null || Player.s_equipmentModifierSourceFields == null)
			{
				return;
			}
			float[] cachedCustomEquipmentModifierValues = GetCachedCustomEquipmentModifierValues(player);
			if (cachedCustomEquipmentModifierValues != null)
			{
				int num = Math.Min(player.m_equipmentModifierValues.Length, cachedCustomEquipmentModifierValues.Length);
				for (int i = 0; i < num; i++)
				{
					player.m_equipmentModifierValues[i] += cachedCustomEquipmentModifierValues[i];
				}
			}
		}

		internal static bool ClearAllCustomEquipmentState(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			bool result = false;
			ItemData[] array = GetCustomEquippedItems(player).ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				ClearCustomEquipmentState(array[i]);
				result = true;
			}
			return result;
		}

		internal static bool TryGetCustomEquippedItemForApi(Player player, Func<ItemData?, bool> predicate, out ItemData? item)
		{
			item = null;
			if ((Object)(object)player == (Object)null || predicate == null)
			{
				return false;
			}
			foreach (ItemData customEquippedItem in GetCustomEquippedItems(player))
			{
				if (predicate(customEquippedItem))
				{
					item = customEquippedItem;
					return true;
				}
			}
			return false;
		}

		internal static bool IsLocalPlayerHumanoid(Humanoid humanoid, out Player? player)
		{
			player = Player.m_localPlayer;
			if ((Object)(object)player != (Object)null)
			{
				return (Object)(object)humanoid == (Object)(object)player;
			}
			return false;
		}

		private static int EnsureForeignSlotItemsPreserved(Player player, Inventory inventory, int minimumHeight, bool recoverToRegularCells, bool warnLockedRows, out bool changed)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			changed = false;
			if (inventory == null)
			{
				return minimumHeight;
			}
			if (recoverToRegularCells)
			{
				foreach (ItemData item in inventory.m_inventory.ToList())
				{
					if (ShouldRecoverForeignSlotItem(player, inventory, item, minimumHeight))
					{
						Vector2i gridPos = item.m_gridPos;
						if (TryFindFreeAutomaticPlacementCell(player, inventory, null, out var pos))
						{
							item.m_gridPos = pos;
							ClearForeignSlotItemState(player, item);
							changed = true;
							InventorySafety.ForeignSlotPreservationWarnings.Remove(GetForeignSlotPreservationWarningKey(item, gridPos));
						}
					}
				}
			}
			int inventoryPreservationHeight = GetInventoryPreservationHeight(inventory, minimumHeight);
			if (inventoryPreservationHeight > minimumHeight || recoverToRegularCells)
			{
				foreach (ItemData item2 in inventory.m_inventory)
				{
					if (ShouldWarnForeignSlotItemPreserved(player, inventory, item2, minimumHeight, warnLockedRows))
					{
						WarnForeignSlotItemPreserved(player, inventory, item2, minimumHeight);
					}
				}
			}
			return inventoryPreservationHeight;
		}

		internal static int GetInventoryPreservationHeight(Inventory inventory, int minimumHeight)
		{
			int num = minimumHeight;
			if (inventory == null)
			{
				return num;
			}
			int width = inventory.GetWidth();
			foreach (ItemData item in inventory.m_inventory)
			{
				if (ShouldPreserveForeignSlotHeight(item, minimumHeight) && item.m_gridPos.x >= 0 && item.m_gridPos.x < width)
				{
					num = Math.Max(num, item.m_gridPos.y + 1);
				}
			}
			return num;
		}

		private static bool ShouldRecoverForeignSlotItem(Player player, Inventory inventory, ItemData? item, int expectedFullHeight)
		{
			//IL_002c: 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)
			if (item == null)
			{
				return false;
			}
			if (ShouldPreserveForeignSlotHeight(item, expectedFullHeight))
			{
				return true;
			}
			if (IsLegacyExtraSlotsItem(item) && item.m_gridPos.y >= GetFixedRegularRows() && !TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition _))
			{
				return true;
			}
			if (!ShouldPreserveProgressiveRowsDuringLoad(inventory, player) && !item.m_equipped && !((Humanoid)player).IsItemEquiped(item) && IsRegularRowProgressionLookupReady(player))
			{
				return GetInventoryCellKind(player, inventory, item.m_gridPos) == InventoryCellKind.RegularLocked;
			}
			return false;
		}

		private static bool ShouldPreserveForeignSlotHeight(ItemData? item, int expectedFullHeight)
		{
			if (item != null && item.m_gridPos.y >= expectedFullHeight)
			{
				return item.m_gridPos.y >= 0;
			}
			return false;
		}

		private static bool IsLegacyExtraSlotsItem(ItemData item)
		{
			if (item.m_customData != null)
			{
				if (!item.m_customData.ContainsKey("ExtraSlotsEquippedSlot") && !item.m_customData.ContainsKey("ExtraSlotsEquippedBy"))
				{
					return item.m_customData.ContainsKey("ExtraSlotsEquippedWeaponShield");
				}
				return true;
			}
			return false;
		}

		private static bool ShouldWarnForeignSlotItemPreserved(Player player, Inventory inventory, ItemData? item, int expectedFullHeight, bool warnLockedRows)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				return false;
			}
			if (!ShouldPreserveForeignSlotHeight(item, expectedFullHeight))
			{
				if (warnLockedRows)
				{
					return GetInventoryCellKind(player, inventory, item.m_gridPos) == InventoryCellKind.RegularLocked;
				}
				return false;
			}
			return true;
		}

		internal static bool ShouldShowLockedInventoryCellForRecovery(Player player, Inventory inventory, Vector2i pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (inventory.GetItemAt(pos.x, pos.y) != null)
			{
				return GetInventoryCellKind(player, inventory, pos) == InventoryCellKind.RegularLocked;
			}
			return false;
		}

		private static void ClearForeignSlotItemState(Player player, ItemData item)
		{
			bool num = ClearLegacyExtraSlotsItemState(item);
			bool flag = ForceClearEquipmentReference(player, item);
			if (num)
			{
				ClearSlotActionState(item);
			}
			if (flag)
			{
				RefreshExternalEquipmentEffects(player);
			}
		}

		private static bool ClearLegacyExtraSlotsItemState(ItemData item)
		{
			if (item?.m_customData == null)
			{
				return false;
			}
			return (byte)(0u | (item.m_customData.Remove("ExtraSlotsEquippedBy") ? 1u : 0u) | (item.m_customData.Remove("ExtraSlotsEquippedSlot") ? 1u : 0u) | (item.m_customData.Remove("ExtraSlotsEquippedWeaponShield") ? 1u : 0u)) != 0;
		}

		private static void WarnForeignSlotItemPreserved(Player player, Inventory inventory, ItemData item, int expectedFullHeight)
		{
			//IL_0002: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			string foreignSlotPreservationWarningKey = GetForeignSlotPreservationWarningKey(item, item.m_gridPos);
			if (InventorySafety.ForeignSlotPreservationWarnings.Add(foreignSlotPreservationWarningKey))
			{
				string text = (IsLegacyExtraSlotsItem(item) ? "ExtraSlots" : "foreign inventory");
				string text2 = (ShouldPreserveForeignSlotHeight(item, expectedFullHeight) ? "outside the InventorySlots grid" : ((GetInventoryCellKind(player, inventory, item.m_gridPos) == InventoryCellKind.RegularLocked) ? "in a locked hidden inventory row" : "in a foreign slot position"));
				Log.LogWarning((object)(text + " slot item " + GetForeignSlotItemName(item) + " is " + text2 + " at " + FormatGridPos(item.m_gridPos) + ". No regular inventory cell was free, so InventorySlots is preserving the item in place. Free inventory space and reconnect to let it recover."));
			}
		}

		private static string GetForeignSlotPreservationWarningKey(ItemData item, Vector2i pos)
		{
			//IL_000b: 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)
			return $"{GetForeignSlotItemName(item)}|{pos.x},{pos.y}";
		}

		private static string GetForeignSlotItemName(ItemData item)
		{
			string itemPrefabName = GetItemPrefabName(item);
			object obj;
			if (string.IsNullOrWhiteSpace(itemPrefabName))
			{
				obj = item.m_shared?.m_name;
				if (obj == null)
				{
					return "<unknown>";
				}
			}
			else
			{
				obj = itemPrefabName;
			}
			return (string)obj;
		}

		private static string FormatGridPos(Vector2i pos)
		{
			//IL_0005: 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)
			return $"({pos.x},{pos.y})";
		}

		private static bool ShouldBlockGlobalHotkeys(Player? player = null)
		{
			if ((Object)(object)player != (Object)null && (player.m_isLoading || ((Character)player).InCutscene()))
			{
				return true;
			}
			if (IsCraftingSearchFocused())
			{
				return true;
			}
			if ((Object)(object)Chat.instance != (Object)null && !IsUnityNull((Object?)(object)Chat.instance) && Chat.instance.HasFocus())
			{
				return true;
			}
			if (Console.IsVisible() || TextInput.IsVisible() || Menu.IsVisible() || Minimap.IsOpen() || Minimap.InTextInput() || StoreGui.IsVisible() || GameCamera.InFreeFly())
			{
				return true;
			}
			if ((Object)(object)TextViewer.instance != (Object)null && !IsUnityNull((Object?)(object)TextViewer.instance) && TextViewer.instance.IsVisible())
			{
				return true;
			}
			if ((Object)(object)ZNet.instance != (Object)null && !IsUnityNull((Object?)(object)ZNet.instance))
			{
				return ZNet.instance.InPasswordDialog();
			}
			return false;
		}

		private static bool IsInventoryContainerTooltipSource(UITooltip tooltip)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)tooltip == (Object)null)
			{
				return false;
			}
			Transform transform = ((Component)tooltip).transform;
			if (!IsTooltipSourceInGrid(transform, instance.m_playerGrid) && !IsTooltipSourceInGrid(transform, instance.m_containerGrid))
			{
				return IsTooltipSourceInInventorySlotsPanel(transform);
			}
			return true;
		}

		private static bool IsTooltipSourceInGrid(Transform source, InventoryGrid? grid)
		{
			if ((Object)(object)source != (Object)null && (Object)(object)grid != (Object)null && !IsUnityNull((Object?)(object)grid) && (Object)(object)((Component)grid).transform != (Object)null)
			{
				if (!((Object)(object)source == (Object)(object)((Component)grid).transform))
				{
					return source.IsChildOf(((Component)grid).transform);
				}
				return true;
			}
			return false;
		}

		private static bool IsTooltipSourceInInventorySlotsPanel(Transform? source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return false;
			}
			foreach (RectTransform item in InventoryPanels.QuickSlotPanels.Values.Concat(InventoryPanels.CustomSlotPanels.Values))
			{
				if ((Object)(object)item != (Object)null && !IsUnityNull((Object?)(object)item) && ((Object)(object)source == (Object)(object)item || source.IsChildOf((Transform)(object)item)))
				{
					return true;
				}
			}
			return false;
		}

		private static void RefreshCraftingHoverTooltipBackground()
		{
			if ((Object)(object)CraftingUi.HoverTooltip != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltip))
			{
				ApplyCraftingHoverTooltipBackground(CraftingUi.HoverTooltip.GetComponent<Image>());
			}
			RefreshInventoryContainerHoverTooltipBackground();
		}

		private static void RefreshInventoryContainerHoverTooltipBackground()
		{
			if ((Object)(object)_inventoryHoverTooltip != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltip))
			{
				ApplyInventoryContainerCustomTooltipBackground(_inventoryHoverTooltip.GetComponent<Image>(), GetInventoryHoverCustomTooltipBackgroundAlpha(GetInventoryHoverTooltipActiveSource()));
			}
		}

		private static void ApplyCraftingHoverTooltipBackground(Image? background)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)background == (Object)null) && !IsUnityNull((Object?)(object)background))
			{
				background.sprite = GetSolidUiSprite();
				((Graphic)background).color = new Color(0f, 0f, 0f, GetCraftingHoverTooltipBackgroundAlpha());
				((Graphic)background).raycastTarget = false;
			}
		}

		private static float GetCraftingHoverTooltipBackgroundAlpha()
		{
			return Mathf.Clamp01((_craftingHoverTooltipBackgroundAlpha != null) ? _craftingHoverTooltipBackgroundAlpha.Value : 0.9f);
		}

		private static float GetInventoryContainerHoverTooltipBackgroundAlpha()
		{
			return Mathf.Clamp01((_inventoryContainerHoverTooltipBackgroundAlpha != null) ? _inventoryContainerHoverTooltipBackgroundAlpha.Value : 0.9f);
		}

		private static float GetInventoryHoverCustomTooltipBackgroundAlpha(UITooltip? tooltip)
		{
			if (!HoverTooltipSourceCore.UsesCraftingHoverTooltipBackgroundAlpha(ResolveHoverTooltipSourceKind(tooltip)))
			{
				return GetInventoryContainerHoverTooltipBackgroundAlpha();
			}
			return GetCraftingHoverTooltipBackgroundAlpha();
		}

		private static UITooltip? GetInventoryHoverTooltipActiveSource()
		{
			if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)null && !IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource))
			{
				return _inventorySlotsOwnedHoverTooltipSource;
			}
			if ((Object)(object)_inventoryContainerHoverTooltipSource != (Object)null && !IsUnityNull((Object?)(object)_inventoryContainerHoverTooltipSource))
			{
				return _inventoryContainerHoverTooltipSource;
			}
			if (!((Object)(object)UITooltip.m_current != (Object)null) || IsUnityNull((Object?)(object)UITooltip.m_current))
			{
				return null;
			}
			return UITooltip.m_current;
		}

		private static HoverTooltipSourceKind ResolveHoverTooltipSourceKind(UITooltip? tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip))
			{
				return HoverTooltipSourceKind.None;
			}
			Transform transform = ((Component)tooltip).transform;
			return HoverTooltipSourceCore.Classify(IsInventoryContainerTooltipSource(tooltip), IsInventorySlotsCraftingTooltipSource(transform), IsVneiCraftingTransform(transform));
		}

		private static HoverTooltipSourceKind ResolveHoverTooltipSourceKind(Transform? source)
		{
			if (!((Object)(object)source == (Object)null) && !IsUnityNull((Object?)(object)source))
			{
				return HoverTooltipSourceCore.Classify(inventoryContainer: false, IsInventorySlotsCraftingTooltipSource(source), IsVneiCraftingTransform(source));
			}
			return HoverTooltipSourceKind.None;
		}

		private static bool IsInventorySlotsCraftingTooltipSource(Transform? source)
		{
			if ((Object)(object)source != (Object)null && !IsUnityNull((Object?)(object)source))
			{
				if (!IsOwnedCraftingUiTransform(source))
				{
					return HasInventorySlotsCraftingTooltipRoot(source);
				}
				return true;
			}
			return false;
		}

		private static bool ShouldUseInventorySlotsOwnedHoverTooltip(UITooltip? tooltip)
		{
			return HoverTooltipSourceCore.UsesInventorySlotsOwnedHoverTooltip(ResolveHoverTooltipSourceKind(tooltip));
		}

		private static bool ShouldSuppressVanillaHoverStart(UITooltip? tooltip)
		{
			return HoverTooltipSourceCore.SuppressesVanillaHoverStart(ResolveHoverTooltipSourceKind(tooltip));
		}

		private static bool ShouldSuppressVanillaLateUpdate(UITooltip? tooltip)
		{
			return HoverTooltipSourceCore.SuppressesVanillaLateUpdate(ResolveHoverTooltipSourceKind(tooltip));
		}

		internal static void ApplyHudHealthBarLengthScaling(ref float size)
		{
			ApplyHudStatBarLengthScaling(ref size, 32f);
		}

		internal static void ApplyHudStaminaBarLengthScaling(ref float size)
		{
			ApplyHudStatBarLengthScaling(ref size, 32f);
		}

		internal static void ApplyHudEitrBarLengthScaling(ref float size)
		{
			ApplyHudStatBarLengthScaling(ref size, 32f);
		}

		internal static void ApplyHudAdrenalineBarLengthScaling(ref float size)
		{
			ApplyHudStatBarLengthScaling(ref size, 64f);
		}

		internal static void ApplyHudFoodBarLengthScaling(Hud hud, Player player)
		{
			if (ShouldUseLogarithmicHudStatBarLengthScaling() && !((Object)(object)hud == (Object)null) && !((Object)(object)player == (Object)null))
			{
				float scaledHudStatBarLength = GetScaledHudStatBarLength(player.GetBaseFoodHP(), 32f);
				float num = Mathf.Ceil(GetScaledHudStatBarLength(((Character)player).GetMaxHealth(), 32f));
				hud.m_foodBaseBar.SetSizeWithCurrentAnchors((Axis)0, scaledHudStatBarLength);
				hud.m_foodBarRoot.SetSizeWithCurrentAnchors((Axis)0, num);
			}
		}

		private static void ApplyHudStatBarLengthScaling(ref float size, float pixelsPer25)
		{
			if (ShouldUseLogarithmicHudStatBarLengthScaling() && !(size <= 0f) && !(pixelsPer25 <= 0f))
			{
				float value = size * 25f / pixelsPer25;
				size = GetScaledHudStatBarLength(value, pixelsPer25);
			}
		}

		private static float GetScaledHudStatBarLength(float value, float pixelsPer25)
		{
			return GetLogarithmicHudStatBarValue(value) / 25f * pixelsPer25;
		}

		private static float GetLogarithmicHudStatBarValue(float value)
		{
			if (value <= 100f)
			{
				return Mathf.Max(0f, value);
			}
			return 100f + 100f * Mathf.Log(1f + (value - 100f) / 100f);
		}

		private static bool ShouldUseLogarithmicHudStatBarLengthScaling()
		{
			if (_playerStatBarLengthScaling != null)
			{
				return _playerStatBarLengthScaling.Value == PlayerStatBarLengthScaling.Logarithmic;
			}
			return false;
		}

		private static void UpdateInventoryActionPanels(InventoryGrid playerGrid, Player player, Vector3 gridOrigin, int viewportRows)
		{
			//IL_0025: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || !InventoryGui.IsVisible())
			{
				HideInventoryActionPanels();
				return;
			}
			UpdateContainerActionPanel(instance);
			UpdateInventorySortPanel(instance, playerGrid, player, gridOrigin, viewportRows);
			UpdateInventoryTrashPanel(instance, playerGrid, player, gridOrigin, viewportRows);
			UpdateCurrencyPocketPanel(instance, playerGrid, gridOrigin);
			RaiseInventorySortPanel();
		}

		private static void UpdateContainerActionPanel(InventoryGui gui)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: 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_02b3: 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_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Expected O, but got Unknown
			if ((Object)(object)gui.m_currentContainer == (Object)null || (Object)(object)gui.m_takeAllButton == (Object)null || (Object)(object)gui.m_stackAllButton == (Object)null)
			{
				RestoreContainerActionButtonLayout();
				HideContainerActionButtons();
				return;
			}
			Container currentContainer = gui.m_currentContainer;
			Transform parent = ((Component)gui.m_takeAllButton).transform.parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			Transform parent2 = ((Component)gui.m_stackAllButton).transform.parent;
			RectTransform val2 = (RectTransform)(object)((parent2 is RectTransform) ? parent2 : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				RestoreContainerActionButtonLayout();
				HideContainerActionButtons();
				return;
			}
			CaptureRectTransformSnapshot(ref InventoryPanels.TakeAllButtonOriginal, (RectTransform)((Component)gui.m_takeAllButton).transform);
			CaptureRectTransformSnapshot(ref InventoryPanels.StackAllButtonOriginal, (RectTransform)((Component)gui.m_stackAllButton).transform);
			RestoreContainerActionButtonLayout();
			Button takeAllButton = gui.m_takeAllButton;
			RectTransform val3 = (RectTransform)((Component)gui.m_takeAllButton).transform;
			RectTransform val4 = (RectTransform)((Component)gui.m_stackAllButton).transform;
			ContainerAccessMode containerAccessMode = GetContainerAccessMode(currentContainer, allowLocalWithoutZNetView: true);
			bool flag = containerAccessMode == ContainerAccessMode.DirectOwner;
			bool flag2 = containerAccessMode != ContainerAccessMode.Unavailable;
			SetActionButtonLabel(gui.m_takeAllButton, LocalizeUi("$inventoryslots_button_take_all", "Take all"));
			SetActionButtonLabel(gui.m_stackAllButton, LocalizeUi("$inventoryslots_button_place_stacks", "Place stacks"));
			if (!flag)
			{
				HideContainerMutationButtons();
				InventoryPanels.ContainerSortButton = EnsureContainerSortButton(val4, takeAllButton, GetContainerSortButtonSize(gui), Vector2.op_Implicit(ContainerSortButtonFixedOffset));
				SetButtonActive(InventoryPanels.ContainerSortButton, flag2);
				SetButtonInteractable(InventoryPanels.ContainerSortButton, flag2 && !IsContainerSortRequestPending(currentContainer));
				return;
			}
			AlignContainerActionButtonRows(val3, val4);
			float buttonHeight = Mathf.Clamp(Mathf.Max(GetRectHeight(val3), GetRectHeight(val4)), 24f, 36f);
			Vector3 zero = Vector3.zero;
			float rectWidth = GetRectWidth(val3);
			float rectWidth2 = GetRectWidth(val4);
			InventoryPanelRuntimeState inventoryPanels = InventoryPanels;
			string label = LocalizeUi("$inventoryslots_button_place_all", "Place all");
			object obj = <>c.<>9__983_0;
			if (obj == null)
			{
				UnityAction val5 = delegate
				{
					StoreAllToCurrentContainer(Player.m_localPlayer);
				};
				<>c.<>9__983_0 = val5;
				obj = (object)val5;
			}
			inventoryPanels.ContainerStoreAllButton = EnsureActionButton(val, takeAllButton, "InventorySlots_StoreAllButton", label, (UnityAction)obj);
			LayoutButtonPair(val3, InventoryPanels.ContainerStoreAllButton, rectWidth, buttonHeight, 4f, addedButtonOnRight: true, zero);
			InventoryPanelRuntimeState inventoryPanels2 = InventoryPanels;
			Button stackAllButton = gui.m_stackAllButton;
			string label2 = LocalizeUi("$inventoryslots_button_take_stacks", "Take stacks");
			object obj2 = <>c.<>9__983_1;
			if (obj2 == null)
			{
				UnityAction val6 = delegate
				{
					RestockFromCurrentContainer(Player.m_localPlayer);
				};
				<>c.<>9__983_1 = val6;
				obj2 = (object)val6;
			}
			inventoryPanels2.ContainerRestockButton = EnsureActionButton(val2, stackAllButton, "InventorySlots_RestockButton", label2, (UnityAction)obj2);
			LayoutButtonPair(val4, InventoryPanels.ContainerRestockButton, rectWidth2, buttonHeight, 4f, addedButtonOnRight: false, zero);
			InventoryPanels.ContainerSortButton = EnsureContainerSortButton(val4, takeAllButton, buttonHeight, zero + Vector2.op_Implicit(ContainerSortButtonFixedOffset));
			SetButtonActive(InventoryPanels.ContainerStoreAllButton, active: true);
			SetButtonActive(InventoryPanels.ContainerRestockButton, active: true);
			SetButtonActive(InventoryPanels.ContainerSortButton, active: true);
			SetButtonInteractable(InventoryPanels.ContainerStoreAllButton, interactable: true);
			SetButtonInteractable(InventoryPanels.ContainerRestockButton, interactable: true);
			SetButtonInteractable(InventoryPanels.ContainerSortButton, interactable: true);
		}

		private static void AlignContainerActionButtonRows(RectTransform takeAllRect, RectTransform stackAllRect)
		{
			//IL_0014: 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_0031: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)takeAllRect == (Object)null) && !((Object)(object)stackAllRect == (Object)null))
			{
				float num = Mathf.Max(((Transform)takeAllRect).localPosition.y, ((Transform)stackAllRect).localPosition.y);
				((Transform)takeAllRect).localPosition = new Vector3(((Transform)takeAllRect).localPosition.x, num, ((Transform)takeAllRect).localPosition.z);
				((Transform)stackAllRect).localPosition = new Vector3(((Transform)stackAllRect).localPosition.x, num, ((Transform)stackAllRect).localPosition.z);
			}
		}

		private static void UpdateInventorySortPanel(InventoryGui gui, InventoryGrid playerGrid, Player player, Vector3 gridOrigin, int viewportRows)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			if ((Object)(object)playerGrid.m_gridRoot == (Object)null || (Object)(object)gui.m_takeAllButton == (Object)null)
			{
				SetActionPanelActive(InventoryPanels.InventorySortPanel, active: false);
				return;
			}
			InventoryPanels.InventorySortPanel = EnsureActionPanel(playerGrid.m_gridRoot, "InventorySlots_InventorySortPanel", InventoryPanels.InventorySortPanel);
			if ((Object)(object)InventoryPanels.InventorySortPanel == (Object)null)
			{
				return;
			}
			float containerSortButtonSize = GetContainerSortButtonSize(gui);
			float num = containerSortButtonSize;
			int num2 = 1;
			float num3 = (float)num2 * num + (float)Mathf.Max(0, num2 - 1) * 6f;
			InventoryPanels.InventorySortPanel.sizeDelta = new Vector2(num3, containerSortButtonSize);
			if (((Transform)InventoryPanels.InventorySortPanel).localScale != Vector3.one)
			{
				((Transform)InventoryPanels.InventorySortPanel).localScale = Vector3.one;
			}
			if (((Transform)InventoryPanels.InventorySortPanel).localRotation != Quaternion.identity)
			{
				((Transform)InventoryPanels.InventorySortPanel).localRotation = Quaternion.identity;
			}
			Vector3 val = gridOrigin + new Vector3(8f * playerGrid.m_elementSpace + 1f, (float)(-Mathf.Max(1, viewportRows)) * playerGrid.m_elementSpace + containerSortButtonSize, 0f) + Vector2.op_Implicit(InventorySortButtonFixedOffset);
			Vector3 val2 = ((Transform)InventoryPanels.InventorySortPanel).localPosition - val;
			if (((Vector3)(ref val2)).sqrMagnitude > 0.0001f)
			{
				((Transform)InventoryPanels.InventorySortPanel).localPosition = val;
			}
			DisableActionPanelChildren(InventoryPanels.InventorySortPanel);
			int index = 0;
			RectTransform? inventorySortPanel = InventoryPanels.InventorySortPanel;
			Button takeAllButton = gui.m_takeAllButton;
			object obj = <>c.<>9__985_0;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					SortPlayerInventory(Player.m_localPlayer);
				};
				<>c.<>9__985_0 = val3;
				obj = (object)val3;
			}
			LayoutActionButton(EnsureActionButton(inventorySortPanel, takeAllButton, "InventorySlots_PlayerSortButton", "S", (UnityAction)obj), index, num, containerSortButtonSize, 6f);
			SetActionPanelActive(InventoryPanels.InventorySortPanel, active: true);
		}

		private static void RaiseInventorySortPanel()
		{
			if (!((Object)(object)InventoryPanels.InventorySortPanel == (Object)null) && !IsUnityNull((Object?)(object)InventoryPanels.InventorySortPanel) && ((Component)InventoryPanels.InventorySortPanel).gameObject.activeInHierarchy && ((Transform)InventoryPanels.InventorySortPanel).GetSiblingIndex() != ((Transform)InventoryPanels.InventorySortPanel).parent.childCount - 1)
			{
				((Transform)InventoryPanels.InventorySortPanel).SetAsLastSibling();
			}
		}

		private static void UpdateCurrencyPocketPanel(InventoryGui gui, InventoryGrid playerGrid, Vector3 gridOrigin)
		{
			//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_0082: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!HasPlugin("Azumatt.CurrencyPocket") || (Object)(object)playerGrid.m_gridRoot == (Object)null)
			{
				return;
			}
			RectTransform val = FindCurrencyPocketPanel(gui, playerGrid);
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)((Transform)val).parent != (Object)(object)playerGrid.m_gridRoot)
				{
					((Transform)val).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
				}
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.pivot = new Vector2(0f, 1f);
				((Transform)val).localScale = Vector3.one;
				((Transform)val).localRotation = Quaternion.identity;
				int num = ((playerGrid.m_inventory != null) ? playerGrid.m_inventory.GetWidth() : playerGrid.m_width);
				float num2 = Mathf.Max(1f, playerGrid.m_elementSpace);
				float num3 = Mathf.Max(1f, GetRectHeight(val));
				int num4 = Mathf.Max(0, 3);
				float num5 = Mathf.Max(0f, (num2 - num3) * 0.5f);
				((Transform)val).localPosition = gridOrigin + new Vector3((float)Mathf.Max(1, num) * num2 + 6f, (float)(-num4) * num2 - num5, 0f);
				((Transform)val).SetAsLastSibling();
				((Component)val).gameObject.SetActive(true);
			}
		}

		private static RectTransform? FindCurrencyPocketPanel(InventoryGui gui, InventoryGrid playerGrid)
		{
			if ((Object)(object)InventoryPanels.CurrencyPocketPanel != (Object)null && !IsUnityNull((Object?)(object)InventoryPanels.CurrencyPocketPanel))
			{
				return InventoryPanels.CurrencyPocketPanel;
			}
			InventoryPanels.CurrencyPocketPanel = FindCurrencyPocketPanelUnder((Transform?)(object)playerGrid.m_gridRoot) ?? FindCurrencyPocketPanelUnder((Transform?)(object)gui.m_player) ?? FindCurrencyPocketPanelUnder((Transform?)(object)InventoryPanels.PlayerStatPanelHost);
			return InventoryPanels.CurrencyPocketPanel;
		}

		private static RectTransform? FindCurrencyPocketPanelUnder(Transform? parent)
		{
			if ((Object)(object)parent == (Object)null || IsUnityNull((Object?)(object)parent))
			{
				return null;
			}
			Transform val = parent.Find("CoinPocketUI");
			if (!((Object)(object)val != (Object)null) || IsUnityNull((Object?)(object)val))
			{
				return null;
			}
			return ((Component)val).GetComponent<RectTransform>();
		}

		private static RectTransform? LayoutActionButton(Button? button, int index, float buttonWidth, float buttonHeight, float gap)
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_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_0058: 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_006f: 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_007a: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			if ((Object)(object)button == (Object)null)
			{
				return null;
			}
			RectTransform val = (RectTransform)((Component)button).transform;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.sizeDelta = new Vector2(buttonWidth, buttonHeight);
			val.anchoredPosition = new Vector2((float)index * (buttonWidth + gap), 0f);
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			((Component)button).gameObject.SetActive(true);
			return val;
		}

		private static void LayoutButtonPair(RectTransform vanillaButton, Button? addedButton, float originalWidth, float buttonHeight, float gap, bool addedButtonOnRight, Vector3 offset)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_004d: 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_0054: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)vanillaButton == (Object)null) && !((Object)(object)addedButton == (Object)null))
			{
				RectTransform val = (RectTransform)((Component)addedButton).transform;
				CopyRectTransformFrame(vanillaButton, val);
				float num = Mathf.Max(1f, (originalWidth - gap) * 0.5f) * 1f;
				float num2 = (num + gap) * 0.5f;
				Vector3 val2 = ((Transform)vanillaButton).localPosition + offset;
				Vector3 localPosition = val2 + new Vector3(addedButtonOnRight ? (0f - num2) : num2, 0f, 0f);
				Vector3 localPosition2 = val2 + new Vector3(addedButtonOnRight ? num2 : (0f - num2), 0f, 0f);
				SetActionButtonTextAutoSize(((Component)vanillaButton).GetComponent<Button>());
				SetActionButtonTextAutoSize(addedButton);
				LayoutButtonRect(vanillaButton, num, buttonHeight, localPosition);
				LayoutButtonRect(val, num, buttonHeight, localPosition2);
			}
		}

		private static Button? EnsureContainerSortButton(RectTransform stackButton, Button template, float buttonHeight, Vector3 offset)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00cf: 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)
			Transform obj = ((stackButton != null) ? ((Transform)stackButton).parent : null);
			RectTransform val = (RectTransform)(((object)((obj is RectTransform) ? obj : null)) ?? ((object)/*isinst with value type is only supported in some contexts*/));
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			object obj2 = <>c.<>9__992_0;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					SortCurrentContainer(Player.m_localPlayer);
				};
				<>c.<>9__992_0 = val2;
				obj2 = (object)val2;
			}
			Button val3 = EnsureActionButton(val, template, "InventorySlots_SortButton", "S", (UnityAction)obj2);
			if ((Object)(object)val3 == (Object)null)
			{
				return null;
			}
			RectTransform val4 = (RectTransform)((Component)val3).transform;
			RectTransform val5 = (RectTransform)(((object)stackButton) ?? ((object)(RectTransform)((Component)template).transform));
			CopyRectTransformFrame(val5, val4);
			LayoutButtonRect(val4, buttonHeight, buttonHeight, ((Transform)val5).localPosition + new Vector3(GetRectWidth(val5) * 0.5f + 1f + buttonHeight * 0.5f, 0f, 0f) + offset);
			return val3;
		}

		private static float GetContainerSortButtonSize(InventoryGui gui)
		{
			RectTransform val = (RectTransform)(((Object)(object)gui.m_takeAllButton != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			RectTransform val2 = (RectTransform)(((Object)(object)gui.m_stackAllButton != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null)
			{
				return 32f;
			}
			float num = (((Object)(object)val != (Object)null) ? GetRectHeight(val) : 0f);
			float num2 = (((Object)(object)val2 != (Object)null) ? GetRectHeight(val2) : 0f);
			return Mathf.Clamp(Mathf.Max(num, num2), 24f, 36f);
		}

		private static void LayoutButtonRect(RectTransform rect, float width, float height, Vector3 localPosition)
		{
			//IL_0003: 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_0015: 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)
			rect.sizeDelta = new Vector2(width, height);
			((Transform)rect).localPosition = localPosition;
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		private static void CopyRectTransformFrame(RectTransform source, RectTransform target)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			target.anchorMin = source.anchorMin;
			target.anchorMax = source.anchorMax;
			target.pivot = source.pivot;
			target.offsetMin = source.offsetMin;
			target.offsetMax = source.offsetMax;
			((Transform)target).localScale = Vector3.one;
			((Transform)target).localRotation = Quaternion.identity;
			((Transform)target).localPosition = ((Transform)source).localPosition;
		}

		private static void DisableActionPanelChildren(RectTransform panel)
		{
			for (int i = 0; i < ((Transform)panel).childCount; i++)
			{
				Transform child = ((Transform)panel).GetChild(i);
				if (((Object)child).name.StartsWith("InventorySlots_", StringComparison.Ordinal))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		private static RectTransform? EnsureActionPanel(RectTransform parent, string name, RectTransform? cached)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_006d: 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_0097: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = cached;
			if ((Object)(object)val == (Object)null)
			{
				Transform obj = ((Transform)parent).Find(name);
				val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = (RectTransform)new GameObject(name, new Type[1] { typeof(RectTransform) }).transform;
			}
			if ((Object)(object)((Transform)val).parent != (Object)(object)parent)
			{
				((Transform)val).SetParent((Transform)(object)parent, false);
			}
			((Object)val).name = name;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			return val;
		}

		private static Button? EnsureActionButton(RectTransform panel, Button template, string name, string label, UnityAction action)
		{
			Transform val = ((Transform)panel).Find(name);
			Button val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Button>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = Object.Instantiate<Button>(template, (Transform)(object)panel, false);
				((Object)val2).name = name;
				(((Component)val2).gameObject.GetComponent<InventoryActionButtonMarker>() ?? ((Component)val2).gameObject.AddComponent<InventoryActionButtonMarker>()).Initialized = false;
			}
			InventoryActionButtonMarker inventoryActionButtonMarker = ((Component)val2).gameObject.GetComponent<InventoryActionButtonMarker>() ?? ((Component)val2).gameObject.AddComponent<InventoryActionButtonMarker>();
			if (!inventoryActionButtonMarker.Initialized)
			{
				((UnityEventBase)val2.onClick).RemoveAllListeners();
				((UnityEvent)val2.onClick).AddListener(action);
				inventoryActionButtonMarker.Initialized = true;
			}
			SetActionButtonLabel(val2, label);
			return val2;
		}

		private static void SetActionButtonLabel(Button button, string label)
		{
			InventoryActionButtonMarker inventoryActionButtonMarker = ((Component)button).gameObject.GetComponent<InventoryActionButtonMarker>() ?? ((Component)button).gameObject.AddComponent<InventoryActionButtonMarker>();
			string text = $"{label}|{_uiLocalizationVersion}";
			if (inventoryActionButtonMarker.AutoSizeInitialized && string.Equals(inventoryActionButtonMarker.LabelSignature, text, StringComparison.Ordinal))
			{
				return;
			}
			SetActionButtonTextAutoSize(button);
			TMP_Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				ApplyDefaultFontAsset(val);
				if (val.text != label)
				{
					val.text = label;
				}
			}
			Text[] componentsInChildren2 = ((Component)button).GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if (val2.text != label)
				{
					val2.text = label;
				}
			}
			inventoryActionButtonMarker.LabelSignature = text;
		}

		private static void SetActionButtonTextAutoSize(Button? button)
		{
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			InventoryActionButtonMarker inventoryActionButtonMarker = ((Component)button).gameObject.GetComponent<InventoryActionButtonMarker>() ?? ((Component)button).gameObject.AddComponent<InventoryActionButtonMarker>();
			if (!inventoryActionButtonMarker.AutoSizeInitialized)
			{
				TMP_Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
				foreach (TMP_Text obj in componentsInChildren)
				{
					ApplyDefaultFontAsset(obj);
					obj.enableAutoSizing = true;
					obj.fontSizeMin = 10f;
					obj.fontSizeMax = Mathf.Min(Mathf.Max(obj.fontSize, 14f), 16f);
					obj.alignment = (TextAlignmentOptions)514;
				}
				inventoryActionButtonMarker.AutoSizeInitialized = true;
			}
		}

		private static void SetActionPanelActive(RectTransform? panel, bool active)
		{
			if ((Object)(object)panel != (Object)null && ((Component)panel).gameObject.activeSelf != active)
			{
				((Component)panel).gameObject.SetActive(active);
			}
		}

		internal static void HideInventoryActionPanels()
		{
			SetActionPanelActive(InventoryPanels.InventorySortPanel, active: false);
			SetActionPanelActive(_inventoryTrashPanel, active: false);
			CloseInventoryTrashConfirmDialog();
			HideInventorySideHints();
			RestoreContainerActionButtonLayout();
			HideContainerActionButtons();
		}

		private static string CleanPrefabName(string name)
		{
			return InventorySlotsConfigCore.CleanPrefabName(name);
		}

		internal static Sprite? GetItemPrefabIcon(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(prefabName) : null);
			ItemDrop val2 = default(ItemDrop);
			if ((Object)(object)val != (Object)null && val.TryGetComponent<ItemDrop>(ref val2))
			{
				return val2.m_itemData.GetIcon();
			}
			val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(prefabName) : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			ItemDrop val3 = default(ItemDrop);
			if (val.TryGetComponent<ItemDrop>(ref val3))
			{
				return val3.m_itemData.GetIcon();
			}
			Piece val4 = default(Piece);
			if (val.TryGetComponent<Piece>(ref val4))
			{
				return val4.m_icon;
			}
			return null;
		}

		internal static Sprite? GetSkillIcon(int skillType)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			try
			{
				return ((Character)localPlayer).GetSkills().GetSkillDef((SkillType)skillType)?.m_icon;
			}
			catch
			{
				return null;
			}
		}

		private static void CaptureRectTransformSnapshot(ref RectTransformSnapshot? snapshot, RectTransform rect)
		{
			if (!((Object)(object)rect == (Object)null) && (snapshot == null || (Object)(object)snapshot.Rect != (Object)(object)rect))
			{
				snapshot = new RectTransformSnapshot(rect);
			}
		}

		private static void RestoreContainerActionButtonLayout()
		{
			InventoryPanels.TakeAllButtonOriginal?.Restore();
			InventoryPanels.StackAllButtonOriginal?.Restore();
		}

		private static void HideContainerActionButtons()
		{
			SetButtonActive(InventoryPanels.ContainerRestockButton, active: false);
			SetButtonActive(InventoryPanels.ContainerStoreAllButton, active: false);
			SetButtonActive(InventoryPanels.ContainerSortButton, active: false);
		}

		private static void HideContainerMutationButtons()
		{
			SetButtonActive(InventoryPanels.ContainerRestockButton, active: false);
			SetButtonActive(InventoryPanels.ContainerStoreAllButton, active: false);
		}

		private static void SetButtonActive(Button? button, bool active)
		{
			if ((Object)(object)button != (Object)null && ((Component)button).gameObject.activeSelf != active)
			{
				((Component)button).gameObject.SetActive(active);
			}
		}

		private static void SetButtonInteractable(Button? button, bool interactable)
		{
			if ((Object)(object)button != (Object)null && ((Selectable)button).interactable != interactable)
			{
				((Selectable)button).interactable = interactable;
			}
		}

		private static float GetRectWidth(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			Rect rect2 = rect.rect;
			if (((Rect)(ref rect2)).width > 0f)
			{
				rect2 = rect.rect;
				return ((Rect)(ref rect2)).width;
			}
			if (!(rect.sizeDelta.x > 0f))
			{
				return 120f;
			}
			return rect.sizeDelta.x;
		}

		private static float GetRectHeight(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			Rect rect2 = rect.rect;
			if (((Rect)(ref rect2)).height > 0f)
			{
				rect2 = rect.rect;
				return ((Rect)(ref rect2)).height;
			}
			if (!(rect.sizeDelta.y > 0f))
			{
				return 30f;
			}
			return rect.sizeDelta.y;
		}

		private static void EnsureClientStateLoaded()
		{
			if (InventoryClient.ClientStateLoaded)
			{
				return;
			}
			InventoryClient.ClientStateLoaded = true;
			InventoryClient.ClientState = new InventorySlotsClientState();
			if (!File.Exists(ClientStateFilePath))
			{
				SaveClientState();
				return;
			}
			try
			{
				IDeserializer deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
				InventoryClient.ClientState = deserializer.Deserialize<InventorySlotsClientState>(File.ReadAllText(ClientStateFilePath)) ?? new InventorySlotsClientState();
				NormalizeClientState();
			}
			catch (Exception ex)
			{
				InventoryClient.ClientState = new InventorySlotsClientState();
				Log.LogWarning((object)("Failed to load InventorySlots client state from " + ClientStateFilePath + ": " + ex.Message));
			}
		}

		private static void SaveClientState()
		{
			try
			{
				EnsureClientStateLoaded();
				NormalizeClientState();
				Directory.CreateDirectory(Path.GetDirectoryName(ClientStateFilePath));
				ISerializer serializer = new SerializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
				string text = ClientStateFilePath + ".tmp";
				File.WriteAllText(text, serializer.Serialize(InventoryClient.ClientState));
				if (File.Exists(ClientStateFilePath))
				{
					File.Delete(ClientStateFilePath);
				}
				File.Move(text, ClientStateFilePath);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to save InventorySlots client state: " + ex.Message));
			}
		}

		private static InventorySlotsClientPlayerState? GetClientPlayerState(string playerId, bool create)
		{
			EnsureClientStateLoaded();
			if (InventoryClient.ClientState.Players.TryGetValue(playerId, out InventorySlotsClientPlayerState value))
			{
				return value;
			}
			if (!create)
			{
				return null;
			}
			value = new InventorySlotsClientPlayerState();
			InventoryClient.ClientState.Players[playerId] = value;
			return value;
		}

		private static void NormalizeClientState()
		{
			InventoryClient.ClientState = ClientStateCore.Normalize(InventoryClient.ClientState);
		}

		internal static void RestoreContainerPanelPosition()
		{
			//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_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_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)InventoryPanels.TrackedContainerPanel != (Object)null && InventoryPanels.ContainerPanelBasePositionSet && !IsUnityNull((Object?)(object)InventoryPanels.TrackedContainerPanel))
			{
				((Transform)InventoryPanels.TrackedContainerPanel).localPosition = InventoryPanels.ContainerPanelBasePosition;
			}
			InventoryPanels.TrackedContainerPanel = null;
			InventoryPanels.ContainerPanelBasePosition = Vector3.zero;
			InventoryPanels.ContainerPanelAppliedOffset = Vector3.zero;
			InventoryPanels.ContainerPanelBasePositionSet = false;
		}

		internal static void RestoreContainerWeightPanelPosition()
		{
			//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_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)InventoryPanels.TrackedContainerWeightPanel != (Object)null && InventoryPanels.ContainerWeightPanelBasePositionSet && !IsUnityNull((Object?)(object)InventoryPanels.TrackedContainerWeightPanel))
			{
				((Transform)InventoryPanels.TrackedContainerWeightPanel).localPosition = InventoryPanels.ContainerWeightPanelBasePosition;
			}
			InventoryPanels.TrackedContainerWeightPanel = null;
			InventoryPanels.ContainerWeightPanelBasePosition = Vector3.zero;
			InventoryPanels.ContainerWeightPanelAppliedYOffset = 0f;
			InventoryPanels.ContainerWeightPanelBasePositionSet = false;
		}

		private static void UpdateContainerPanelPosition(int viewportRows, float elementSpace)
		{
			//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_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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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)
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_container == (Object)null)
			{
				RestoreContainerPanelPosition();
				return;
			}
			RectTransform container = instance.m_container;
			if (!((Component)container).gameObject.activeSelf)
			{
				RestoreContainerPanelPosition();
				return;
			}
			if ((Object)(object)InventoryPanels.TrackedContainerPanel != (Object)(object)container)
			{
				InventoryPanels.TrackedContainerPanel = container;
				InventoryPanels.ContainerPanelBasePosition = ((Transform)container).localPosition;
				InventoryPanels.ContainerPanelAppliedOffset = Vector3.zero;
				InventoryPanels.ContainerPanelBasePositionSet = true;
			}
			else if (InventoryPanels.ContainerPanelBasePositionSet)
			{
				InventoryPanels.ContainerPanelBasePosition = ((Transform)container).localPosition - InventoryPanels.ContainerPanelAppliedOffset;
			}
			float num = (float)Mathf.Max(0, viewportRows - 4) * Mathf.Max(1f, elementSpace);
			float num2 = 1f;
			if ((Object)(object)instance.m_player != (Object)null)
			{
				num2 = ((InventoryPanels.ContainerPanelBasePosition.y >= ((Transform)instance.m_player).localPosition.y) ? 1f : (-1f));
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(0f, num2 * num, 0f);
			((Transform)container).localPosition = InventoryPanels.ContainerPanelBasePosition + val;
			InventoryPanels.ContainerPanelAppliedOffset = val;
		}

		private static void UpdateContainerWeightPanelPosition()
		{
			//IL_008a: 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_00f6: 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_010b: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_container == (Object)null || (Object)(object)instance.m_currentContainer == (Object)null || (Object)(object)instance.m_containerWeight == (Object)null || !((Component)instance.m_container).gameObject.activeSelf)
			{
				RestoreContainerWeightPanelPosition();
				return;
			}
			RectTransform containerWeightPanelRoot = GetContainerWeightPanelRoot(instance);
			if ((Object)(object)containerWeightPanelRoot == (Object)null)
			{
				RestoreContainerWeightPanelPosition();
				return;
			}
			if ((Object)(object)InventoryPanels.TrackedContainerWeightPanel != (Object)(object)containerWeightPanelRoot)
			{
				InventoryPanels.TrackedContainerWeightPanel = containerWeightPanelRoot;
				InventoryPanels.ContainerWeightPanelBasePosition = ((Transform)containerWeightPanelRoot).localPosition;
				InventoryPanels.ContainerWeightPanelAppliedYOffset = 0f;
				InventoryPanels.ContainerWeightPanelBasePositionSet = true;
			}
			else if (InventoryPanels.ContainerWeightPanelBasePositionSet)
			{
				InventoryPanels.ContainerWeightPanelBasePosition = ((Transform)containerWeightPanelRoot).localPosition - new Vector3(0f, InventoryPanels.ContainerWeightPanelAppliedYOffset, 0f);
			}
			float num = 200f;
			((Transform)containerWeightPanelRoot).localPosition = InventoryPanels.ContainerWeightPanelBasePosition + new Vector3(0f, num, 0f);
			InventoryPanels.ContainerWeightPanelAppliedYOffset = num;
		}

		private static bool UpdateEquipmentSlotElementState(Element element, Player player, Inventory inventory, SlotDefinition slot, Vector2i pos)
		{
			//IL_000d: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			if (slot.Kind == SlotKind.Quick || inventory == null || IsOutOfBounds(inventory, pos))
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(pos.x, pos.y);
			if (itemAt?.m_shared == null)
			{
				ResetEquipmentSlotTooltipCache(element);
				if ((Object)(object)element.m_tooltip != (Object)null)
				{
					element.m_tooltip.m_topic = "";
					element.m_tooltip.m_text = "";
				}
				if ((Object)(object)element.m_equiped != (Object)null)
				{
					((Behaviour)element.m_equiped).enabled = false;
				}
				return false;
			}
			element.m_used = true;
			UpdateEquipmentSlotTooltip(element, itemAt);
			if ((Object)(object)element.m_equiped != (Object)null)
			{
				((Behaviour)element.m_equiped).enabled = IsSlotItemEquippedForDisplay(player, itemAt, slot);
			}
			return true;
		}

		private static void UpdateEquipmentSlotTooltip(Element element, ItemData item)
		{
			if ((Object)(object)element?.m_tooltip == (Object)null || item?.m_shared == null)
			{
				return;
			}
			InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
			string equipmentSlotTooltipSignature = GetEquipmentSlotTooltipSignature(item);
			bool flag = ShouldForceJewelcraftingEquipmentTooltipRefresh(item);
			if ((Object)(object)inventoryGridElementUiCache != (Object)null && !flag && string.Equals(inventoryGridElementUiCache.EquipmentTooltipSignature, equipmentSlotTooltipSignature, StringComparison.Ordinal) && !string.IsNullOrWhiteSpace(element.m_tooltip.m_text))
			{
				return;
			}
			try
			{
				InventoryGui instance = InventoryGui.instance;
				if ((Object)(object)instance?.m_playerGrid != (Object)null)
				{
					instance.m_playerGrid.CreateItemTooltip(item, element.m_tooltip);
					if (string.IsNullOrWhiteSpace(element.m_tooltip.m_text))
					{
						SetDirectEquipmentSlotTooltip(element, item);
					}
					if ((Object)(object)inventoryGridElementUiCache != (Object)null)
					{
						inventoryGridElementUiCache.EquipmentTooltipSignature = equipmentSlotTooltipSignature;
					}
					return;
				}
			}
			catch (Exception)
			{
			}
			SetDirectEquipmentSlotTooltip(element, item);
			if ((Object)(object)inventoryGridElementUiCache != (Object)null)
			{
				inventoryGridElementUiCache.EquipmentTooltipSignature = equipmentSlotTooltipSignature;
			}
		}

		private static bool ShouldForceJewelcraftingEquipmentTooltipRefresh(ItemData item)
		{
			if (HasJewelcraftingActive && TryGetJewelcraftingGemApi(out JewelcraftingGemApi api) && api != null)
			{
				return api.HasSocketContainer(item);
			}
			return false;
		}

		private static void SetDirectEquipmentSlotTooltip(Element element, ItemData item)
		{
			//IL_006d: 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)
			if (!((Object)(object)element.m_tooltip == (Object)null) && item?.m_shared != null)
			{
				EnsureTooltipPrefab(element.m_tooltip);
				element.m_tooltip.Set(item.m_shared.m_name, item.GetTooltip(-1), ((Object)(object)InventoryGui.instance?.m_playerGrid != (Object)null) ? InventoryGui.instance.m_playerGrid.m_tooltipAnchor : null, default(Vector2));
			}
		}

		internal static void EnsureInventoryGridItemTooltipText(ItemData item, UITooltip tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip) || item?.m_shared == null || !string.IsNullOrWhiteSpace(tooltip.m_text))
			{
				return;
			}
			string tooltip2 = item.GetTooltip(-1);
			if (!string.IsNullOrWhiteSpace(tooltip2))
			{
				EnsureTooltipPrefab(tooltip);
				if (string.IsNullOrWhiteSpace(tooltip.m_topic))
				{
					tooltip.m_topic = item.m_shared.m_name;
				}
				tooltip.m_text = tooltip2;
			}
		}

		private static void ResetEquipmentSlotTooltipCache(Element element)
		{
			InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
			if ((Object)(object)inventoryGridElementUiCache != (Object)null)
			{
				inventoryGridElementUiCache.EquipmentTooltipSignature = "";
			}
		}

		private static string GetEquipmentSlotTooltipSignature(ItemData item)
		{
			int num = Mathf.RoundToInt(item.m_durability * 1000f);
			int itemCustomDataOrderIndependentHash = GetItemCustomDataOrderIndependentHash(item);
			return string.Format("{0}|{1}|{2}|{3}|{4}|{5}|{6}|{7}|{8}|{9}", GetItemPrefabName(item), item.m_shared?.m_name ?? "", item.m_gridPos.x, item.m_gridPos.y, item.m_quality, item.m_variant, item.m_stack, num, item.m_equipped, itemCustomDataOrderIndependentHash);
		}

		private static int GetItemCustomDataOrderIndependentHash(ItemData item)
		{
			Dictionary<string, string> customData = item.m_customData;
			if (customData == null || customData.Count <= 0)
			{
				return 0;
			}
			int num = item.m_customData.Count;
			foreach (KeyValuePair<string, string> customDatum in item.m_customData)
			{
				int num2 = 17;
				num2 = num2 * 31 + StringComparer.Ordinal.GetHashCode(customDatum.Key ?? "");
				num2 = num2 * 31 + StringComparer.Ordinal.GetHashCode(customDatum.Value ?? "");
				num ^= num2 + -1640531527 + (num << 6) + (num >> 2);
			}
			return num;
		}

		private static bool IsSlotItemEquippedForDisplay(Player player, ItemData item, SlotDefinition slot)
		{
			if (item == null || slot.Kind == SlotKind.Quick)
			{
				return false;
			}
			if (slot.Kind == SlotKind.CustomEquipment)
			{
				return IsInventorySlotsCustomEquipped(item);
			}
			try
			{
				return ((Humanoid)player).IsItemEquiped(item) || item.m_equipped;
			}
			catch
			{
				return item.m_equipped;
			}
		}

		private static RectTransform? GetContainerWeightPanelRoot(InventoryGui gui)
		{
			if ((Object)(object)gui.m_containerWeight == (Object)null)
			{
				return null;
			}
			RectTransform component = ((Component)gui.m_containerWeight).GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			if ((Object)(object)gui.m_container == (Object)null || !gui.m_containerWeight.transform.IsChildOf((Transform)(object)gui.m_container))
			{
				return component;
			}
			RectTransform result = component;
			Transform val = gui.m_containerWeight.transform;
			while ((Object)(object)val.parent != (Object)null && (Object)(object)val.parent != (Object)(object)gui.m_container)
			{
				val = val.parent;
				RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if (val2 != null)
				{
					result = val2;
				}
			}
			return result;
		}

		internal static bool HandleFavoriteClick(InventoryGrid grid, UIInputHandler clickHandler, bool leftClick)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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)
			if (!ShouldHandleFavoriteClick(grid))
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null || grid.m_inventory != inventory)
			{
				return true;
			}
			Vector2i buttonPos = grid.GetButtonPos(((Component)clickHandler).gameObject);
			if (buttonPos.x < 0 || buttonPos.y < 0 || IsOutOfBounds(inventory, buttonPos))
			{
				return true;
			}
			if (!leftClick || !CanFavoriteSlot(localPlayer, inventory, buttonPos))
			{
				return true;
			}
			ToggleFavoriteSlot(localPlayer, buttonPos);
			return false;
		}

		private static bool ShouldHandleFavoriteClick(InventoryGrid grid)
		{
			if ((Object)(object)grid == (Object)null || (Object)(object)InventoryGui.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer.m_isLoading || ((Character)localPlayer).IsTeleporting())
			{
				return false;
			}
			if ((Object)(object)InventoryGui.instance.m_dragGo != (Object)null)
			{
				return false;
			}
			if ((Object)(object)grid != (Object)(object)InventoryGui.instance.m_playerGrid)
			{
				return false;
			}
			return IsFavoriteModifierHeld();
		}

		private static bool IsFavoriteModifierHeld()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (_favoriteModifierKey == null || !IsShortcutHeldAllowingAltPair(_favoriteModifierKey.Value))
			{
				return IsControllerHotkeyHeld(_controllerFavoriteModifierButton);
			}
			return true;
		}

		internal static bool ShouldSuppressVanillaHotbarItemUse(Player player, int index)
		{
			//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_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_004b: 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)
			if ((Object)(object)player != (Object)(object)Player.m_localPlayer || _quickSlotHotkeys == null || !TryGetHotbarKeyCode(index, out var keyCode))
			{
				return false;
			}
			ConfigEntry<KeyboardShortcut>[] quickSlotHotkeys = _quickSlotHotkeys;
			for (int i = 0; i < quickSlotHotkeys.Length; i++)
			{
				KeyboardShortcut value = quickSlotHotkeys[i].Value;
				if (((KeyboardShortcut)(ref value)).MainKey == keyCode && ((KeyboardShortcut)(ref value)).Modifiers.Any() && AreShortcutModifiersHeldAllowingAltPair(value) && IsShortcutMainKeyDownAllowingAltPair(value))
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryGetHotbarKeyCode(int index, out KeyCode keyCode)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected I4, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			keyCode = (KeyCode)(int)(index switch
			{
				1 => 49, 
				2 => 50, 
				3 => 51, 
				4 => 52, 
				5 => 53, 
				6 => 54, 
				7 => 55, 
				8 => 56, 
				_ => 0, 
			});
			return (int)keyCode != 0;
		}

		private static bool IsShortcutDownAllowingAltPair(KeyboardShortcut shortcut)
		{
			//IL_0002: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && AreShortcutModifiersHeldAllowingAltPair(shortcut))
			{
				return IsShortcutMainKeyDownAllowingAltPair(shortcut);
			}
			return false;
		}

		private static bool IsShortcutHeldAllowingAltPair(KeyboardShortcut shortcut)
		{
			//IL_0002: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0 || !AreShortcutModifiersHeldAllowingAltPair(shortcut))
			{
				return false;
			}
			return IsShortcutMainKeyHeldAllowingAltPair(shortcut);
		}

		private static bool AreShortcutModifiersHeldAllowingAltPair(KeyboardShortcut shortcut)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if (!IsShortcutModifierHeldAllowingAltPair(modifier))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsShortcutModifierHeldAllowingAltPair(KeyCode key)
		{
			//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_0008: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (key - 307 <= 1)
			{
				if (!Input.GetKey((KeyCode)308))
				{
					return Input.GetKey((KeyCode)307);
				}
				return true;
			}
			return Input.GetKey(key);
		}

		private static bool IsShortcutMainKeyHeldAllowingAltPair(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0010: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			if (mainKey - 307 <= 1)
			{
				if (!Input.GetKey((KeyCode)308))
				{
					return Input.GetKey((KeyCode)307);
				}
				return true;
			}
			return Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey);
		}

		private static bool IsShortcutMainKeyDownAllowingAltPair(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0010: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			if (mainKey - 307 <= 1)
			{
				if (!Input.GetKeyDown((KeyCode)308))
				{
					return Input.GetKeyDown((KeyCode)307);
				}
				return true;
			}
			return Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey);
		}

		private static bool CanFavoriteSlot(Player player, Inventory inventory, Vector2i pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return InventoryActionCellPolicyCore.CanFavoriteSlot(GetInventoryCellKind(player, inventory, pos));
		}

		private static void ToggleFavoriteSlot(Player player, Vector2i pos)
		{
			//IL_000b: 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)
			EnsureFavoritesLoaded(player);
			if (!FavoriteSlots.Add(pos))
			{
				FavoriteSlots.Remove(pos);
			}
			SaveFavorites(player);
		}

		private static void EnsureFavoritesLoaded(Player player)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			string playerId = GetPlayerId(player);
			if (string.Equals(InventoryClient.LoadedFavoritesPlayerId, playerId, StringComparison.Ordinal))
			{
				return;
			}
			FavoriteSlots.Clear();
			InventoryClient.LoadedFavoritesPlayerId = playerId;
			try
			{
				InventorySlotsClientPlayerState clientPlayerState = GetClientPlayerState(playerId, create: false);
				if (clientPlayerState == null)
				{
					return;
				}
				foreach (InventorySlotsFavoriteSlot favoriteSlot in clientPlayerState.FavoriteSlots)
				{
					if (favoriteSlot.X >= 0 && favoriteSlot.Y >= 0)
					{
						FavoriteSlots.Add(new Vector2i(favoriteSlot.X, favoriteSlot.Y));
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to load InventorySlots favorites from " + ClientStateFilePath + ": " + ex.Message));
			}
		}

		private static void ApplyAutoFavoriteHotbarSwitchRowToLocalPlayer()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				ApplyAutoFavoriteHotbarSwitchRowForPlayer(localPlayer);
			}
		}

		private static void ApplyAutoFavoriteHotbarSwitchRowForPlayer(Player player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer) && ShouldAutoFavoriteHotbarSwitchRow())
			{
				EnsureFavoritesLoaded(player);
				if (ApplyAutoFavoriteHotbarSwitchRow(player))
				{
					SaveFavorites(player);
				}
			}
		}

		private static bool ApplyAutoFavoriteHotbarSwitchRow(Player player)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldAutoFavoriteHotbarSwitchRow() || (Object)(object)player == (Object)null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || inventory.GetHeight() <= 1)
			{
				return false;
			}
			int num = Math.Max(1, inventory.GetWidth());
			bool flag = false;
			for (int i = 0; i < num; i++)
			{
				flag |= FavoriteSlots.Add(new Vector2i(i, 1));
			}
			return flag;
		}

		private static bool ShouldAutoFavoriteHotbarSwitchRow()
		{
			if (_autoFavoriteHotbarSwitchRow != null)
			{
				return _autoFavoriteHotbarSwitchRow.Value.IsOn();
			}
			return false;
		}

		private static void SaveFavorites(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			string playerId = GetPlayerId(player);
			InventoryClient.LoadedFavoritesPlayerId = playerId;
			try
			{
				GetClientPlayerState(playerId, create: true).FavoriteSlots = (from slot in FavoriteSlots
					orderby slot.y, slot.x
					select new InventorySlotsFavoriteSlot
					{
						X = slot.x,
						Y = slot.y
					}).ToList();
				SaveClientState();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to save InventorySlots favorites: " + ex.Message));
			}
		}

		private static void UpdateInventorySideHints(InventoryGrid playerGrid, Vector3 origin, float elementSpace, int totalRegularRows)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerGrid?.m_gridRoot == (Object)null || !InventoryGui.IsVisible())
			{
				HideInventorySideHints();
			}
			else
			{
				UpdateInventoryWheelHint(playerGrid, origin, elementSpace, totalRegularRows);
			}
		}

		private static void UpdateHotbarSwitchHud()
		{
			//IL_0107: 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_011a: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_0161: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = (((Object)(object)Hud.instance != (Object)null) ? Hud.instance.m_rootObject : null);
			string hotbarSwitchKeyDisplayText = GetHotbarSwitchKeyDisplayText();
			if (_showHotbarSwitchHint == null || !_showHotbarSwitchHint.Value.IsOn() || string.IsNullOrWhiteSpace(hotbarSwitchKeyDisplayText) || !((Object)(object)val != (Object)null))
			{
				SetHintActive(TooltipUi.HotbarSwitchHudHint, active: false);
				return;
			}
			Transform val2 = val.transform.Find("HotKeyBar");
			RectTransform component = val.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				SetHintActive(TooltipUi.HotbarSwitchHudHint, active: false);
				return;
			}
			TooltipUi.HotbarSwitchHudHint = EnsureInventoryHintLabel(component, "InventorySlots_HotbarSwitchHudHint", ref TooltipUi.HotbarSwitchHudHintText);
			if (!((Object)(object)TooltipUi.HotbarSwitchHudHint == (Object)null) && !((Object)(object)TooltipUi.HotbarSwitchHudHintText == (Object)null))
			{
				float num = (((Object)(object)val2 != (Object)null) ? GetHudElementSpace() : 70f);
				float num2 = 64f;
				TooltipUi.HotbarSwitchHudHint.pivot = new Vector2(0f, 0.5f);
				Vector3 val3 = (((Object)(object)val2 != (Object)null) ? val2.localPosition : Vector3.zero);
				((Transform)TooltipUi.HotbarSwitchHudHint).localPosition = val3 + new Vector3(8f * num + 10f, 0f, 0f) + Vector2.op_Implicit(HotbarSwitchHintOffset);
				TooltipUi.HotbarSwitchHudHint.sizeDelta = new Vector2(Mathf.Max(num2 * 2.25f, 58f), Mathf.Max(num2 * 1.6f, 38f));
				TooltipUi.HotbarSwitchHudHintText.text = LocalizeUi("$inventoryslots_hotbar_switch_hint", "Switch\n[{key}]").Replace("{key}", hotbarSwitchKeyDisplayText);
				TooltipUi.HotbarSwitchHudHintText.fontSize = 16f;
				TooltipUi.HotbarSwitchHudHintText.lineSpacing = -10f;
				TooltipUi.HotbarSwitchHudHintText.overflowMode = (TextOverflowModes)0;
				((Graphic)TooltipUi.HotbarSwitchHudHintText).color = HotbarSwitchHintColor;
				SetHintActive(TooltipUi.HotbarSwitchHudHint, active: true);
			}
		}

		private static void UpdateInventoryWheelHint(InventoryGrid playerGrid, Vector3 origin, float elementSpace, int totalRegularRows)
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			if (_showInventoryWheelButton == null || !_showInventoryWheelButton.Value.IsOn() || !UseExpandableInventoryRows() || totalRegularRows <= 4 || !InventoryGui.IsVisible())
			{
				SetHintActive(TooltipUi.InventoryWheelHint, active: false);
				return;
			}
			TooltipUi.InventoryWheelHint = EnsureInventoryHintLabel(playerGrid.m_gridRoot, "InventorySlots_InventoryWheelHint", ref TooltipUi.InventoryWheelHintText);
			if (!((Object)(object)TooltipUi.InventoryWheelHint == (Object)null) && !((Object)(object)TooltipUi.InventoryWheelHintText == (Object)null))
			{
				float num = 0f;
				float num2 = ((num > 0f) ? Mathf.Clamp(num, 8f, 64f) : Mathf.Clamp(elementSpace * 0.34f, 18f, 28f));
				float num3 = Mathf.Max(18f, num2 * 0.92f);
				float num4 = Mathf.Max(28f, num2 * 1.32f);
				((Transform)TooltipUi.InventoryWheelHint).localPosition = origin + new Vector3(0f - num3 - 9f, -3f * elementSpace, 0f) + Vector2.op_Implicit(InventoryWheelHintOffset);
				TooltipUi.InventoryWheelHint.sizeDelta = new Vector2(num3, num4);
				TooltipUi.InventoryWheelHintText.text = "";
				TooltipUi.InventoryWheelHintText.fontSize = Mathf.Clamp(num2 * 0.55f, 12f, 18f);
				TooltipUi.InventoryWheelHintText.overflowMode = (TextOverflowModes)0;
				((Graphic)TooltipUi.InventoryWheelHintText).color = InventoryWheelHintColor;
				UpdateInventoryWheelHintIcon(TooltipUi.InventoryWheelHint, num3, num4, InventoryWheelHintColor);
				SetHintActive(TooltipUi.InventoryWheelHint, active: true);
			}
		}

		private static void UpdateInventoryWheelHintIcon(RectTransform root, float width, float height, Color color)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = EnsureHintImage(root, "MouseWheelIcon");
			obj.sizeDelta = new Vector2(width, height);
			((Transform)obj).localPosition = Vector3.zero;
			((Transform)obj).SetAsLastSibling();
			Image component = ((Component)obj).GetComponent<Image>();
			component.sprite = GetMouseWheelHintSprite();
			component.type = (Type)0;
			component.preserveAspect = true;
			((Graphic)component).color = color;
			HideHintChild(root, "KeyBkg");
			HideHintChild(root, "Up");
			HideHintChild(root, "Down");
			HideHintChild(root, "Line");
		}

		private static void HideHintChild(RectTransform root, string name)
		{
			Transform val = ((Transform)root).Find(name);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
		}

		private static Sprite GetMouseWheelHintSprite()
		{
			//IL_001d: 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)
			//IL_0285: Expected O, but got Unknown
			//IL_02cb: 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_00a7: 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_00ab: 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_00df: 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_0117: 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_012a: 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_0151: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: 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_01d2: 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_01f9: 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_024a: 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)
			if ((Object)(object)TooltipUi.MouseWheelHintSprite != (Object)null)
			{
				return TooltipUi.MouseWheelHintSprite;
			}
			Color[] array = Enumerable.Repeat<Color>(Color.clear, 12288).ToArray();
			float num = 7f;
			float num2 = 7f;
			float num3 = 48f;
			float num4 = (96f - num * 2f) * 0.5f;
			Vector2 start = default(Vector2);
			((Vector2)(ref start))..ctor(num3, num + num4);
			Vector2 end = default(Vector2);
			((Vector2)(ref end))..ctor(num3, 128f - num - num4);
			Vector2 point = default(Vector2);
			for (int i = 0; i < 128; i++)
			{
				for (int j = 0; j < 96; j++)
				{
					((Vector2)(ref point))..ctor((float)j + 0.5f, (float)i + 0.5f);
					float num5 = 0f;
					float distance = Mathf.Abs(DistanceToSegment(point, start, end) - num4);
					num5 = Mathf.Max(num5, StrokeAlpha(distance, num2));
					num5 = Mathf.Max(num5, StrokeAlpha(DistanceToSegment(point, new Vector2(num + num2 * 0.45f, 62.72f), new Vector2(96f - num - num2 * 0.45f, 62.72f)), num2 * 0.55f));
					num5 = Mathf.Max(num5, StrokeAlpha(DistanceToSegment(point, new Vector2(num3, 76.8f), new Vector2(num3, 106.24f)), num2 * 0.55f));
					num5 = Mathf.Max(num5, StrokeAlpha(DistanceToSegment(point, new Vector2(num3, 106.24f), new Vector2(num3 - 14.400001f, 92.16f)), num2 * 0.55f));
					num5 = Mathf.Max(num5, StrokeAlpha(DistanceToSegment(point, new Vector2(num3, 106.24f), new Vector2(num3 + 14.400001f, 92.16f)), num2 * 0.55f));
					num5 = Mathf.Max(num5, StrokeAlpha(DistanceToSegment(point, new Vector2(num3, 78.08f), new Vector2(num3 - 14.400001f, 92.16f)), num2 * 0.55f));
					num5 = Mathf.Max(num5, StrokeAlpha(DistanceToSegment(point, new Vector2(num3, 78.08f), new Vector2(num3 + 14.400001f, 92.16f)), num2 * 0.55f));
					if (num5 > 0f)
					{
						array[i * 96 + j] = new Color(1f, 1f, 1f, num5);
					}
				}
			}
			Texture2D val = new Texture2D(96, 128, (TextureFormat)4, false);
			((Object)val).name = "InventorySlots_MouseWheelHintTexture";
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)1;
			val.SetPixels(array);
			val.Apply();
			TooltipUi.MouseWheelHintSprite = Sprite.Create(val, new Rect(0f, 0f, 96f, 128f), new Vector2(0.5f, 0.5f), 100f);
			((Object)TooltipUi.MouseWheelHintSprite).name = "InventorySlots_MouseWheelHintSprite";
			return TooltipUi.MouseWheelHintSprite;
		}

		private static float StrokeAlpha(float distance, float strokeWidth)
		{
			return Mathf.Clamp01(strokeWidth * 0.5f + 1f - distance);
		}

		private static float DistanceToSegment(Vector2 point, Vector2 start, Vector2 end)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_0020: 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_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_0036: 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_003e: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = end - start;
			float num = Vector2.Dot(val, val);
			if (num <= 0.0001f)
			{
				return Vector2.Distance(point, start);
			}
			float num2 = Mathf.Clamp01(Vector2.Dot(point - start, val) / num);
			return Vector2.Distance(point, start + val * num2);
		}

		private static TMP_Text EnsureHintText(RectTransform parent, string name, string value)
		{
			//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_006d: 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)
			Transform val = ((Transform)parent).Find(name);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = CreateTextRect(name, (Transform)(object)parent);
			}
			val2.anchorMin = new Vector2(0.5f, 0.5f);
			val2.anchorMax = new Vector2(0.5f, 0.5f);
			val2.pivot = new Vector2(0.5f, 0.5f);
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			TMP_Text component = ((Component)val2).GetComponent<TMP_Text>();
			ApplyDefaultFontAsset(component);
			component.text = value;
			component.alignment = (TextAlignmentOptions)514;
			component.textWrappingMode = (TextWrappingModes)0;
			component.overflowMode = (TextOverflowModes)0;
			((Graphic)component).raycastTarget = false;
			((Component)component).gameObject.SetActive(true);
			return component;
		}

		private static RectTransform EnsureHintImage(RectTransform parent, string name)
		{
			//IL_0063: 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_008d: 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_00a3: 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)
			Transform val = ((Transform)parent).Find(name);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = new GameObject(name, new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				}).GetComponent<RectTransform>();
				((Transform)val2).SetParent((Transform)(object)parent, false);
			}
			val2.anchorMin = new Vector2(0.5f, 0.5f);
			val2.anchorMax = new Vector2(0.5f, 0.5f);
			val2.pivot = new Vector2(0.5f, 0.5f);
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			Image component = ((Component)val2).GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).raycastTarget = false;
			((Component)val2).gameObject.SetActive(true);
			return val2;
		}

		internal static Sprite GetSolidUiSprite()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_002a: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)TooltipUi.SolidUiSprite != (Object)null)
			{
				return TooltipUi.SolidUiSprite;
			}
			Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false);
			val.SetPixel(0, 0, Color.white);
			val.Apply();
			TooltipUi.SolidUiSprite = Sprite.Create(val, new Rect(0f, 0f, 1f, 1f), new Vector2(0.5f, 0.5f));
			return TooltipUi.SolidUiSprite;
		}

		private static RectTransform? EnsureInventoryHintLabel(RectTransform parent, string name, ref TMP_Text? text, bool configureCenteredLayout = true)
		{
			//IL_0070: 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_00cc: 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_0050: 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)
			Transform val = ((Transform)parent).Find(name);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = CreateTextRect(name, (Transform)(object)parent);
			}
			if (configureCenteredLayout)
			{
				val2.anchorMin = new Vector2(0.5f, 0.5f);
				val2.anchorMax = new Vector2(0.5f, 0.5f);
				val2.pivot = new Vector2(0.5f, 0.5f);
			}
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			((Transform)val2).SetAsLastSibling();
			text = ((Component)val2).GetComponent<TMP_Text>();
			ApplyDefaultFontAsset(text);
			text.alignment = (TextAlignmentOptions)514;
			text.textWrappingMode = (TextWrappingModes)0;
			text.enableAutoSizing = false;
			((Graphic)text).color = new Color(0.68f, 0.88f, 1f, 1f);
			((Graphic)text).raycastTarget = false;
			return val2;
		}

		private static void HideInventorySideHints()
		{
			SetHintActive(TooltipUi.InventoryWheelHint, active: false);
		}

		private static void SetHintActive(RectTransform? hint, bool active)
		{
			if ((Object)(object)hint != (Object)null && ((Component)hint).gameObject.activeSelf != active)
			{
				((Component)hint).gameObject.SetActive(active);
			}
		}

		private static string GetHotbarSwitchKeyDisplayText()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return JoinShortcutDisplayTexts((_hotbarSwitchKey != null) ? _hotbarSwitchKey.Value.GetCompactDisplayText() : "", GetControllerHotkeyDisplayText(_controllerHotbarSwitchButton));
		}

		private static Transform? FindKeyboardHintParent(Transform groupRoot)
		{
			Transform val = groupRoot.Find("Keyboard");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			for (int i = 0; i < groupRoot.childCount; i++)
			{
				Transform child = groupRoot.GetChild(i);
				if (string.Equals(((Object)child).name, "Keyboard", StringComparison.OrdinalIgnoreCase))
				{
					return child;
				}
			}
			return groupRoot;
		}

		private static void ApplyDefaultFontAsset(TMP_Text? text)
		{
			if ((Object)(object)text == (Object)null)
			{
				return;
			}
			TMP_FontAsset defaultFontAsset = GetDefaultFontAsset(text);
			if ((Object)(object)defaultFontAsset != (Object)null)
			{
				text.font = defaultFontAsset;
				if ((Object)(object)TooltipUi.DefaultFontMaterial != (Object)null && !IsUnityNull((Object?)(object)TooltipUi.DefaultFontMaterial))
				{
					text.fontSharedMaterial = TooltipUi.DefaultFontMaterial;
				}
			}
		}

		private static RectTransform CreateTextRect(string name, Transform parent, out TMP_Text text, bool active = true)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.SetActive(false);
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			text = (TMP_Text)(object)val.AddComponent<TextMeshProUGUI>();
			ApplyDefaultFontAsset(text);
			val.SetActive(active);
			return component;
		}

		private static RectTransform CreateTextRect(string name, Transform parent, bool active = true)
		{
			TMP_Text text;
			return CreateTextRect(name, parent, out text, active);
		}

		private static RectTransform CreateTopLeftImageChild(string name, Transform parent, Color color, bool active, bool raycastTarget = false)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0047: 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_0071: 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_0087: 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)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.SetActive(false);
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			((Transform)component).localScale = Vector3.one;
			((Transform)component).localRotation = Quaternion.identity;
			Image component2 = val.GetComponent<Image>();
			component2.sprite = GetSolidUiSprite();
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = raycastTarget;
			val.SetActive(active);
			return component;
		}

		private static TMP_FontAsset? GetDefaultFontAsset(TMP_Text? exclude = null)
		{
			if ((Object)(object)TooltipUi.DefaultFontAsset != (Object)null && !IsUnityNull((Object?)(object)TooltipUi.DefaultFontAsset))
			{
				return TooltipUi.DefaultFontAsset;
			}
			TMP_FontAsset val = TryFindKnownUiFontAsset(exclude) ?? TryFindLoadedFontAsset();
			if ((Object)(object)val != (Object)null)
			{
				TooltipUi.DefaultFontAsset = val;
			}
			return TooltipUi.DefaultFontAsset;
		}

		private static TMP_FontAsset? TryFindKnownUiFontAsset(TMP_Text? exclude)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			return TryGetFontAsset(((Object)(object)instance.m_tabCraft != (Object)null) ? ((Component)instance.m_tabCraft).GetComponentInChildren<TMP_Text>(true) : null, exclude) ?? TryGetFontAsset(((Object)(object)instance.m_tabUpgrade != (Object)null) ? ((Component)instance.m_tabUpgrade).GetComponentInChildren<TMP_Text>(true) : null, exclude) ?? TryGetFontAsset(instance.m_craftingStationName, exclude) ?? TryGetFontAsset(instance.m_recipeName, exclude) ?? TryGetFontAsset(instance.m_recipeDecription, exclude) ?? TryGetFontAsset(instance.m_containerName, exclude) ?? TryGetFontAsset(instance.m_armor, exclude) ?? TryGetFontAsset(instance.m_weight, exclude) ?? TryGetFontAsset(instance.m_containerWeight, exclude) ?? TryGetFontAsset(instance.m_minStationLevelText, exclude) ?? TryGetFontAsset(((Object)(object)instance.m_craftButton != (Object)null) ? ((Component)instance.m_craftButton).GetComponentInChildren<TMP_Text>(true) : null, exclude) ?? TryGetFontAsset(((Object)(object)instance.m_repairButton != (Object)null) ? ((Component)instance.m_repairButton).GetComponentInChildren<TMP_Text>(true) : null, exclude);
		}

		private static TMP_FontAsset? TryGetFontAsset(TMP_Text? candidate, TMP_Text? exclude)
		{
			if ((Object)(object)candidate == (Object)null || (Object)(object)candidate == (Object)(object)exclude)
			{
				return null;
			}
			TMP_FontAsset font = candidate.font;
			if ((Object)(object)font == (Object)null || IsUnityNull((Object?)(object)font))
			{
				return null;
			}
			CaptureDefaultFontMaterials(candidate);
			return font;
		}

		private static void CaptureDefaultFontMaterials(TMP_Text source)
		{
			if ((Object)(object)TooltipUi.DefaultFontMaterial == (Object)null || IsUnityNull((Object?)(object)TooltipUi.DefaultFontMaterial))
			{
				Material fontSharedMaterial = source.fontSharedMaterial;
				if ((Object)(object)fontSharedMaterial != (Object)null && !IsUnityNull((Object?)(object)fontSharedMaterial))
				{
					TooltipUi.DefaultFontMaterial = fontSharedMaterial;
				}
			}
		}

		private static void ApplyDefaultFontAssetToChildren(GameObject? root)
		{
			if (!((Object)(object)root == (Object)null))
			{
				TMP_Text[] componentsInChildren = root.GetComponentsInChildren<TMP_Text>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					ApplyDefaultFontAsset(componentsInChildren[i]);
				}
			}
		}

		private static TMP_FontAsset? TryFindLoadedFontAsset()
		{
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					string text = ((Object)val).name ?? "";
					if (text.IndexOf("LiberationSans", StringComparison.OrdinalIgnoreCase) < 0 && (text.IndexOf("Valheim", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Averia", StringComparison.OrdinalIgnoreCase) >= 0))
					{
						return val;
					}
				}
			}
			return ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset fontAsset) => (Object)(object)fontAsset != (Object)null && !IsUnityNull((Object?)(object)fontAsset) && (((Object)fontAsset).name ?? "").IndexOf("LiberationSans", StringComparison.OrdinalIgnoreCase) < 0));
		}

		internal static void EnsureInventoryContainerHoverTooltipScroll(UITooltip tooltip)
		{
			UpdateInventoryContainerHoverTooltip(tooltip, resetScroll: true, handleWheel: false);
		}

		internal static void RegisterInventoryGridItemTooltip(InventoryGrid? grid, ItemData item, UITooltip tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip) && item?.m_shared != null)
			{
				PruneInventoryHoverTooltipSources();
				InventoryHoverTooltipItems.Set(tooltip, new InventoryHoverTooltipItemSource(grid, item));
			}
		}

		internal static void UpdateInventoryContainerHoverTooltipScroll(UITooltip tooltip)
		{
			UpdateInventoryContainerHoverTooltip(tooltip, resetScroll: false, handleWheel: true);
		}

		internal static void BeginInventoryContainerHoverTooltipOwnership(UITooltip tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip) && IsInventoryContainerTooltipSource(tooltip))
			{
				if ((Object)(object)_inventoryContainerHoverTooltipSource != (Object)(object)tooltip)
				{
					_inventoryHoverTooltipSignature = "";
					_inventoryHoverTooltipScrollOffset = 0f;
				}
				_inventoryContainerHoverTooltipSource = tooltip;
			}
		}

		internal static void EndInventoryContainerHoverTooltipOwnership(UITooltip tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip) && !((Object)(object)_inventoryContainerHoverTooltipSource == (Object)null) && !IsUnityNull((Object?)(object)_inventoryContainerHoverTooltipSource) && !((Object)(object)_inventoryContainerHoverTooltipSource != (Object)(object)tooltip))
			{
				_inventoryContainerHoverTooltipSource = null;
				HideInventoryContainerCustomTooltip();
				ForceHideInventorySimpleNameTooltip();
				RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
			}
		}

		internal static void UpdateInventorySlotsOwnedHoverTooltip(UITooltip tooltip, bool resetScroll, bool handleWheel)
		{
			if (ShouldUseInventorySlotsOwnedHoverTooltip(tooltip))
			{
				if (resetScroll)
				{
					BeginInventorySlotsOwnedHoverTooltip(tooltip);
				}
				else if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)null || IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource) || (Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)(object)tooltip)
				{
					return;
				}
				if (IsSimpleInventorySlotsNameTooltip(tooltip))
				{
					HideInventoryContainerCustomTooltip();
					HideVanillaTooltipVisual(UITooltip.m_tooltip);
					UpdateInventorySimpleNameTooltip(tooltip);
				}
				else
				{
					ForceHideInventorySimpleNameTooltip();
					UpdateInventoryHoverCustomTooltip(tooltip, resetScroll, handleWheel, GetInventoryHoverCustomTooltipBackgroundAlpha(tooltip), hideVanillaTooltip: true);
				}
			}
		}

		internal static bool ShouldAllowTooltipLateUpdate(UITooltip tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip) || !ShouldSuppressVanillaLateUpdate(tooltip))
			{
				return true;
			}
			bool flag = (Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)null && !IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource) && (Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)(object)tooltip;
			if (!flag && !((Object)(object)UITooltip.m_current == (Object)(object)tooltip))
			{
				return true;
			}
			UpdateInventorySlotsOwnedHoverTooltip(tooltip, !flag, handleWheel: true);
			return false;
		}

		internal static void BeginInventorySlotsOwnedHoverTooltip(UITooltip tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip))
			{
				if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)(object)tooltip)
				{
					_inventoryHoverTooltipSignature = "";
					_inventoryHoverTooltipScrollOffset = 0f;
				}
				_inventorySlotsOwnedHoverTooltipSource = tooltip;
				UITooltip.m_current = tooltip;
				if (ShouldSuppressVanillaHoverStart(tooltip) && (Object)(object)UITooltip.m_hovered == (Object)(object)((Component)tooltip).gameObject)
				{
					UITooltip.m_hovered = null;
				}
			}
		}

		internal static void EndInventorySlotsOwnedHoverTooltip(UITooltip tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip) && !((Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)null) && !IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource) && !((Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)(object)tooltip))
			{
				_inventorySlotsOwnedHoverTooltipSource = null;
				if ((Object)(object)UITooltip.m_current == (Object)(object)tooltip)
				{
					UITooltip.m_current = null;
				}
				if ((Object)(object)UITooltip.m_hovered == (Object)(object)((Component)tooltip).gameObject)
				{
					UITooltip.m_hovered = null;
				}
				HideInventoryContainerCustomTooltip();
				ForceHideInventorySimpleNameTooltip();
				RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
			}
		}

		internal static bool TryRecoverInventorySlotsTooltipLateUpdateException(UITooltip tooltip, Exception exception)
		{
			if (!(exception is NullReferenceException) || (Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip) || !IsRecoverableInventorySlotsTooltipLateUpdateSource(tooltip))
			{
				return false;
			}
			if (!_tooltipLateUpdateExceptionLogged)
			{
				_tooltipLateUpdateExceptionLogged = true;
				Log.LogWarning((object)("Recovered InventorySlots-owned UITooltip LateUpdate null state for " + ((Object)tooltip).name + ". Future identical recoveries will be silent."));
			}
			if ((Object)(object)UITooltip.m_current == (Object)(object)tooltip)
			{
				UITooltip.m_current = null;
			}
			if ((Object)(object)UITooltip.m_hovered == (Object)(object)((Component)tooltip).gameObject)
			{
				UITooltip.m_hovered = null;
			}
			if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)(object)tooltip)
			{
				_inventorySlotsOwnedHoverTooltipSource = null;
			}
			HideInventoryContainerCustomTooltip();
			ForceHideInventorySimpleNameTooltip();
			RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
			return true;
		}

		private static bool IsRecoverableInventorySlotsTooltipLateUpdateSource(UITooltip tooltip)
		{
			if ((Object)(object)_inventorySlotsOwnedHoverTooltipSource != (Object)null && !IsUnityNull((Object?)(object)_inventorySlotsOwnedHoverTooltipSource) && (Object)(object)_inventorySlotsOwnedHoverTooltipSource == (Object)(object)tooltip)
			{
				return true;
			}
			if ((Object)(object)UITooltip.m_current == (Object)(object)tooltip)
			{
				return ShouldUseInventorySlotsOwnedHoverTooltip(tooltip);
			}
			return false;
		}

		internal static void OnVanillaTooltipHidden()
		{
			_inventoryContainerHoverTooltipSource = null;
			_inventorySlotsOwnedHoverTooltipSource = null;
			HideInventoryContainerCustomTooltip();
			ForceHideInventorySimpleNameTooltip();
			PruneInventoryHoverTooltipSources();
			RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
		}

		private static bool ShouldSuppressInventoryContainerRowsWheel()
		{
			if (IsMouseOverContainerInventory())
			{
				return true;
			}
			if ((Object)(object)UITooltip.m_current == (Object)null || IsUnityNull((Object?)(object)UITooltip.m_current) || !IsInventoryContainerTooltipSource(UITooltip.m_current))
			{
				return false;
			}
			if (!_inventoryHoverTooltipNeedsScroll)
			{
				return HasTooltipScrollRect(UITooltip.m_tooltip);
			}
			return true;
		}

		private static bool IsMouseOverContainerInventory()
		{
			//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_009c: 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)
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance) || (Object)(object)instance.m_container == (Object)null || IsUnityNull((Object?)(object)instance.m_container) || !((Component)instance.m_container).gameObject.activeInHierarchy)
			{
				return false;
			}
			Vector2 uiMousePosition = GetUiMousePosition();
			InventoryGrid containerGrid = instance.m_containerGrid;
			if ((Object)(object)containerGrid?.m_gridRoot != (Object)null && !IsUnityNull((Object?)(object)containerGrid.m_gridRoot) && ((Component)containerGrid.m_gridRoot).gameObject.activeInHierarchy && RectContainsScreenPoint(containerGrid.m_gridRoot, uiMousePosition))
			{
				return true;
			}
			return RectContainsScreenPoint(instance.m_container, uiMousePosition);
		}

		private static bool HasTooltipScrollRect(GameObject? tooltipObject)
		{
			if ((Object)(object)tooltipObject == (Object)null || IsUnityNull((Object?)(object)tooltipObject))
			{
				return false;
			}
			ScrollRect componentInChildren = tooltipObject.GetComponentInChildren<ScrollRect>(false);
			if ((Object)(object)componentInChildren == (Object)null || IsUnityNull((Object?)(object)componentInChildren) || !((Component)componentInChildren).gameObject.activeInHierarchy)
			{
				return false;
			}
			Scrollbar verticalScrollbar = componentInChildren.verticalScrollbar;
			if (!((Behaviour)componentInChildren).enabled)
			{
				if ((Object)(object)verticalScrollbar != (Object)null && !IsUnityNull((Object?)(object)verticalScrollbar))
				{
					return ((Component)verticalScrollbar).gameObject.activeInHierarchy;
				}
				return false;
			}
			return true;
		}

		private static void UpdateInventoryContainerHoverTooltip(UITooltip tooltip, bool resetScroll, bool handleWheel)
		{
			if ((Object)(object)tooltip == (Object)null || !IsInventoryContainerTooltipSource(tooltip) || ShouldUseInventorySlotsOwnedHoverTooltip(tooltip))
			{
				HideInventoryContainerCustomTooltip();
				RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
			}
			else
			{
				ForceHideInventorySimpleNameTooltip();
				UpdateInventoryHoverCustomTooltip(tooltip, resetScroll, handleWheel, GetInventoryHoverCustomTooltipBackgroundAlpha(tooltip), hideVanillaTooltip: true);
			}
		}

		private static void UpdateInventoryHoverCustomTooltip(UITooltip tooltip, bool resetScroll, bool handleWheel, float backgroundAlpha, bool hideVanillaTooltip)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = EnsureInventoryContainerCustomTooltip(tooltip);
			RectTransform inventoryHoverTooltipPanel = _inventoryHoverTooltipPanel;
			if ((Object)(object)val == (Object)null || (Object)(object)inventoryHoverTooltipPanel == (Object)null || IsUnityNull((Object?)(object)inventoryHoverTooltipPanel))
			{
				if (hideVanillaTooltip)
				{
					RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
				}
				return;
			}
			string text = LocalizeTooltipText(GetInventoryContainerHoverTooltipTopic(tooltip));
			string text2 = LocalizeTooltipText(GetInventoryContainerHoverTooltipBody(tooltip));
			InventoryHoverTooltipItemSource? inventoryContainerHoverTooltipItemSource = GetInventoryContainerHoverTooltipItemSource(tooltip);
			ItemData item = inventoryContainerHoverTooltipItemSource?.Item;
			if (string.IsNullOrWhiteSpace(text) && string.IsNullOrWhiteSpace(text2))
			{
				HideInventoryContainerCustomTooltip();
				if (hideVanillaTooltip)
				{
					RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
				}
				return;
			}
			bool flag = hideVanillaTooltip && IsInventoryContainerTooltipSource(tooltip) && (resetScroll || (Object)(object)_inventoryContainerHoverTooltipSource == (Object)null || IsUnityNull((Object?)(object)_inventoryContainerHoverTooltipSource) || (Object)(object)_inventoryContainerHoverTooltipSource != (Object)(object)tooltip);
			if (hideVanillaTooltip)
			{
				HideVanillaTooltipVisual(UITooltip.m_tooltip);
			}
			val.SetActive(true);
			BeginInventoryContainerHoverTooltipOwnership(tooltip);
			if (flag)
			{
				SuppressEpicLootInventoryContainerTooltipArtifacts();
			}
			ApplyInventoryContainerCustomTooltipBackground(val.GetComponent<Image>(), backgroundAlpha);
			string inventoryHoverTooltipItemSignature = GetInventoryHoverTooltipItemSignature(item);
			bool flag2 = UpdateInventoryContainerCustomTooltipText(text, text2, resetScroll, inventoryHoverTooltipItemSignature);
			bool flag3 = UpdateInventoryHoverJewelcraftingTooltip(inventoryHoverTooltipPanel, item, ShouldShowJewelcraftingInventoryInteract(inventoryContainerHoverTooltipItemSource?.Grid), inventoryHoverTooltipItemSignature);
			LayoutInventoryContainerCustomTooltip(inventoryHoverTooltipPanel, resetScroll || flag2 || flag3);
			((Transform)inventoryHoverTooltipPanel).position = ZInput.mousePosition;
			Utils.ClampUIToScreen(inventoryHoverTooltipPanel);
			((Transform)inventoryHoverTooltipPanel).SetAsLastSibling();
			if (handleWheel)
			{
				HandleInventoryContainerHoverTooltipWheel();
			}
		}

		private static string GetInventoryContainerHoverTooltipTopic(UITooltip tooltip)
		{
			InventorySlotsTooltipDisplayData inventorySlotsTooltipDisplayData = default(InventorySlotsTooltipDisplayData);
			if (((Component)tooltip).TryGetComponent<InventorySlotsTooltipDisplayData>(ref inventorySlotsTooltipDisplayData) && inventorySlotsTooltipDisplayData.HasDisplayData && !string.IsNullOrWhiteSpace(inventorySlotsTooltipDisplayData.DisplayTopic))
			{
				return inventorySlotsTooltipDisplayData.DisplayTopic;
			}
			if (!string.IsNullOrWhiteSpace(tooltip.m_topic))
			{
				return tooltip.m_topic;
			}
			TMP_Text val = FindTooltipTextByName(UITooltip.m_tooltip, "Topic");
			if (!((Object)(object)val != (Object)null) || IsUnityNull((Object?)(object)val))
			{
				return "";
			}
			return val.text ?? "";
		}

		private static string GetInventoryContainerHoverTooltipBody(UITooltip tooltip)
		{
			InventorySlotsTooltipDisplayData inventorySlotsTooltipDisplayData = default(InventorySlotsTooltipDisplayData);
			if (((Component)tooltip).TryGetComponent<InventorySlotsTooltipDisplayData>(ref inventorySlotsTooltipDisplayData) && inventorySlotsTooltipDisplayData.HasDisplayData)
			{
				return inventorySlotsTooltipDisplayData.DisplayText;
			}
			if (!string.IsNullOrWhiteSpace(tooltip.m_text))
			{
				return tooltip.m_text;
			}
			TMP_Text val = FindTooltipTextByName(UITooltip.m_tooltip, "Text");
			if (!((Object)(object)val != (Object)null) || IsUnityNull((Object?)(object)val))
			{
				return "";
			}
			return val.text ?? "";
		}

		private static InventoryHoverTooltipItemSource? GetInventoryContainerHoverTooltipItemSource(UITooltip tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip))
			{
				return null;
			}
			if (!InventoryHoverTooltipItems.TryGet(tooltip, out var value))
			{
				return null;
			}
			if (!IsInventoryHoverTooltipSourceValid(tooltip, value))
			{
				InventoryHoverTooltipItems.Remove(tooltip);
				return null;
			}
			return value;
		}

		private static void ClearInventoryHoverTooltipSources()
		{
			InventoryHoverTooltipItems.Clear();
		}

		private static void PruneInventoryHoverTooltipSources()
		{
			InventoryHoverTooltipItems.RemoveWhere((UITooltip tooltip, InventoryHoverTooltipItemSource source) => !IsInventoryHoverTooltipSourceValid(tooltip, source));
		}

		private static bool IsInventoryHoverTooltipSourceValid(UITooltip tooltip, InventoryHoverTooltipItemSource source)
		{
			if ((Object)(object)tooltip != (Object)null && !IsUnityNull((Object?)(object)tooltip) && source.Item?.m_shared != null)
			{
				if (!((Object)(object)source.Grid == (Object)null))
				{
					return !IsUnityNull((Object?)(object)source.Grid);
				}
				return true;
			}
			return false;
		}

		private static string GetInventoryHoverTooltipItemSignature(ItemData? item)
		{
			if (item?.m_shared != null)
			{
				return GetEquipmentSlotTooltipSignature(item);
			}
			return "";
		}

		private static void ApplyInventoryHoverTooltipSourceFonts()
		{
			ApplyTooltipSourceFont(_inventoryHoverTooltipTopic, "Topic");
			ApplyTooltipSourceFont(_inventoryHoverTooltipText, "Text");
		}

		private static void ApplyTooltipSourceFont(TMP_Text? target, string sourceName)
		{
			if ((Object)(object)target == (Object)null || IsUnityNull((Object?)(object)target))
			{
				return;
			}
			try
			{
				TMP_Text val = FindTooltipTextByName(UITooltip.m_tooltip, sourceName);
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)val == (Object)(object)target)
				{
					ApplyDefaultFontAsset(target);
					return;
				}
				TMP_FontAsset font = val.font;
				if ((Object)(object)font == (Object)null || IsUnityNull((Object?)(object)font))
				{
					ApplyDefaultFontAsset(target);
					return;
				}
				target.font = font;
				Material fontSharedMaterial = val.fontSharedMaterial;
				if ((Object)(object)fontSharedMaterial != (Object)null && !IsUnityNull((Object?)(object)fontSharedMaterial))
				{
					target.fontSharedMaterial = fontSharedMaterial;
				}
			}
			catch (Exception)
			{
				ApplyDefaultFontAsset(target);
			}
		}

		private static bool UpdateInventoryHoverJewelcraftingTooltip(RectTransform panel, ItemData? item, bool showInteract, string itemSignature)
		{
			if (item?.m_shared == null)
			{
				return HideInventoryHoverJewelcraftingTooltip();
			}
			string inventoryHoverJewelcraftingTooltipSignature = GetInventoryHoverJewelcraftingTooltipSignature(item, showInteract, itemSignature);
			if ((Object)(object)_inventoryHoverJewelcraftingTooltipRoot != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverJewelcraftingTooltipRoot) && ((Component)_inventoryHoverJewelcraftingTooltipRoot).gameObject.activeSelf && string.Equals(_inventoryHoverJewelcraftingTooltipSignature, inventoryHoverJewelcraftingTooltipSignature, StringComparison.Ordinal))
			{
				JewelcraftingTooltipLayoutCache component = ((Component)_inventoryHoverJewelcraftingTooltipRoot).GetComponent<JewelcraftingTooltipLayoutCache>();
				if ((Object)(object)component == (Object)null || !component.Visible)
				{
					return false;
				}
				if (!JewelcraftingTooltipCore.ShouldRefreshNativeTooltip(component.Signature, inventoryHoverJewelcraftingTooltipSignature, component.Visible, component.HasResolvedSocketGems, component.RowlessRefreshAttempts) && (!component.HasResolvedSocketGems || HasNativeJewelcraftingTooltipRows(_inventoryHoverJewelcraftingTooltipRoot)))
				{
					return false;
				}
			}
			RectTransform cachedRoot = _inventoryHoverJewelcraftingTooltipRoot;
			bool num = UpdateJewelcraftingTooltip(panel, item, ref cachedRoot, showInteract, inventoryHoverJewelcraftingTooltipSignature);
			_inventoryHoverJewelcraftingTooltipRoot = cachedRoot;
			if (num)
			{
				_inventoryHoverJewelcraftingTooltipSignature = inventoryHoverJewelcraftingTooltipSignature;
				ApplyInventoryHoverJewelcraftingSourceFonts();
				_inventoryHoverJewelcraftingTooltipLayoutRefreshFrames = 2;
				return true;
			}
			return HideInventoryHoverJewelcraftingTooltip();
		}

		private static string GetInventoryHoverJewelcraftingTooltipSignature(ItemData item, bool showInteract, string itemSignature)
		{
			return string.Join("|", showInteract, IsJewelcraftingAdvancedTooltipPressed(), IsJewelcraftingProphecyTooltipPressed(), _uiLocalizationVersion, itemSignature, GetJewelcraftingOpenSocketInventorySignature(item));
		}

		private static bool HideInventoryHoverJewelcraftingTooltip()
		{
			bool flag = !string.IsNullOrEmpty(_inventoryHoverJewelcraftingTooltipSignature);
			if ((Object)(object)_inventoryHoverJewelcraftingTooltipRoot != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverJewelcraftingTooltipRoot))
			{
				flag |= ((Component)_inventoryHoverJewelcraftingTooltipRoot).gameObject.activeSelf;
				((Component)_inventoryHoverJewelcraftingTooltipRoot).gameObject.SetActive(false);
			}
			_inventoryHoverJewelcraftingTooltipSignature = "";
			_inventoryHoverJewelcraftingTooltipLayoutRefreshFrames = 0;
			return flag;
		}

		private static void ApplyInventoryHoverJewelcraftingSourceFonts()
		{
			RectTransform inventoryHoverJewelcraftingTooltipRoot = _inventoryHoverJewelcraftingTooltipRoot;
			if (!((Object)(object)inventoryHoverJewelcraftingTooltipRoot == (Object)null) && !IsUnityNull((Object?)(object)inventoryHoverJewelcraftingTooltipRoot))
			{
				TMP_Text[] componentsInChildren = ((Component)inventoryHoverJewelcraftingTooltipRoot).GetComponentsInChildren<TMP_Text>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					ApplyTooltipSourceFont(componentsInChildren[i], "Text");
				}
				Graphic[] componentsInChildren2 = ((Component)inventoryHoverJewelcraftingTooltipRoot).GetComponentsInChildren<Graphic>(true);
				for (int i = 0; i < componentsInChildren2.Length; i++)
				{
					componentsInChildren2[i].raycastTarget = false;
				}
			}
		}

		private static float GetInventoryHoverTooltipScrollbarThresholdHeight()
		{
			return Mathf.Clamp(600f, 80f, 720f);
		}

		private static TMP_Text? FindTooltipTextByName(GameObject? tooltipObject, string name)
		{
			if ((Object)(object)tooltipObject == (Object)null || IsUnityNull((Object?)(object)tooltipObject))
			{
				return null;
			}
			TMP_Text[] componentsInChildren = tooltipObject.GetComponentsInChildren<TMP_Text>(false);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && string.Equals(((Object)((Component)val).gameObject).name, name, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		private static GameObject? EnsureInventoryContainerCustomTooltip(UITooltip tooltip)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00cb: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_inventoryHoverTooltip != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltip) && (Object)(object)_inventoryHoverTooltipPanel != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipPanel))
			{
				return _inventoryHoverTooltip;
			}
			InventoryGui instance = InventoryGui.instance;
			Canvas val = (((Object)(object)instance != (Object)null) ? ((Component)instance).GetComponentInParent<Canvas>() : ((Component)tooltip).GetComponentInParent<Canvas>());
			Transform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : ((Component)tooltip).transform.root);
			_inventoryHoverTooltip = new GameObject("InventorySlots_InventoryHoverTooltip", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			_inventoryHoverTooltip.transform.SetParent(val2, false);
			_inventoryHoverTooltip.SetActive(false);
			RectTransform component = _inventoryHoverTooltip.GetComponent<RectTransform>();
			SetTopLeftRectLayout(component, component.anchoredPosition, component.sizeDelta);
			ApplyInventoryContainerCustomTooltipBackground(_inventoryHoverTooltip.GetComponent<Image>(), GetInventoryContainerHoverTooltipBackgroundAlpha());
			CreateTextRect("Topic", (Transform)(object)component, out TMP_Text text);
			text.alignment = (TextAlignmentOptions)514;
			text.fontSize = 22f;
			text.fontStyle = (FontStyles)1;
			((Graphic)text).color = new Color(1f, 0.82f, 0.42f, 1f);
			text.textWrappingMode = (TextWrappingModes)1;
			text.overflowMode = (TextOverflowModes)0;
			((Graphic)text).raycastTarget = false;
			CreateTextRect("Text", (Transform)(object)component, out TMP_Text text2);
			text2.alignment = (TextAlignmentOptions)257;
			text2.fontSize = 18f;
			((Graphic)text2).color = Color.white;
			text2.textWrappingMode = (TextWrappingModes)1;
			text2.overflowMode = (TextOverflowModes)0;
			((Graphic)text2).raycastTarget = false;
			EnsureInventoryHoverTooltipTextScrollContent(component, text2);
			_inventoryHoverTooltipPanel = component;
			_inventoryHoverTooltipTopic = text;
			_inventoryHoverTooltipText = text2;
			_inventoryHoverTooltipSignature = "";
			_inventoryHoverTooltipLayoutSignature = "";
			return _inventoryHoverTooltip;
		}

		private static bool UpdateInventoryContainerCustomTooltipText(string topic, string body, bool resetScroll, string extraSignature)
		{
			string text = topic + "\n---\n" + body + "\n---\n" + extraSignature;
			if (!resetScroll && string.Equals(_inventoryHoverTooltipSignature, text, StringComparison.Ordinal))
			{
				return false;
			}
			ApplyInventoryHoverTooltipSourceFonts();
			if ((Object)(object)_inventoryHoverTooltipTopic != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipTopic))
			{
				_inventoryHoverTooltipTopic.text = topic;
				_inventoryHoverTooltipTopic.ForceMeshUpdate(true, true);
			}
			if ((Object)(object)_inventoryHoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipText))
			{
				_inventoryHoverTooltipText.text = body;
				_inventoryHoverTooltipText.ForceMeshUpdate(true, true);
			}
			_inventoryHoverTooltipScrollOffset = 0f;
			_inventoryHoverTooltipSignature = text;
			_inventoryHoverTooltipLayoutSignature = "";
			return true;
		}

		private static void LayoutInventoryContainerCustomTooltip(RectTransform panel, bool force)
		{
			//IL_01dc: 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)
			if (_inventoryHoverJewelcraftingTooltipLayoutRefreshFrames > 0)
			{
				force = true;
				_inventoryHoverJewelcraftingTooltipLayoutRefreshFrames--;
			}
			string inventoryHoverTooltipLayoutSignature = GetInventoryHoverTooltipLayoutSignature(panel);
			if (!force && string.Equals(_inventoryHoverTooltipLayoutSignature, inventoryHoverTooltipLayoutSignature, StringComparison.Ordinal))
			{
				ApplyInventoryHoverTooltipScrollPosition();
				return;
			}
			float num = 410f;
			float num2 = 8f;
			float num3 = Mathf.Max(40f, num - num2 * 2f);
			float num4 = 0f;
			float num5 = 0f;
			if ((Object)(object)_inventoryHoverTooltipTopic != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipTopic))
			{
				TMP_Text inventoryHoverTooltipTopic = _inventoryHoverTooltipTopic;
				((Component)inventoryHoverTooltipTopic).gameObject.SetActive(!string.IsNullOrWhiteSpace(inventoryHoverTooltipTopic.text));
				inventoryHoverTooltipTopic.rectTransform.SetSizeWithCurrentAnchors((Axis)0, num3);
				inventoryHoverTooltipTopic.ForceMeshUpdate(true, false);
				num4 = (((Component)inventoryHoverTooltipTopic).gameObject.activeSelf ? Mathf.Max(28f, inventoryHoverTooltipTopic.preferredHeight) : 0f);
			}
			if ((Object)(object)_inventoryHoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipText))
			{
				TMP_Text inventoryHoverTooltipText = _inventoryHoverTooltipText;
				EnsureInventoryHoverTooltipTextScrollContent(panel, inventoryHoverTooltipText);
				((Component)inventoryHoverTooltipText).gameObject.SetActive(!string.IsNullOrWhiteSpace(inventoryHoverTooltipText.text));
				inventoryHoverTooltipText.rectTransform.SetSizeWithCurrentAnchors((Axis)0, num3);
				inventoryHoverTooltipText.ForceMeshUpdate(true, false);
				num5 = (((Component)inventoryHoverTooltipText).gameObject.activeSelf ? GetInventoryHoverTooltipPreferredTextHeight(inventoryHoverTooltipText, num3) : 0f);
			}
			float num6 = LayoutInventoryHoverTooltipExtraScrollContent(panel, num3, num5);
			float num7 = num5 + num6;
			float num8 = num2 + num4 + ((num4 > 0f && num7 > 0f) ? 6f : 0f);
			float num9 = GetInventoryHoverTooltipMaxPanelHeight() - num8 - num2;
			float inventoryHoverTooltipScrollbarThresholdHeight = GetInventoryHoverTooltipScrollbarThresholdHeight();
			float num10 = Mathf.Max(80f, Mathf.Min(num9, inventoryHoverTooltipScrollbarThresholdHeight));
			float num11 = ((num7 > 0f) ? Mathf.Min(num7, num10) : 0f);
			float num12 = num8 + num11 + num2;
			SetTopLeftRectLayout(panel, panel.anchoredPosition, new Vector2(num, num12));
			if ((Object)(object)_inventoryHoverTooltipTopic != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipTopic))
			{
				LayoutInventoryHoverTooltipTextRect(_inventoryHoverTooltipTopic.rectTransform, num2, num2, num4);
			}
			if ((Object)(object)_inventoryHoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltipText))
			{
				LayoutInventoryHoverTooltipTextScroll(panel, num3, num2, num8, num11, num7);
			}
			_inventoryHoverTooltipLayoutSignature = GetInventoryHoverTooltipLayoutSignature(panel);
		}

		private static string GetInventoryHoverTooltipLayoutSignature(RectTransform panel)
		{
			return string.Join("|", _inventoryHoverTooltipSignature, _inventoryHoverJewelcraftingTooltipSignature, Screen.width.ToString(), Screen.height.ToString(), ((Transform)panel).childCount.ToString(), GetInventoryHoverTooltipMaxPanelHeight().ToString("0.###"), GetInventoryHoverTooltipScrollbarThresholdHeight().ToString("0.###"));
		}

		private static float LayoutInventoryHoverTooltipExtraScrollContent(RectTransform panel, float textWidth, float textHeight)
		{
			//IL_0073: 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_008e: 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)
			RectTransform inventoryHoverJewelcraftingTooltipRoot = _inventoryHoverJewelcraftingTooltipRoot;
			RectTransform content = InventoryHoverTooltipTextScroll.Content;
			if ((Object)(object)inventoryHoverJewelcraftingTooltipRoot == (Object)null || IsUnityNull((Object?)(object)inventoryHoverJewelcraftingTooltipRoot) || !((Component)inventoryHoverJewelcraftingTooltipRoot).gameObject.activeSelf || (Object)(object)content == (Object)null || IsUnityNull((Object?)(object)content) || !((Transform)inventoryHoverJewelcraftingTooltipRoot).IsChildOf((Transform)(object)panel))
			{
				return 0f;
			}
			if ((Object)(object)((Transform)inventoryHoverJewelcraftingTooltipRoot).parent != (Object)(object)content)
			{
				((Transform)inventoryHoverJewelcraftingTooltipRoot).SetParent((Transform)(object)content, false);
			}
			SetTopLeftRectLayout(inventoryHoverJewelcraftingTooltipRoot, new Vector2(0f, 0f - textHeight - 12f), new Vector2(textWidth, Mathf.Max(1f, inventoryHoverJewelcraftingTooltipRoot.sizeDelta.y)));
			((Transform)inventoryHoverJewelcraftingTooltipRoot).SetAsLastSibling();
			float num = LayoutJewelcraftingNativeTooltip(inventoryHoverJewelcraftingTooltipRoot, textWidth);
			inventoryHoverJewelcraftingTooltipRoot.sizeDelta = new Vector2(textWidth, num);
			if (!(num > 0f))
			{
				return 0f;
			}
			return num + 12f;
		}

		private static RectTransform EnsureInventoryHoverTooltipTextScrollContent(RectTransform panel, TMP_Text text)
		{
			return ScrollableTooltipBody.Ensure(panel, text, InventoryHoverTooltipTextScroll, GetSolidUiSprite(), 120f, scrollRectEnabled: false, inertia: false, handleRaycastTarget: false, scrollbarRaycastTarget: false);
		}

		private static void LayoutInventoryHoverTooltipTextScroll(RectTransform panel, float textWidth, float padding, float top, float viewportHeight, float contentHeight)
		{
			if (!((Object)(object)_inventoryHoverTooltipText == (Object)null) && !IsUnityNull((Object?)(object)_inventoryHoverTooltipText))
			{
				EnsureInventoryHoverTooltipTextScrollContent(panel, _inventoryHoverTooltipText);
				ScrollableTooltipBodyLayoutResult scrollableTooltipBodyLayoutResult = ScrollableTooltipBody.LayoutPixelScroll(InventoryHoverTooltipTextScroll, _inventoryHoverTooltipText, textWidth, padding, top, viewportHeight, contentHeight, _inventoryHoverTooltipScrollOffset, 2f, 3f, enableScrollRectWhenNeeded: false);
				_inventoryHoverTooltipScrollOffset = scrollableTooltipBodyLayoutResult.ScrollOffset;
				_inventoryHoverTooltipMaxScroll = scrollableTooltipBodyLayoutResult.MaxScroll;
				_inventoryHoverTooltipNeedsScroll = scrollableTooltipBodyLayoutResult.NeedsScroll;
			}
		}

		private static void HandleInventoryContainerHoverTooltipWheel()
		{
			if (_inventoryHoverTooltipNeedsScroll)
			{
				float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Continuous);
				if (!(Mathf.Abs(uiScrollDelta) < 0.01f))
				{
					_inventoryHoverTooltipScrollOffset = Mathf.Clamp(_inventoryHoverTooltipScrollOffset - uiScrollDelta * 120f, 0f, _inventoryHoverTooltipMaxScroll);
					ApplyInventoryHoverTooltipScrollPosition();
				}
			}
		}

		private static void ApplyInventoryHoverTooltipScrollPosition()
		{
			ScrollableTooltipBody.ApplyPixelScrollPosition(InventoryHoverTooltipTextScroll, _inventoryHoverTooltipScrollOffset, _inventoryHoverTooltipMaxScroll);
		}

		private static void HideInventoryContainerCustomTooltipVisual()
		{
			if ((Object)(object)_inventoryHoverTooltip != (Object)null && !IsUnityNull((Object?)(object)_inventoryHoverTooltip))
			{
				_inventoryHoverTooltip.SetActive(false);
			}
		}

		private static void HideInventoryContainerCustomTooltip()
		{
			HideInventoryContainerCustomTooltipVisual();
			HideInventoryHoverJewelcraftingTooltip();
			_inventoryHoverTooltipNeedsScroll = false;
			_inventoryHoverTooltipMaxScroll = 0f;
			_inventoryHoverTooltipScrollOffset = 0f;
			_inventoryHoverTooltipSignature = "";
			_inventoryHoverTooltipLayoutSignature = "";
		}

		private static bool IsSimpleInventorySlotsNameTooltip(UITooltip tooltip)
		{
			if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip))
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(LocalizeTooltipText(GetInventoryContainerHoverTooltipTopic(tooltip))))
			{
				return string.IsNullOrWhiteSpace(LocalizeTooltipText(GetInventoryContainerHoverTooltipBody(tooltip)));
			}
			return false;
		}

		private static void UpdateInventorySimpleNameTooltip(UITooltip tooltip)
		{
			string text = LocalizeTooltipText(GetInventoryContainerHoverTooltipTopic(tooltip));
			UpdateSimpleNameTooltipText(tooltip, text);
		}

		internal static void ShowPinnedGemNameTooltip(object owner, string displayName)
		{
			_pinnedGemNameTooltipOwner = owner;
			_pinnedGemNameTooltipHoldUntil = Time.unscaledTime + 1f;
			ShowSimpleNameTooltip(owner, displayName, "", SimpleNameTooltipPlacement.LeftOfCursor);
		}

		internal static void HidePinnedGemNameTooltip(object owner)
		{
			if (_pinnedGemNameTooltipOwner == owner)
			{
				_pinnedGemNameTooltipOwner = null;
				_pinnedGemNameTooltipHoldUntil = -1000f;
			}
			HideSimpleNameTooltip(owner);
		}

		internal static void ShowSimpleNameTooltip(string topic, string text = "")
		{
			ShowSimpleNameTooltip(InventorySimpleNameTooltipFallbackOwner, topic, text);
		}

		internal static void ShowSimpleNameTooltip(object owner, string topic, string text = "")
		{
			ShowSimpleNameTooltip(owner, topic, text, SimpleNameTooltipPlacement.RightOfCursor);
		}

		private static void ShowSimpleNameTooltip(object owner, string topic, string text, SimpleNameTooltipPlacement placement)
		{
			string text2 = LocalizeTooltipText(topic);
			string text3 = LocalizeTooltipText(text);
			string text4 = (string.IsNullOrWhiteSpace(text3) ? text2 : (text2 + "\n" + text3));
			UpdateSimpleNameTooltipText(owner, text4, placement);
		}

		internal static void HideSimpleNameTooltip()
		{
			HideSimpleNameTooltip(InventorySimpleNameTooltipFallbackOwner);
		}

		internal static void HideSimpleNameTooltip(object owner)
		{
			HideInventorySimpleNameTooltip(owner);
		}

		private static void UpdateSimpleNameTooltipText(object owner, string text)
		{
			UpdateSimpleNameTooltipText(owner, text, SimpleNameTooltipPlacement.RightOfCursor);
		}

		private static void UpdateSimpleNameTooltipText(object owner, string text, SimpleNameTooltipPlacement placement)
		{
			//IL_011e: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(text))
			{
				HideInventorySimpleNameTooltip(owner);
				return;
			}
			GameObject val = EnsureInventorySimpleNameTooltip();
			RectTransform inventorySimpleNameTooltipRect = _inventorySimpleNameTooltipRect;
			TMP_Text inventorySimpleNameTooltipText = _inventorySimpleNameTooltipText;
			if (!((Object)(object)val == (Object)null) && !((Object)(object)inventorySimpleNameTooltipRect == (Object)null) && !IsUnityNull((Object?)(object)inventorySimpleNameTooltipRect) && !((Object)(object)inventorySimpleNameTooltipText == (Object)null) && !IsUnityNull((Object?)(object)inventorySimpleNameTooltipText))
			{
				bool num = !InventorySimpleNameTooltipOwner.Visible || InventorySimpleNameTooltipOwner.Owner != owner || !string.Equals(_inventorySimpleNameTooltipValue, text, StringComparison.Ordinal) || _inventorySimpleNameTooltipPlacement != placement;
				InventorySimpleNameTooltipOwner.Show(owner);
				val.SetActive(true);
				if (num)
				{
					inventorySimpleNameTooltipText.text = text;
					inventorySimpleNameTooltipText.ForceMeshUpdate(true, true);
					Vector2 preferredValues = inventorySimpleNameTooltipText.GetPreferredValues(text, 320f, 0f);
					float num2 = Mathf.Clamp(Mathf.Ceil(preferredValues.x) + 8f, 24f, 340f);
					float num3 = Mathf.Clamp(Mathf.Ceil(preferredValues.y) + 4f, 18f, 96f);
					inventorySimpleNameTooltipRect.sizeDelta = new Vector2(num2, num3);
					_inventorySimpleNameTooltipValue = text;
					_inventorySimpleNameTooltipPlacement = placement;
				}
				inventorySimpleNameTooltipRect.anchorMin = new Vector2(0f, 1f);
				inventorySimpleNameTooltipRect.anchorMax = new Vector2(0f, 1f);
				inventorySimpleNameTooltipRect.pivot = new Vector2(0f, 1f);
				((Transform)inventorySimpleNameTooltipRect).position = GetSimpleNameTooltipPosition(inventorySimpleNameTooltipRect.sizeDelta.x, placement);
				Utils.ClampUIToScreen(inventorySimpleNameTooltipRect);
				((Transform)inventorySimpleNameTooltipRect).SetAsLastSibling();
				RectTransform rectTransform = inventorySimpleNameTooltipText.rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
			}
		}

		private static Vector3 GetSimpleNameTooltipPosition(float width, SimpleNameTooltipPlacement placement)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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)
			if (placement != SimpleNameTooltipPlacement.LeftOfCursor)
			{
				return ZInput.mousePosition + new Vector3(14f, 16f, 0f);
			}
			return ZInput.mousePosition + new Vector3(0f - width - 14f, 16f, 0f);
		}

		private static GameObject? EnsureInventorySimpleNameTooltip(UITooltip? tooltip = null)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_012d: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_inventorySimpleNameTooltip != (Object)null && !IsUnityNull((Object?)(object)_inventorySimpleNameTooltip) && (Object)(object)_inventorySimpleNameTooltipRect != (Object)null && !IsUnityNull((Object?)(object)_inventorySimpleNameTooltipRect) && (Object)(object)_inventorySimpleNameTooltipText != (Object)null && !IsUnityNull((Object?)(object)_inventorySimpleNameTooltipText))
			{
				return _inventorySimpleNameTooltip;
			}
			InventoryGui instance = InventoryGui.instance;
			Canvas val = (((Object)(object)instance != (Object)null) ? ((Component)instance).GetComponentInParent<Canvas>() : (((Object)(object)tooltip != (Object)null) ? ((Component)tooltip).GetComponentInParent<Canvas>() : null));
			Transform val2 = (((Object)(object)instance != (Object)null && !IsUnityNull((Object?)(object)instance)) ? ((Component)instance).transform.root : (((Object)(object)tooltip != (Object)null && !IsUnityNull((Object?)(object)tooltip)) ? ((Component)tooltip).transform.root : null));
			Transform val3 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : val2);
			if ((Object)(object)val3 == (Object)null)
			{
				return null;
			}
			_inventorySimpleNameTooltip = new GameObject("InventorySlots_SimpleNameTooltip", new Type[1] { typeof(RectTransform) });
			_inventorySimpleNameTooltip.transform.SetParent(val3, false);
			_inventorySimpleNameTooltip.SetActive(false);
			RectTransform component = _inventorySimpleNameTooltip.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			((Transform)component).localScale = Vector3.one;
			((Transform)component).localRotation = Quaternion.identity;
			CreateTextRect("Text", (Transform)(object)component, out TMP_Text text);
			text.alignment = (TextAlignmentOptions)514;
			text.fontSize = 16f;
			((Graphic)text).color = Color.white;
			text.outlineColor = new Color32((byte)0, (byte)0, (byte)0, (byte)230);
			text.outlineWidth = 0.18f;
			text.textWrappingMode = (TextWrappingModes)1;
			text.overflowMode = (TextOverflowModes)0;
			((Graphic)text).raycastTarget = false;
			_inventorySimpleNameTooltipRect = component;
			_inventorySimpleNameTooltipText = text;
			return _inventorySimpleNameTooltip;
		}

		private static void HideInventorySimpleNameTooltip(object owner)
		{
			if (InventorySimpleNameTooltipOwner.Hide(owner))
			{
				if ((Object)(object)_inventorySimpleNameTooltip != (Object)null && !IsUnityNull((Object?)(object)_inventorySimpleNameTooltip))
				{
					_inventorySimpleNameTooltip.SetActive(false);
				}
				_inventorySimpleNameTooltipValue = "";
			}
		}

		private static void ForceHideInventorySimpleNameTooltip()
		{
			if (!ShouldPreservePinnedGemNameTooltip())
			{
				InventorySimpleNameTooltipOwner.ForceHide();
				if ((Object)(object)_inventorySimpleNameTooltip != (Object)null && !IsUnityNull((Object?)(object)_inventorySimpleNameTooltip))
				{
					_inventorySimpleNameTooltip.SetActive(false);
				}
				_inventorySimpleNameTooltipValue = "";
			}
		}

		private static bool ShouldPreservePinnedGemNameTooltip()
		{
			if (_pinnedGemNameTooltipOwner != null && Time.unscaledTime <= _pinnedGemNameTooltipHoldUntil && InventorySimpleNameTooltipOwner.Visible)
			{
				return InventorySimpleNameTooltipOwner.Owner == _pinnedGemNameTooltipOwner;
			}
			return false;
		}

		private static void ApplyInventoryContainerCustomTooltipBackground(Image? background, float alpha)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)background == (Object)null) && !IsUnityNull((Object?)(object)background))
			{
				background.sprite = GetSolidUiSprite();
				((Graphic)background).color = new Color(0f, 0f, 0f, Mathf.Clamp01(alpha));
				((Graphic)background).raycastTarget = false;
			}
		}

		private static void LayoutInventoryHoverTooltipTextRect(RectTransform rect, float horizontalPadding, float top, float height)
		{
			//IL_000b: 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_0029: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			SetRectLayout(rect, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, 0f - top), new Vector2((0f - horizontalPadding) * 2f, height));
		}

		private static string LocalizeTooltipText(string text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return "";
			}
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		private static float GetInventoryHoverTooltipPreferredTextHeight(TMP_Text text, float textWidth)
		{
			//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_001c: 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_0036: 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)
			Vector2 preferredValues = text.GetPreferredValues(text.text ?? "", textWidth, 0f);
			if (float.IsNaN(preferredValues.y) || float.IsInfinity(preferredValues.y) || preferredValues.y < 1f)
			{
				return Mathf.Max(1f, text.preferredHeight);
			}
			return Mathf.Max(1f, preferredValues.y);
		}

		private static float GetInventoryHoverTooltipMaxPanelHeight()
		{
			return Mathf.Clamp(((Screen.height > 0) ? ((float)Screen.height) : 720f) * 0.62f, 260f, 720f);
		}

		private static void RequestLocalInventoryState(InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!IsUnityNull((Object?)(object)localPlayer) && !localPlayer.m_isLoading)
			{
				RequestInventoryStateEnsure(localPlayer, reason, auditLevel);
			}
		}

		internal static void EnsureInventoryState(Player player, InventoryStateEnsureReason reason = InventoryStateEnsureReason.Unknown)
		{
			EnsureInventoryState(player, reason, GetDefaultInventoryStateAuditLevel(reason));
		}

		internal static void EnsureInventoryState(Player player, InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			if (IsUnityNull((Object?)(object)player))
			{
				return;
			}
			if (InventorySafety.EnsuringInventoryState)
			{
				QueuePendingInventoryEnsure(reason, auditLevel);
				return;
			}
			InventoryStateEnsureReason reason2 = reason;
			InventoryStateAuditLevel auditLevel2 = NormalizeAuditLevel(auditLevel, reason);
			PerformInventoryStateAudit(player, reason2, auditLevel2);
			if (ConsumePendingInventoryEnsure(out reason2, out auditLevel2) && !IsUnityNull((Object?)(object)player))
			{
				RequestInventoryStateEnsure(player, reason2, auditLevel2);
			}
		}

		internal static void RequestInventoryStateEnsure(Player? player, InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			if (!IsUnityNull((Object?)(object)player) && !player.m_isLoading)
			{
				InventorySafety.DeferredEnsureReason = MergeInventoryEnsureReasons(InventorySafety.DeferredEnsureReason, reason);
				InventorySafety.DeferredAuditLevel = MaxAuditLevel(InventorySafety.DeferredAuditLevel, NormalizeAuditLevel(auditLevel, reason));
				InventorySafety.DeferredEnsureFrame = Math.Max(InventorySafety.DeferredEnsureFrame, Time.frameCount + 1);
				MarkRecentInventoryActivityForHeavyAudit(reason);
			}
		}

		private static void MarkRecentInventoryActivityForHeavyAudit(InventoryStateEnsureReason reason)
		{
			bool flag;
			switch (reason)
			{
			case InventoryStateEnsureReason.InventoryChanged:
			case InventoryStateEnsureReason.EquipmentChanged:
			case InventoryStateEnsureReason.InventoryMove:
			case InventoryStateEnsureReason.SlotAction:
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag)
			{
				InventorySafety.HeavyAuditDelayUntil = Math.Max(InventorySafety.HeavyAuditDelayUntil, Time.time + 2f);
			}
		}

		private static bool IsSyncedStateReady()
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.IsSinglePlayer || ConfigSync.IsSourceOfTruth)
			{
				return true;
			}
			return ConfigSync.InitialSyncDone;
		}

		private static void ProcessDeferredInventoryStateEnsure(Player player)
		{
			if (InventorySafety.DeferredAuditLevel != InventoryStateAuditLevel.None && InventorySafety.DeferredEnsureReason != InventoryStateEnsureReason.Unknown && InventorySafety.DeferredEnsureFrame <= Time.frameCount)
			{
				InventoryStateEnsureReason deferredEnsureReason = InventorySafety.DeferredEnsureReason;
				InventoryStateAuditLevel deferredAuditLevel = InventorySafety.DeferredAuditLevel;
				InventorySafety.DeferredEnsureReason = InventoryStateEnsureReason.Unknown;
				InventorySafety.DeferredAuditLevel = InventoryStateAuditLevel.None;
				InventorySafety.DeferredEnsureFrame = -1;
				EnsureInventoryState(player, deferredEnsureReason, deferredAuditLevel);
			}
		}

		private static void PerformInventoryStateAudit(Player player, InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			InventoryStateAuditLevel inventoryStateAuditLevel = NormalizeAuditLevel(auditLevel, reason);
			InventorySafety.PendingEnsureReason = InventoryStateEnsureReason.Unknown;
			InventorySafety.PendingAuditLevel = InventoryStateAuditLevel.None;
			InventorySafety.EnsuringInventoryState = true;
			bool suppressKnownItemRediscovery = InventorySafety.SuppressKnownItemRediscovery;
			try
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				if (inventory == null)
				{
					return;
				}
				bool flag = HasPendingQuickSlotProgressionReset(player);
				InventorySafety.SuppressKnownItemRediscovery |= flag;
				bool flag2 = IsSyncedStateReady();
				int fullHeightForWidth = GetFullHeightForWidth(inventory.m_width);
				bool flag3 = false;
				if (inventory.m_height < fullHeightForWidth)
				{
					inventory.m_height = fullHeightForWidth;
					flag3 = true;
				}
				bool changed;
				int num = EnsureForeignSlotItemsPreserved(player, inventory, fullHeightForWidth, inventoryStateAuditLevel >= InventoryStateAuditLevel.FullIntegrity && flag2, ShouldWarnLockedRowsDuringAudit(reason), out changed);
				flag3 = flag3 || changed;
				bool flag4 = reason != InventoryStateEnsureReason.PlayerAwake && reason != InventoryStateEnsureReason.PlayerLoad && reason != InventoryStateEnsureReason.InventoryLoad && reason != InventoryStateEnsureReason.BackupRestore;
				if (flag && flag4 && inventoryStateAuditLevel >= InventoryStateAuditLevel.FullIntegrity && flag2)
				{
					flag3 |= ReconcilePendingQuickSlotProgressionReset(player, inventory);
				}
				if (inventory.m_height != num)
				{
					inventory.m_height = num;
					flag3 = true;
				}
				if (flag3)
				{
					inventory.Changed();
				}
				Container val = (((Object)(object)player.m_tombstone != (Object)null) ? player.m_tombstone.GetComponent<Container>() : null);
				if ((Object)(object)val != (Object)null && val.m_height < num)
				{
					val.m_height = num;
				}
				if (inventoryStateAuditLevel >= InventoryStateAuditLevel.FullIntegrity && flag2)
				{
					if (ShouldRunFullIntegrityValidation(reason, player, inventory))
					{
						ValidateAndProjectInventory(player, inventory);
						RefreshInventoryStateSignature(player, inventory);
						RefreshSlotLightProjectionSignature(player, inventory);
					}
					else
					{
						ProjectSlotDisplayState(player, inventory);
						RefreshSlotLightProjectionSignature(player, inventory);
					}
				}
				else if (inventoryStateAuditLevel >= InventoryStateAuditLevel.SlotLight && flag2)
				{
					int signature = ComputeSlotLightProjectionSignature(player, inventory);
					if (flag3 || !CanSkipSlotLightProjection(signature))
					{
						if (ProjectSlotDisplayState(player, inventory))
						{
							signature = ComputeSlotLightProjectionSignature(player, inventory);
						}
						RememberSlotLightProjectionSignature(signature);
					}
				}
				if (inventoryStateAuditLevel >= InventoryStateAuditLevel.SlotLight)
				{
					UpdateCustomEquipmentVisuals(player);
				}
			}
			finally
			{
				InventorySafety.SuppressKnownItemRediscovery = suppressKnownItemRediscovery;
				InventorySafety.EnsuringInventoryState = false;
			}
		}

		private static void QueuePendingInventoryEnsure(InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			if (reason != InventoryStateEnsureReason.Unknown)
			{
				InventorySafety.PendingEnsureReason = MergeInventoryEnsureReasons(InventorySafety.PendingEnsureReason, reason);
				InventorySafety.PendingAuditLevel = MaxAuditLevel(InventorySafety.PendingAuditLevel, NormalizeAuditLevel(auditLevel, reason));
			}
		}

		private static bool ConsumePendingInventoryEnsure(out InventoryStateEnsureReason reason, out InventoryStateAuditLevel auditLevel)
		{
			reason = InventorySafety.PendingEnsureReason;
			auditLevel = InventorySafety.PendingAuditLevel;
			InventorySafety.PendingEnsureReason = InventoryStateEnsureReason.Unknown;
			InventorySafety.PendingAuditLevel = InventoryStateAuditLevel.None;
			if (reason == InventoryStateEnsureReason.Unknown)
			{
				auditLevel = InventoryStateAuditLevel.None;
				return false;
			}
			auditLevel = NormalizeAuditLevel(auditLevel, reason);
			return true;
		}

		private static InventoryStateAuditLevel GetDefaultInventoryStateAuditLevel(InventoryStateEnsureReason reason)
		{
			return reason switch
			{
				InventoryStateEnsureReason.PeriodicAudit => InventoryStateAuditLevel.FullIntegrity, 
				InventoryStateEnsureReason.InventoryChanged => InventoryStateAuditLevel.SlotLight, 
				InventoryStateEnsureReason.EquipmentChanged => InventoryStateAuditLevel.SlotLight, 
				InventoryStateEnsureReason.InventoryMove => InventoryStateAuditLevel.SlotLight, 
				InventoryStateEnsureReason.GuiShow => InventoryStateAuditLevel.FullIntegrity, 
				InventoryStateEnsureReason.SlotAction => InventoryStateAuditLevel.SlotLight, 
				_ => InventoryStateAuditLevel.FullIntegrity, 
			};
		}

		private static bool ShouldRunFullIntegrityValidation(InventoryStateEnsureReason reason, Player player, Inventory inventory)
		{
			if (MustRunFullIntegrityValidation(reason))
			{
				return true;
			}
			return HasInventoryStateSignatureChanged(player, inventory);
		}

		private static bool MustRunFullIntegrityValidation(InventoryStateEnsureReason reason)
		{
			switch (reason)
			{
			case InventoryStateEnsureReason.PlayerAwake:
			case InventoryStateEnsureReason.PlayerSpawned:
			case InventoryStateEnsureReason.PlayerLoad:
			case InventoryStateEnsureReason.PlayerSave:
			case InventoryStateEnsureReason.InventoryLoad:
			case InventoryStateEnsureReason.Tombstone:
			case InventoryStateEnsureReason.BackupRestore:
			case InventoryStateEnsureReason.YamlReload:
			case InventoryStateEnsureReason.JewelcraftingSlotRefresh:
			case InventoryStateEnsureReason.ProgressionReset:
			case InventoryStateEnsureReason.ConfigChanged:
			case InventoryStateEnsureReason.ReentrantFollowUp:
				return true;
			default:
				return false;
			}
		}

		private static bool ShouldWarnLockedRowsDuringAudit(InventoryStateEnsureReason reason)
		{
			if (reason != InventoryStateEnsureReason.PlayerAwake && reason != InventoryStateEnsureReason.PlayerSpawned && reason != InventoryStateEnsureReason.PlayerLoad && reason != InventoryStateEnsureReason.InventoryLoad)
			{
				return reason != InventoryStateEnsureReason.BackupRestore;
			}
			return false;
		}

		private static InventoryStateAuditLevel NormalizeAuditLevel(InventoryStateAuditLevel auditLevel, InventoryStateEnsureReason reason)
		{
			if (auditLevel != InventoryStateAuditLevel.None)
			{
				return auditLevel;
			}
			return GetDefaultInventoryStateAuditLevel(reason);
		}

		private static InventoryStateAuditLevel MaxAuditLevel(InventoryStateAuditLevel current, InventoryStateAuditLevel next)
		{
			if (current < next)
			{
				return next;
			}
			return current;
		}

		private static InventoryStateEnsureReason MergeInventoryEnsureReasons(InventoryStateEnsureReason current, InventoryStateEnsureReason next)
		{
			if (current == InventoryStateEnsureReason.Unknown || current == next)
			{
				return next;
			}
			if (next != InventoryStateEnsureReason.Unknown)
			{
				return InventoryStateEnsureReason.ReentrantFollowUp;
			}
			return current;
		}

		private static bool ProjectSlotDisplayState(Player player, Inventory inventory)
		{
			bool flag = false;
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (slotDefinition.Kind != SlotKind.Quick)
				{
					ItemData val = FindItemForSlotIncludingGridCandidate(player, inventory, slotDefinition);
					if (val != null)
					{
						flag |= RestoreSlotEquipmentState(player, inventory, val, slotDefinition);
					}
				}
			}
			if (flag)
			{
				inventory.Changed();
				RefreshExternalEquipmentEffects(player);
			}
			return flag;
		}

		internal static bool ShouldSuppressKnownItemRediscovery(Player player)
		{
			if (InventorySafety.SuppressKnownItemRediscovery)
			{
				return (Object)(object)player == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}

		private static bool HasInventoryStateSignatureChanged(Player player, Inventory inventory)
		{
			return ComputeInventoryStateSignature(player, inventory) != InventorySafety.LastFullIntegrityAuditSignature;
		}

		private static void RefreshInventoryStateSignature(Player player, Inventory inventory)
		{
			InventorySafety.LastFullIntegrityAuditSignature = ComputeInventoryStateSignature(player, inventory);
		}

		private static bool CanSkipSlotLightProjection(int signature)
		{
			if (InventorySafety.LastSlotLightProjectionSignature != int.MinValue)
			{
				return InventorySafety.LastSlotLightProjectionSignature == signature;
			}
			return false;
		}

		private static void RefreshSlotLightProjectionSignature(Player player, Inventory inventory)
		{
			InventorySafety.LastSlotLightProjectionSignature = ComputeSlotLightProjectionSignature(player, inventory);
		}

		private static void RememberSlotLightProjectionSignature(int signature)
		{
			InventorySafety.LastSlotLightProjectionSignature = signature;
		}

		private static int ComputeSlotLightProjectionSignature(Player player, Inventory inventory)
		{
			int num = 17;
			num = num * 31 + StringComparer.Ordinal.GetHashCode(GetPlayerId(player));
			num = num * 31 + inventory.m_width;
			num = num * 31 + inventory.m_height;
			num = num * 31 + GetUsableRegularRows(player);
			num = num * 31 + InventoryDefinitions.SlotDefinitionVersion;
			num = num * 31 + GetKnownMaterialHash(player);
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (slotDefinition.Kind != SlotKind.Quick)
				{
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(slotDefinition.Id);
					num = (int)(num * 31 + slotDefinition.Kind);
				}
			}
			AddEquippedItemSignature(((Humanoid)player).m_helmetItem, ref num);
			AddEquippedItemSignature(((Humanoid)player).m_chestItem, ref num);
			AddEquippedItemSignature(((Humanoid)player).m_legItem, ref num);
			AddEquippedItemSignature(((Humanoid)player).m_shoulderItem, ref num);
			AddEquippedItemSignature(((Humanoid)player).m_utilityItem, ref num);
			AddEquippedItemSignature(((Humanoid)player).m_trinketItem, ref num);
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && HasSlotLightProjectionState(item))
				{
					AddItemProjectionSignature(item, ref num);
				}
			}
			return num;
		}

		private static bool HasSlotLightProjectionState(ItemData item)
		{
			if (!item.m_customData.ContainsKey("InventorySlotsSlotId"))
			{
				return item.m_customData.ContainsKey("InventorySlotsEquippedBy");
			}
			return true;
		}

		private static void AddEquippedItemSignature(ItemData? item, ref int hash)
		{
			if (item == null)
			{
				hash *= 31;
			}
			else
			{
				AddItemProjectionSignature(item, ref hash);
			}
		}

		private static void AddItemProjectionSignature(ItemData item, ref int hash)
		{
			hash = hash * 31 + RuntimeHelpers.GetHashCode(item);
			hash = hash * 31 + item.m_gridPos.x;
			hash = hash * 31 + item.m_gridPos.y;
			hash = hash * 31 + item.m_quality;
			hash = hash * 31 + item.m_variant;
			hash = hash * 31 + (item.m_equipped ? 1 : 0);
			string itemPrefabName = GetItemPrefabName(item);
			if (!string.IsNullOrEmpty(itemPrefabName))
			{
				hash = hash * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(itemPrefabName);
			}
			if (item.m_customData.TryGetValue("InventorySlotsSlotId", out var value))
			{
				hash = hash * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(value);
			}
			if (item.m_customData.TryGetValue("InventorySlotsEquippedBy", out var value2))
			{
				hash = hash * 31 + StringComparer.Ordinal.GetHashCode(value2);
			}
		}

		private static int ComputeInventoryStateSignature(Player player, Inventory inventory)
		{
			int num = 17;
			num = num * 31 + inventory.m_width;
			num = num * 31 + inventory.m_height;
			num = num * 31 + SlotDefinitions.Count;
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(slotDefinition.Id);
				num = (int)(num * 31 + slotDefinition.Kind);
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null)
				{
					num = num * 31 + item.m_gridPos.x;
					num = num * 31 + item.m_gridPos.y;
					num = num * 31 + item.m_stack;
					num = num * 31 + item.m_quality;
					num = num * 31 + (item.m_equipped ? 1 : 0);
					string itemPrefabName = GetItemPrefabName(item);
					if (!string.IsNullOrEmpty(itemPrefabName))
					{
						num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(itemPrefabName);
					}
					if (item.m_customData != null && item.m_customData.TryGetValue("InventorySlotsSlotId", out var value))
					{
						num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(value);
					}
				}
			}
			return num;
		}

		private static void ValidateAndProjectInventory(Player player, Inventory inventory)
		{
			//IL_0063: 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_009a: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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_020b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			List<ItemData> list = new List<ItemData>(inventory.m_inventory.Count);
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null)
				{
					list.Add(item);
				}
			}
			foreach (ItemData item2 in list)
			{
				if (IsExternalReservedCell(item2.m_gridPos, includeRestockableSlots: true))
				{
					continue;
				}
				if (IsOutOfBounds(inventory, item2.m_gridPos))
				{
					if (TryMoveToFirstFreeRegularCell(player, inventory, item2))
					{
						flag = true;
					}
				}
				else
				{
					if (IsLockedRowCell(player, item2.m_gridPos) || !TryGetSlotAtGridPos(inventory, item2.m_gridPos, out SlotDefinition slot) || slot == null || !IsSpecialSlotUnlocked(player, inventory, slot))
					{
						continue;
					}
					if (!slot.Accepts(item2))
					{
						if ((!TryGetCanonicalEquippedSlot(player, inventory, item2, out SlotDefinition slot2) || slot2 == slot) && TryReleaseItemToRegularInventory(player, inventory, item2, "slot '" + slot.Id + "' no longer accepts it"))
						{
							flag = true;
						}
					}
					else if (!InventorySafety.SuppressSlotAutoEquip && CanAutoAdoptGridSlot(item2, slot) && FindItemForSlot(player, inventory, slot) != item2 && TryEquipIntoSlot(player, inventory, item2, slot))
					{
						flag = true;
					}
				}
			}
			flag |= ResolveOverlappingItems(player, inventory);
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				ItemData val = FindItemForSlotIncludingGridCandidate(player, inventory, slotDefinition);
				if (val == null)
				{
					continue;
				}
				Vector2i slotGridPos = GetSlotGridPos(inventory, slotDefinition);
				ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
				if (itemAt != null && itemAt != val)
				{
					if (TryMoveBlockingItemToCanonicalSlot(player, inventory, itemAt, val, slotDefinition))
					{
						flag = true;
					}
					else
					{
						if (!TryReleaseItemToRegularInventory(player, inventory, itemAt, "it blocks slot '" + slotDefinition.Id + "'"))
						{
							continue;
						}
						flag = true;
					}
				}
				if (val.m_gridPos != slotGridPos)
				{
					val.m_gridPos = slotGridPos;
					flag = true;
				}
				flag |= RestoreSlotEquipmentState(player, inventory, val, slotDefinition);
			}
			if (flag | ClearMissingCustomEquipment(player, inventory))
			{
				inventory.Changed();
				RefreshExternalEquipmentEffects(player);
			}
		}

		private static bool TryGetCanonicalEquippedSlot(Player player, Inventory inventory, ItemData item, out SlotDefinition? slot)
		{
			slot = null;
			if ((Object)(object)player == (Object)null || inventory == null || item == null || !inventory.ContainsItem(item))
			{
				return false;
			}
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (slotDefinition.Kind != SlotKind.Quick && CanUseSpecialSlot(player, inventory, item, slotDefinition) && FindItemForSlotIncludingGridCandidate(player, inventory, slotDefinition) == item)
				{
					slot = slotDefinition;
					return true;
				}
			}
			return false;
		}

		private static bool TryMoveBlockingItemToCanonicalSlot(Player player, Inventory inventory, ItemData blocking, ItemData incoming, SlotDefinition incomingSlot)
		{
			//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_001f: 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_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_004b: 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 (!TryGetCanonicalEquippedSlot(player, inventory, blocking, out SlotDefinition slot) || slot == null || slot == incomingSlot)
			{
				return false;
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
			if (itemAt != null && itemAt != incoming)
			{
				return false;
			}
			if (blocking.m_gridPos == slotGridPos)
			{
				return false;
			}
			blocking.m_gridPos = slotGridPos;
			return true;
		}

		private static bool ResolveOverlappingItems(Player player, Inventory inventory)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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)
			bool result = false;
			int num = 0;
			int num2 = 0;
			Dictionary<Vector2i, List<ItemData>> dictionary = new Dictionary<Vector2i, List<ItemData>>();
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && !IsOutOfBounds(inventory, item.m_gridPos))
				{
					if (!dictionary.TryGetValue(item.m_gridPos, out var value))
					{
						value = new List<ItemData>(2);
						dictionary[item.m_gridPos] = value;
					}
					value.Add(item);
				}
			}
			foreach (KeyValuePair<Vector2i, List<ItemData>> item2 in dictionary)
			{
				if (item2.Value.Count <= 1)
				{
					continue;
				}
				Vector2i key = item2.Key;
				if (IsExternalReservedCell(key, includeRestockableSlots: true))
				{
					continue;
				}
				List<ItemData> value2 = item2.Value;
				ItemData val = SelectOverlapKeeper(player, inventory, key, value2);
				foreach (ItemData item3 in value2)
				{
					if (item3 != val)
					{
						if (TryRelocateOverlappingItem(player, inventory, item3))
						{
							num++;
							result = true;
						}
						else if (TryMoveOverlappingItemToOverflowPreservationCell(inventory, item3))
						{
							num++;
							result = true;
						}
						else
						{
							num2++;
						}
					}
				}
			}
			return result;
		}

		private static ItemData SelectOverlapKeeper(Player player, Inventory inventory, Vector2i position, List<ItemData> items)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetSlotAtGridPos(inventory, position, out SlotDefinition slot))
			{
				ItemData val = FindItemForSlotIncludingGridCandidate(player, inventory, slot);
				if (val != null && items.Contains(val) && slot.Accepts(val))
				{
					return val;
				}
				foreach (ItemData item in items)
				{
					if (slot.Accepts(item))
					{
						return item;
					}
				}
			}
			return items[0];
		}

		private static bool TryRelocateOverlappingItem(Player player, Inventory inventory, ItemData item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition slot) && slot.Kind == SlotKind.Quick)
			{
				return TryMoveOverlappingQuickSlotItemToEmptyQuickSlot(player, inventory, item);
			}
			if (TryGetCanonicalEquippedSlot(player, inventory, item, out SlotDefinition slot2) && slot2 != null)
			{
				Vector2i slotGridPos = GetSlotGridPos(inventory, slot2);
				if (CanUseCell(player, inventory, item, slotGridPos) && CellContainsOnly(inventory, slotGridPos, item))
				{
					item.m_gridPos = slotGridPos;
					return true;
				}
			}
			return TryMoveToFirstFreeRegularCell(player, inventory, item);
		}

		private static bool TryMoveOverlappingItemToOverflowPreservationCell(Inventory inventory, ItemData item)
		{
			//IL_009b: 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_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)
			if (inventory == null || item == null || !inventory.ContainsItem(item))
			{
				return false;
			}
			InventorySlotSafetyCore.GridCell gridCell = InventorySlotSafetyCore.SelectNonOverlappingPreservationCell(inventory.GetWidth(), inventory.GetHeight(), new InventorySlotSafetyCore.GridCell(item.m_gridPos.x, item.m_gridPos.y), delegate(int x, int y)
			{
				foreach (ItemData item2 in inventory.m_inventory)
				{
					if (item2 != null && item2 != item && item2.m_gridPos.x == x && item2.m_gridPos.y == y)
					{
						return true;
					}
				}
				return false;
			});
			Vector2i val = default(Vector2i);
			((Vector2i)(ref val))..ctor(gridCell.X, gridCell.Y);
			if (val == item.m_gridPos)
			{
				return false;
			}
			item.m_gridPos = val;
			return true;
		}

		private static bool TryMoveOverlappingQuickSlotItemToEmptyQuickSlot(Player player, Inventory inventory, ItemData item)
		{
			//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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0051: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (slotDefinition.Kind == SlotKind.Quick && CanUseSpecialSlot(player, inventory, item, slotDefinition))
				{
					Vector2i slotGridPos = GetSlotGridPos(inventory, slotDefinition);
					if (!(slotGridPos == item.m_gridPos) && CanUseCell(player, inventory, item, slotGridPos) && inventory.GetItemAt(slotGridPos.x, slotGridPos.y) == null)
					{
						item.m_gridPos = slotGridPos;
						return true;
					}
				}
			}
			return false;
		}

		private static bool ClearMissingCustomEquipment(Player player, Inventory inventory)
		{
			bool result = false;
			foreach (ItemData item in inventory.m_inventory)
			{
				if (IsInventorySlotsCustomEquipped(item) && (!TryGetSlotById(item.m_customData["InventorySlotsSlotId"], out SlotDefinition slot) || !slot.Accepts(item)))
				{
					string value;
					string text = (item.m_customData.TryGetValue("InventorySlotsSlotId", out value) ? value : "<missing>");
					if (TryReleaseItemToRegularInventory(player, inventory, item, "custom slot '" + text + "' no longer exists or no longer accepts it"))
					{
						result = true;
					}
				}
			}
			return result;
		}

		private static bool TryReleaseItemToRegularInventory(Player player, Inventory inventory, ItemData item, string reason)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (item == null || !inventory.ContainsItem(item))
			{
				return false;
			}
			if (IsUsableRegularCell(inventory, player, item.m_gridPos) && inventory.GetItemAt(item.m_gridPos.x, item.m_gridPos.y) == item)
			{
				ClearSlotRecoveryWarning(item, reason);
				UnequipInventorySlotsItem(player, item);
				return true;
			}
			if (TryMoveToFirstFreeRegularCell(player, inventory, item))
			{
				ClearSlotRecoveryWarning(item, reason);
				UnequipInventorySlotsItem(player, item);
				return true;
			}
			WarnUnableToReleaseSlotItem(item, reason);
			return false;
		}

		private static void WarnUnableToReleaseSlotItem(ItemData item, string reason)
		{
			string slotRecoveryWarningKey = GetSlotRecoveryWarningKey(item, reason);
			if (InventorySafety.SlotRecoveryWarnings.Add(slotRecoveryWarningKey))
			{
				string text = item.m_shared?.m_name ?? GetItemPrefabName(item);
				string value;
				string text2 = ((item.m_customData != null && item.m_customData.TryGetValue("InventorySlotsSlotId", out value)) ? value : "<none>");
				Log.LogWarning((object)("Unable to move " + text + " out of InventorySlots slot state because " + reason + " and no regular inventory cell is free. The item was left in place with slot id '" + text2 + "'. Free an inventory cell and reload or reconnect to let InventorySlots recover it."));
			}
		}

		private static void ClearSlotRecoveryWarning(ItemData item, string reason)
		{
			InventorySafety.SlotRecoveryWarnings.Remove(GetSlotRecoveryWarningKey(item, reason));
		}

		private static string GetSlotRecoveryWarningKey(ItemData item, string reason)
		{
			string text = ((!string.IsNullOrWhiteSpace(GetItemPrefabName(item))) ? GetItemPrefabName(item) : (item.m_shared?.m_name ?? "<unknown>"));
			string value;
			string text2 = ((item.m_customData != null && item.m_customData.TryGetValue("InventorySlotsSlotId", out value)) ? value : "<none>");
			return text2 + "|" + text + "|" + reason;
		}

		internal static void UpdateFavoriteKeyHint(KeyHints hints)
		{
			if (!((Object)(object)hints == (Object)null))
			{
				UpdateFavoriteKeyHintGroup(hints.m_inventoryHints);
				UpdateFavoriteKeyHintGroup(hints.m_inventoryWithContainerHints);
			}
		}

		private static void UpdateFavoriteKeyHintGroup(GameObject? group)
		{
			if (IsUnityNull((Object?)(object)group))
			{
				return;
			}
			Transform val = FindKeyboardHintParent(group.transform);
			if (!((Object)(object)val == (Object)null))
			{
				RemoveMisplacedInventorySlotsKeyHints(group.transform, val);
				bool active = _favoriteModifierKey != null;
				GameObject val2 = EnsureInventorySlotsKeyHint(val, "InventorySlots_FavoriteKeyHint", InventoryPanels.FavoriteKeyHintObjects);
				if ((Object)(object)val2 != (Object)null)
				{
					UpdateKeyHintObject(val2, LocalizeUi("$inventoryslots_keyhint_favorite", "Favorite"), GetFavoriteKeyHintDisplayText());
					val2.transform.SetAsFirstSibling();
					val2.SetActive(active);
				}
				bool active2 = IsPinnedTooltipKeyConfigured();
				GameObject val3 = EnsureInventorySlotsKeyHint(val, "InventorySlots_PinnedTooltipKeyHint", InventoryPanels.PinnedTooltipKeyHintObjects);
				if ((Object)(object)val3 != (Object)null)
				{
					UpdateKeyHintObject(val3, LocalizeUi("$inventoryslots_keyhint_tooltip", "Tooltip"), GetPinnedTooltipKeyDisplayText());
					val3.SetActive(active2);
					int num = (((Object)(object)val2 != (Object)null && val2.activeSelf) ? (val2.transform.GetSiblingIndex() + 1) : 0);
					val3.transform.SetSiblingIndex(Mathf.Clamp(num, 0, val.childCount - 1));
				}
			}
		}

		private static void RemoveMisplacedInventorySlotsKeyHints(Transform groupRoot, Transform keyboardParent)
		{
			Transform[] componentsInChildren = ((Component)groupRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((string.Equals(((Object)val).name, "InventorySlots_FavoriteKeyHint", StringComparison.Ordinal) || string.Equals(((Object)val).name, "InventorySlots_PinnedTooltipKeyHint", StringComparison.Ordinal)) && !((Object)(object)val.parent == (Object)(object)keyboardParent))
				{
					((Component)val).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static GameObject? EnsureInventorySlotsKeyHint(Transform parent, string hintName, Dictionary<int, GameObject> cache)
		{
			int instanceID = ((Object)parent).GetInstanceID();
			if (cache.TryGetValue(instanceID, out GameObject value) && !IsUnityNull((Object?)(object)value) && (Object)(object)value.transform.parent == (Object)(object)parent)
			{
				return value;
			}
			Transform val = parent.Find(hintName);
			if ((Object)(object)val != (Object)null)
			{
				cache[instanceID] = ((Component)val).gameObject;
				StripTooltips(((Component)val).gameObject);
				return ((Component)val).gameObject;
			}
			Transform val2 = FindFavoriteKeyHintTemplate(parent);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, parent, false);
			((Object)val3).name = hintName;
			StripTooltips(val3);
			cache[instanceID] = val3;
			return val3;
		}

		private static void StripTooltips(GameObject root)
		{
			if (!((Object)(object)root == (Object)null))
			{
				UITooltip[] componentsInChildren = root.GetComponentsInChildren<UITooltip>(true);
				foreach (UITooltip obj in componentsInChildren)
				{
					obj.m_topic = "";
					obj.m_text = "";
					((Behaviour)obj).enabled = false;
				}
			}
		}

		private static Transform? FindFavoriteKeyHintTemplate(Transform parent)
		{
			Transform val = null;
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (!((Object)child).name.StartsWith("InventorySlots_", StringComparison.Ordinal) && ((Component)child).GetComponentsInChildren<TMP_Text>(true).Length != 0)
				{
					if (val == null)
					{
						val = child;
					}
					if (((Object)child).name.IndexOf("Split", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return child;
					}
				}
			}
			return val;
		}

		private static void UpdateKeyHintObject(GameObject hint, string label, string keyText)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)hint.transform;
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			SetKeyHintLabel(hint.transform, label);
			SetKeyHintKeys(hint.transform, keyText);
			(hint.GetComponent<LayoutElement>() ?? hint.AddComponent<LayoutElement>()).ignoreLayout = false;
		}

		private static void SetKeyHintLabel(Transform root, string value)
		{
			Transform obj = root.Find("Text");
			TMP_Text val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
			if (val == null)
			{
				val = ((IEnumerable<TMP_Text>)((Component)root).GetComponentsInChildren<TMP_Text>(true)).FirstOrDefault((Func<TMP_Text, bool>)((TMP_Text text) => !IsKeyHintText(text)));
			}
			if (!((Object)(object)val == (Object)null))
			{
				ApplyDefaultFontAsset(val);
				val.text = value;
				val.textWrappingMode = (TextWrappingModes)0;
				val.enableAutoSizing = true;
				val.fontSizeMin = 12f;
				val.fontSizeMax = Mathf.Min(Mathf.Max(val.fontSize, 14f), 16f);
				LayoutElement val2 = default(LayoutElement);
				if (((Component)val).TryGetComponent<LayoutElement>(ref val2))
				{
					val2.preferredWidth = 64f;
				}
			}
		}

		private static void SetKeyHintKeys(Transform root, string keyText)
		{
			List<TMP_Text> list = ((Component)root).GetComponentsInChildren<TMP_Text>(true).Where(IsKeyHintText).ToList();
			if (list.Count == 0)
			{
				return;
			}
			if (list.Count == 1)
			{
				SetKeyHintText(list[0], keyText, visible: true);
				SetKeyHintSeparators(root, visible: false);
				return;
			}
			string[] array = keyText.Split(new char[1] { '+' }, 2, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 2)
			{
				SetKeyHintText(list[0], array[0], visible: true);
				SetKeyHintText(list[1], array[1], visible: true);
				SetKeyHintSeparators(root, visible: true);
			}
			else
			{
				SetKeyHintText(list[0], keyText, visible: true);
				SetKeyHintText(list[1], "", visible: false);
				SetKeyHintSeparators(root, visible: false);
			}
			for (int i = 2; i < list.Count; i++)
			{
				SetKeyHintText(list[i], "", visible: false);
			}
		}

		private static bool IsKeyHintText(TMP_Text text)
		{
			if ((Object)(object)text != (Object)null)
			{
				return string.Equals(((Object)text).name, "Key", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static void SetKeyHintSeparators(Transform root, bool visible)
		{
			TMP_Text[] componentsInChildren = ((Component)root).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!IsKeyHintText(val) && (string.Equals(val.text?.Trim() ?? "", "+", StringComparison.Ordinal) || string.Equals(((Object)val).name, "Plus", StringComparison.OrdinalIgnoreCase) || ((Object)val).name.IndexOf("Separator", StringComparison.OrdinalIgnoreCase) >= 0))
				{
					((Component)val).gameObject.SetActive(visible);
				}
			}
		}

		private static void SetKeyHintText(TMP_Text text, string value, bool visible)
		{
			ApplyDefaultFontAsset(text);
			text.text = value;
			text.textWrappingMode = (TextWrappingModes)0;
			Transform parent = text.transform.parent;
			if ((Object)(object)parent != (Object)null && ((Object)parent).name.StartsWith("key_bkg", StringComparison.OrdinalIgnoreCase))
			{
				((Component)parent).gameObject.SetActive(visible);
			}
			else
			{
				((Component)text).gameObject.SetActive(visible);
			}
		}

		private static string GetFavoriteModifierDisplayText()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			string controllerHotkeyDisplayText = GetControllerHotkeyDisplayText(_controllerFavoriteModifierButton);
			if (_favoriteModifierKey == null)
			{
				if (!string.IsNullOrWhiteSpace(controllerHotkeyDisplayText))
				{
					return controllerHotkeyDisplayText;
				}
				return "Alt";
			}
			return JoinShortcutDisplayTexts(_favoriteModifierKey.Value.GetDisplayText(), controllerHotkeyDisplayText);
		}

		private static string GetFavoriteKeyHintDisplayText()
		{
			return GetFavoriteModifierDisplayText() + " + " + ((KeyCode)323).GetDisplayText();
		}

		private static bool IsPinnedTooltipKeyConfigured()
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			if (_pinnedTooltipKey != null)
			{
				KeyboardShortcut value = _pinnedTooltipKey.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					return true;
				}
			}
			return IsControllerHotkeyConfigured(_controllerPinnedTooltipButton);
		}

		private static string GetPinnedTooltipKeyDisplayText()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return JoinShortcutDisplayTexts((_pinnedTooltipKey != null) ? _pinnedTooltipKey.Value.GetDisplayText() : ((KeyCode)325).GetDisplayText(), GetControllerHotkeyDisplayText(_controllerPinnedTooltipButton));
		}

		private static InventoryGridElementUiCache? GetInventoryGridElementUiCache(Element element)
		{
			object obj;
			if (!IsUnityNull((Object?)(object)element?.m_go))
			{
				obj = element.m_go.GetComponent<InventoryGridElementUiCache>();
				if (obj == null)
				{
					return element.m_go.AddComponent<InventoryGridElementUiCache>();
				}
			}
			else
			{
				obj = null;
			}
			return (InventoryGridElementUiCache?)obj;
		}

		private static void UpdateFavoriteBorder(Element element, Player player, Inventory inventory, Vector2i pos)
		{
			//IL_0001: 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)
			if (!IsFavoriteSlot(player, pos))
			{
				SetFavoriteBorderActive(element, active: false);
				return;
			}
			RectTransform val = EnsureFavoriteBorder(element);
			if (!((Object)(object)val == (Object)null))
			{
				Color color = default(Color);
				((Color)(ref color))..ctor(0.1f, 0.55f, 1f, 0.95f);
				Image[] array = GetInventoryGridElementUiCache(element)?.FavoriteBorderImages ?? ((Component)val).GetComponentsInChildren<Image>(true);
				for (int i = 0; i < array.Length; i++)
				{
					((Graphic)array[i]).color = color;
				}
				((Component)val).gameObject.SetActive(true);
				((Transform)val).SetAsLastSibling();
			}
		}

		private static RectTransform? EnsureFavoriteBorder(Element element)
		{
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_00b2: Expected O, but got Unknown
			//IL_00cf: 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_00ed: 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_0101: 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)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: 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)
			if (IsUnityNull((Object?)(object)element?.m_go))
			{
				return null;
			}
			GameObject go = element.m_go;
			InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
			RectTransform val = (((Object)(object)inventoryGridElementUiCache != (Object)null && (Object)(object)inventoryGridElementUiCache.FavoriteBorder != (Object)null && !IsUnityNull((Object?)(object)inventoryGridElementUiCache.FavoriteBorder)) ? inventoryGridElementUiCache.FavoriteBorder : null);
			if ((Object)(object)val == (Object)null)
			{
				Transform val2 = go.transform.Find("InventorySlots_FavoriteBorder");
				val = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<RectTransform>() : null);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = (RectTransform)new GameObject("InventorySlots_FavoriteBorder", new Type[1] { typeof(RectTransform) }).transform;
				((Transform)val).SetParent(go.transform, false);
				CreateFavoriteBorderSide(val, "Top", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, 2f), Vector2.zero);
				CreateFavoriteBorderSide(val, "Bottom", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 2f), Vector2.zero);
				CreateFavoriteBorderSide(val, "Left", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(0f, 0.5f), new Vector2(2f, 0f), Vector2.zero);
				CreateFavoriteBorderSide(val, "Right", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(1f, 0.5f), new Vector2(2f, 0f), Vector2.zero);
			}
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			if ((Object)(object)inventoryGridElementUiCache != (Object)null)
			{
				inventoryGridElementUiCache.FavoriteBorder = val;
				if (inventoryGridElementUiCache.FavoriteBorderImages.Length == 0)
				{
					inventoryGridElementUiCache.FavoriteBorderImages = ((Component)val).GetComponentsInChildren<Image>(true);
				}
			}
			return val;
		}

		private static void UpdateInventoryPinnedTooltipGridBorders(InventoryGrid? grid)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (grid?.m_elements == null || grid.m_inventory == null)
			{
				return;
			}
			foreach (Element element in grid.m_elements)
			{
				if (!IsUnityNull((Object?)(object)element?.m_go))
				{
					if (!element.m_go.activeSelf)
					{
						SetInventoryPinnedTooltipBorderActive(element, active: false);
						continue;
					}
					Vector2i buttonPos = grid.GetButtonPos(element.m_go);
					UpdateInventoryPinnedTooltipBorder(grid, element, buttonPos);
				}
			}
		}

		private static void RefreshInventoryPinnedTooltipBorders()
		{
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				UpdateInventoryPinnedTooltipGridBorders(instance.m_playerGrid);
				UpdateInventoryPinnedTooltipGridBorders(instance.m_containerGrid);
			}
		}

		private static void UpdateInventoryPinnedTooltipBorder(InventoryGrid grid, Element element, Vector2i pos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (grid.m_inventory == null || IsOutOfBounds(grid.m_inventory, pos))
			{
				SetInventoryPinnedTooltipBorderActive(element, active: false);
				return;
			}
			ItemData itemAt = grid.m_inventory.GetItemAt(pos.x, pos.y);
			if (itemAt?.m_shared == null || !IsInventoryItemTooltipPinned(grid, pos, itemAt))
			{
				SetInventoryPinnedTooltipBorderActive(element, active: false);
				return;
			}
			RectTransform val = EnsureInventoryPinnedTooltipMarker(element);
			if (!((Object)(object)val == (Object)null))
			{
				ConfigureInventoryPinnedTooltipMarker(val);
				((Component)val).gameObject.SetActive(true);
				((Transform)val).SetAsLastSibling();
			}
		}

		private static bool IsInventoryItemTooltipPinned(InventoryGrid grid, Vector2i pos, ItemData item)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < GetActivePinnedTooltipSlotCount(); i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf && IsSameInventoryPinnedTooltipTarget(i, grid, pos, item))
				{
					return true;
				}
			}
			return false;
		}

		private static RectTransform? EnsureInventoryPinnedTooltipMarker(Element element)
		{
			if (IsUnityNull((Object?)(object)element?.m_go))
			{
				return null;
			}
			GameObject go = element.m_go;
			InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
			RectTransform val = (((Object)(object)inventoryGridElementUiCache != (Object)null && (Object)(object)inventoryGridElementUiCache.PinnedTooltipMarker != (Object)null && !IsUnityNull((Object?)(object)inventoryGridElementUiCache.PinnedTooltipMarker)) ? inventoryGridElementUiCache.PinnedTooltipMarker : null);
			if ((Object)(object)val == (Object)null)
			{
				Transform val2 = go.transform.Find("InventorySlots_PinnedTooltipMarker");
				val = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<RectTransform>() : null);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = CreateTextRect("InventorySlots_PinnedTooltipMarker", go.transform, out TMP_Text text, active: false);
				text.text = "T";
				if ((Object)(object)inventoryGridElementUiCache != (Object)null)
				{
					inventoryGridElementUiCache.PinnedTooltipText = text;
				}
			}
			if ((Object)(object)inventoryGridElementUiCache != (Object)null)
			{
				inventoryGridElementUiCache.PinnedTooltipMarker = val;
				InventoryGridElementUiCache inventoryGridElementUiCache2 = inventoryGridElementUiCache;
				if (inventoryGridElementUiCache2.PinnedTooltipText == null)
				{
					TMP_Text val3 = (inventoryGridElementUiCache2.PinnedTooltipText = ((Component)val).GetComponent<TMP_Text>());
				}
			}
			ConfigureInventoryPinnedTooltipMarker(val);
			return val;
		}

		private static void ConfigureInventoryPinnedTooltipMarker(RectTransform marker)
		{
			//IL_0047: 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_0065: 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_0083: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null || IsUnityNull((Object?)(object)marker))
			{
				return;
			}
			CraftingPinnedTooltipMarkerState craftingPinnedTooltipMarkerState = ((Component)marker).GetComponent<CraftingPinnedTooltipMarkerState>() ?? ((Component)marker).gameObject.AddComponent<CraftingPinnedTooltipMarkerState>();
			if (!string.Equals(craftingPinnedTooltipMarkerState.LayoutSignature, "inventory", StringComparison.Ordinal))
			{
				SetRectLayout(marker, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(-4f, 4f), new Vector2(26f, 24f));
				TMP_Text component = ((Component)marker).GetComponent<TMP_Text>();
				if ((Object)(object)component == (Object)null)
				{
					craftingPinnedTooltipMarkerState.LayoutSignature = "inventory";
					return;
				}
				ApplyDefaultFontAsset(component);
				component.text = "T";
				component.alignment = (TextAlignmentOptions)1028;
				component.textWrappingMode = (TextWrappingModes)0;
				component.fontSize = 18f;
				((Graphic)component).color = Color.white;
				component.outlineColor = new Color32((byte)0, (byte)0, (byte)0, (byte)230);
				component.outlineWidth = 0.18f;
				((Graphic)component).raycastTarget = false;
				craftingPinnedTooltipMarkerState.LayoutSignature = "inventory";
			}
		}

		private static void SetInventoryPinnedTooltipBorderActive(Element element, bool active)
		{
			if (!IsUnityNull((Object?)(object)element?.m_go))
			{
				InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
				Transform val = (Transform)(((Object)(object)inventoryGridElementUiCache?.PinnedTooltipMarker != (Object)null && !IsUnityNull((Object?)(object)inventoryGridElementUiCache.PinnedTooltipMarker)) ? ((object)inventoryGridElementUiCache.PinnedTooltipMarker) : ((object)element.m_go.transform.Find("InventorySlots_PinnedTooltipMarker")));
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf != active)
				{
					((Component)val).gameObject.SetActive(active);
				}
			}
		}

		private static void CreateFavoriteBorderSide(RectTransform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 sizeDelta, Vector2 anchoredPosition)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_003b: 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_0046: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)parent, false);
			SetRectLayout(val2, anchorMin, anchorMax, pivot, anchoredPosition, sizeDelta);
			((Graphic)val.GetComponent<Image>()).raycastTarget = false;
		}

		private static void SetFavoriteBorderActive(Element element, bool active)
		{
			if (!IsUnityNull((Object?)(object)element?.m_go))
			{
				InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
				Transform val = (Transform)(((Object)(object)inventoryGridElementUiCache?.FavoriteBorder != (Object)null && !IsUnityNull((Object?)(object)inventoryGridElementUiCache.FavoriteBorder)) ? ((object)inventoryGridElementUiCache.FavoriteBorder) : ((object)element.m_go.transform.Find("InventorySlots_FavoriteBorder")));
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf != active)
				{
					((Component)val).gameObject.SetActive(active);
				}
			}
		}

		internal static bool BeginPlayerInventoryLoad(Player player)
		{
			if (IsUnityNull((Object?)(object)player))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			EnsureInventoryHeightForLoad(inventory);
			return BeginInventoryLoadPreservation(inventory);
		}

		internal static bool BeginInventoryLoad(Inventory? inventory)
		{
			bool num = ShouldPreserveInventoryLoad(inventory);
			PrepareInventoryForLoad(inventory);
			if (num)
			{
				return BeginInventoryLoadPreservation(inventory);
			}
			return false;
		}

		internal static void EndPlayerInventoryLoad(Player player, bool active)
		{
			if (active && !IsUnityNull((Object?)(object)player))
			{
				EndInventoryLoad(((Humanoid)player).GetInventory(), active);
			}
		}

		internal static void EndInventoryLoad(Inventory? inventory, bool active)
		{
			if (active && inventory != null)
			{
				EndInventoryLoadPreservation(inventory);
			}
		}

		internal static void PrepareInventoryForLoad(Inventory? inventory)
		{
			if (inventory != null && ShouldPrepareDetachedPlayerInventoryForLoad(inventory))
			{
				EnsureInventoryHeightForLoad(inventory);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (inventory != null && !((Object)(object)localPlayer == (Object)null) && inventory == ((Humanoid)localPlayer).GetInventory())
			{
				EnsureInventoryHeightForLoad(inventory);
			}
		}

		private static bool ShouldPreserveInventoryLoad(Inventory? inventory)
		{
			if (inventory == null)
			{
				return false;
			}
			if (TryGetLocalPlayerInventory(inventory, out Player _))
			{
				return true;
			}
			return ShouldPrepareDetachedPlayerInventoryForLoad(inventory);
		}

		private static bool ShouldPreserveProgressiveRowsDuringLoad(Inventory inventory, Player? player)
		{
			if (inventory != null)
			{
				if (!IsInventoryLoadPreserving(inventory))
				{
					if ((Object)(object)player != (Object)null)
					{
						return player.m_isLoading;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static void EnsureInventoryHeightForLoad(Inventory? inventory)
		{
			if (inventory != null)
			{
				int inventoryFullHeight = GetInventoryFullHeight(inventory.GetWidth());
				if (inventory.m_height < inventoryFullHeight)
				{
					inventory.m_height = inventoryFullHeight;
				}
			}
		}

		private static bool ShouldPrepareDetachedPlayerInventoryForLoad(Inventory inventory)
		{
			if (HasServerCharactersActive && inventory.GetWidth() == 8 && inventory.m_height <= 4)
			{
				return string.Equals(inventory.m_name, "Inventory", StringComparison.Ordinal);
			}
			return false;
		}

		internal static void OnPlayerAwake(Player player)
		{
			InvalidateInventoryPlacementCaches();
			InvalidateCustomEquipmentProjectionCache();
			EnsureInventoryState(player, InventoryStateEnsureReason.PlayerAwake);
		}

		internal static void OnPlayerSpawned(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				InvalidateInventoryPlacementCaches();
				InvalidateCustomEquipmentProjectionCache();
				EnsureInventoryState(player, InventoryStateEnsureReason.PlayerSpawned);
				ApplyAutoFavoriteHotbarSwitchRowForPlayer(player);
				ScheduleEpicLootRespawnRuntimeReload(player);
			}
		}

		internal static void OnPlayerLoaded(Player player)
		{
			InvalidateInventoryPlacementCaches();
			InvalidateCustomEquipmentProjectionCache();
			ClearPendingSlotActions();
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				PreserveOccupiedQuickSlotRowsDuringLoad(player, ((Humanoid)player).GetInventory());
			}
			EnsureInventoryState(player, InventoryStateEnsureReason.PlayerLoad);
			TryRestoreSlotBackup(player);
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				PreserveOccupiedQuickSlotRowsDuringLoad(player, ((Humanoid)player).GetInventory());
			}
			EnsureInventoryState(player, InventoryStateEnsureReason.BackupRestore);
			ApplyAutoFavoriteHotbarSwitchRowForPlayer(player);
		}

		internal static void OnPlayerSaving(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer && !player.m_isLoading)
			{
				PrunePendingSlotActions(player);
				EnsureInventoryState(player, InventoryStateEnsureReason.PlayerSave);
			}
			SaveSlotBackup(player);
		}

		internal static void OnGameSpawnPlayer()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && !localPlayer.m_isLoading)
			{
				EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PlayerSpawned);
				ApplyAutoFavoriteHotbarSwitchRowForPlayer(localPlayer);
				ScheduleEpicLootRespawnRuntimeReload(localPlayer);
			}
		}

		internal static void OnPlayerInventoryChanged(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer && !player.m_isLoading)
			{
				InvalidateInventoryPlacementCaches();
				InvalidateCustomEquipmentProjectionCache();
				ClearCraftingRequirementAvailabilityCache();
				bool flag = HasPendingQuickSlotProgressionReset(player);
				RequestInventoryStateEnsure(player, flag ? InventoryStateEnsureReason.ProgressionReset : InventoryStateEnsureReason.InventoryChanged, flag ? InventoryStateAuditLevel.FullIntegrity : InventoryStateAuditLevel.SlotLight);
			}
		}

		internal static void OnHumanoidSetupEquipment(Humanoid humanoid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)humanoid == (Object)(object)localPlayer && (Object)(object)localPlayer != (Object)null && !localPlayer.m_isLoading && !IsCompletingSlotUnequip)
			{
				InvalidateCustomEquipmentProjectionCache();
				RequestInventoryStateEnsure(localPlayer, InventoryStateEnsureReason.EquipmentChanged, InventoryStateAuditLevel.SlotLight);
			}
		}

		internal static void OnHumanoidSetupVisEquipment(Humanoid humanoid, bool isRagdoll)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!isRagdoll && (Object)(object)humanoid == (Object)(object)localPlayer && (Object)(object)localPlayer != (Object)null && !localPlayer.m_isLoading)
			{
				UpdateCustomEquipmentVisuals(localPlayer);
			}
		}

		internal static void OnInventoryLoaded(Inventory inventory)
		{
			if (TryGetLocalPlayerInventory(inventory, out Player player))
			{
				PreserveOccupiedQuickSlotRowsDuringLoad(player, inventory);
				EnsureInventoryState(player, InventoryStateEnsureReason.InventoryLoad);
			}
		}

		internal static void OnInventoryMoveAll(Inventory targetInventory, Inventory fromInventory)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)localPlayer).GetInventory();
				if (targetInventory == inventory || fromInventory == inventory)
				{
					RequestInventoryStateEnsure(localPlayer, InventoryStateEnsureReason.InventoryMove, InventoryStateAuditLevel.SlotLight);
				}
			}
		}

		internal static void OnInventoryMoveInventoryToGrave(Inventory graveInventory, Inventory original)
		{
			if (TryGetLocalPlayerInventory(original, out Player player))
			{
				EnsureInventoryState(player, InventoryStateEnsureReason.Tombstone);
				graveInventory.m_height = Math.Max(val2: original.m_height = GetInventoryPreservationHeight(original, GetInventoryFullHeight(original.GetWidth())), val1: GetInventoryFullHeight(graveInventory.GetWidth()));
			}
		}

		internal static bool ShouldAllowInventoryGridDropItem(InventoryGrid grid, ItemData item, Vector2i pos)
		{
			//IL_002a: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || item == null || grid.m_inventory != ((Humanoid)localPlayer).GetInventory())
			{
				return true;
			}
			if (!CanUseCell(localPlayer, grid.m_inventory, item, pos))
			{
				return false;
			}
			if (!TryGetSlotAtGridPos(grid.m_inventory, pos, out SlotDefinition _) && IsInventorySlotsCustomEquipped(item))
			{
				UnequipInventorySlotsItem(localPlayer, item);
			}
			return true;
		}

		internal static SlotDefinition? PrepareHumanoidDropInventorySlotsItem(Humanoid humanoid, Inventory inventory, ItemData item, int amount)
		{
			Player localPlayer = Player.m_localPlayer;
			if (IsHandlingSlotDropOutside || (Object)(object)localPlayer == (Object)null || (Object)(object)humanoid != (Object)(object)localPlayer || inventory == null || item == null || amount < item.m_stack || inventory != ((Humanoid)localPlayer).GetInventory())
			{
				return null;
			}
			if (!TryPrepareSlotItemForExternalRemoval(localPlayer, inventory, item, out SlotDefinition slot))
			{
				return null;
			}
			return slot;
		}

		internal static void RestoreHumanoidDropInventorySlotsItem(Humanoid humanoid, Inventory inventory, ItemData item, bool result, SlotDefinition? slot)
		{
			if (!result && slot != null)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)humanoid == (Object)(object)localPlayer)
				{
					RestoreSlotItemAfterFailedExternalRemoval(localPlayer, inventory, item, slot);
				}
			}
		}

		internal static void OnInventoryGuiUpdateInventory(InventoryGrid playerGrid, Player player)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)playerGrid != (Object)null)
			{
				UpdateInventoryGridUi(playerGrid, player);
			}
		}

		internal static void OnInventoryGuiUpdateContainer(InventoryGui gui, Player player)
		{
			if (!((Object)(object)gui == (Object)null) && !((Object)(object)player == (Object)null) && !((Object)(object)gui.m_playerGrid == (Object)null) && InventoryGui.IsVisible())
			{
				UpdateContainerPanelPosition(GetInventoryViewportRows(GetUsableRegularRows(player)), gui.m_playerGrid.m_elementSpace);
				UpdateContainerWeightPanelPosition();
			}
		}

		internal static bool ShouldAllowTooltipHoverStart(UITooltip tooltip)
		{
			if (ShouldUseInventorySlotsOwnedHoverTooltip(tooltip))
			{
				EnsureTooltipPrefab(tooltip);
				if ((Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip) || (Object)(object)tooltip.m_tooltipPrefab == (Object)null)
				{
					return false;
				}
				if (!ShouldSuppressVanillaHoverStart(tooltip))
				{
					return true;
				}
				BeginInventorySlotsOwnedHoverTooltip(tooltip);
				HideVanillaTooltipVisual(UITooltip.m_tooltip);
				UpdateInventorySlotsOwnedHoverTooltip(tooltip, resetScroll: true, handleWheel: false);
				return false;
			}
			BeginInventoryContainerHoverTooltipOwnership(tooltip);
			if ((Object)(object)tooltip == (Object)null || (Object)(object)tooltip.m_tooltipPrefab != (Object)null)
			{
				return true;
			}
			tooltip.m_topic = "";
			tooltip.m_text = "";
			return false;
		}

		internal static void OnContainerTakeAllResponse(Container container, bool granted)
		{
			Player localPlayer = Player.m_localPlayer;
			if (granted && (Object)(object)localPlayer != (Object)null && !localPlayer.m_isLoading && (Object)(object)container != (Object)null && (Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null)
			{
				EnsureInventoryState(localPlayer, InventoryStateEnsureReason.Tombstone);
			}
		}

		internal static void OnInventoryGuiShow()
		{
			OnRealInventoryGuiShown();
			StartQuickSlotPanelIntroAnimation();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && !localPlayer.m_isLoading)
			{
				RequestInventoryStateEnsure(localPlayer, InventoryStateEnsureReason.GuiShow, InventoryStateAuditLevel.SlotLight);
			}
		}

		internal static void OnInventoryGuiHide()
		{
			CancelMultiUserContainerBatch(includeAreaBatch: false);
			OnInventoryGuiHidden();
			StartQuickSlotPanelOutroAnimation();
			PrunePendingSlotActions();
			RestoreContainerUiState();
			RestorePlayerStatPanels();
			HideCraftingPanelRedesign();
			HideInventoryPinnedTooltips();
			HideInventoryOwnedHoverTooltips();
			ClearInventoryHoverTooltipSources();
		}

		internal static void OnInventoryGuiCloseContainer()
		{
			CancelMultiUserContainerBatch(includeAreaBatch: false);
			RestoreContainerUiState();
		}

		private static void RestoreContainerUiState()
		{
			ClearPendingContainerSortRequest();
			RestoreContainerPanelPosition();
			RestoreContainerWeightPanelPosition();
			HideInventoryActionPanels();
		}

		internal static bool TryOverrideTombStoneEasyFit(TombStone tombStone, Player player, ref bool result)
		{
			EnsureTombstoneContainerHeight(tombStone.m_container, reloadInventory: false, persistHeight: true);
			result = (Object)(object)player == (Object)null || TombstoneCanFitInventory(tombStone, player);
			return false;
		}

		internal static void OnTombStoneInteract(TombStone tombStone, bool hold)
		{
			if (!hold)
			{
				EnsureTombstoneContainerHeight(tombStone.m_container, reloadInventory: true, persistHeight: true);
			}
		}

		internal static void OnTombStoneInventoryStateChanged(Player player)
		{
			if ((Object)(object)player != (Object)null && !player.m_isLoading)
			{
				EnsureInventoryState(player, InventoryStateEnsureReason.Tombstone);
			}
		}

		internal static void OnTombStoneTakeAllSuccess(TombStone tombStone)
		{
			CleanupTombstoneFloatingBodyForAutoPickup(tombStone);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && !localPlayer.m_isLoading)
			{
				EnsureInventoryState(localPlayer, InventoryStateEnsureReason.Tombstone);
			}
		}

		private static bool TryGetLocalPlayerInventory(Inventory? inventory, out Player? player)
		{
			player = Player.m_localPlayer;
			if ((Object)(object)player != (Object)null && inventory != null)
			{
				return inventory == ((Humanoid)player).GetInventory();
			}
			return false;
		}

		private static bool TryMoveToFirstFreeRegularCell(Player player, Inventory inventory, ItemData item)
		{
			//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)
			if (!TryFindFreeRegularCell(player, inventory, out var pos))
			{
				return false;
			}
			item.m_gridPos = pos;
			return true;
		}

		private static bool TryRelocateBlockingItem(Player player, Inventory inventory, ItemData blocking, ItemData incoming)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (inventory.ContainsItem(incoming) && IsUsableRegularCell(inventory, player, incoming.m_gridPos) && inventory.GetItemAt(incoming.m_gridPos.x, incoming.m_gridPos.y) == incoming)
			{
				blocking.m_gridPos = incoming.m_gridPos;
				return true;
			}
			return TryMoveToFirstFreeRegularCell(player, inventory, blocking);
		}

		private static bool TryRelocateSlotEquipBlockingItem(Player player, Inventory inventory, ItemData blocking, ItemData incoming, Vector2i incomingOriginalPos, ref bool incomingOriginalPosUsed)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!incomingOriginalPosUsed && inventory.ContainsItem(incoming) && IsUsableRegularCell(inventory, player, incomingOriginalPos) && inventory.GetItemAt(incomingOriginalPos.x, incomingOriginalPos.y) == incoming && CellContainsOnly(inventory, incomingOriginalPos, incoming))
			{
				blocking.m_gridPos = incomingOriginalPos;
				incomingOriginalPosUsed = true;
				return true;
			}
			return TryMoveToFirstFreeRegularCell(player, inventory, blocking);
		}

		private static bool CellContainsOnly(Inventory inventory, Vector2i pos, ItemData allowedItem)
		{
			//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)
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && item != allowedItem && item.m_gridPos == pos)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsUsableRegularCell(Inventory inventory, Player player, Vector2i pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			InventoryCellKind inventoryCellKind = GetInventoryCellKind(player, inventory, pos);
			if (inventoryCellKind != InventoryCellKind.Hotbar)
			{
				return inventoryCellKind == InventoryCellKind.RegularUnlocked;
			}
			return true;
		}

		internal static bool TryFindFreeRegularCell(Player player, Inventory inventory, out Vector2i pos)
		{
			//IL_0069: 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)
			HashSet<Vector2i> occupied = BuildOccupiedCellSet(inventory);
			InventorySlotSafetyCore.GridCell cell;
			bool result = InventorySlotSafetyCore.TrySelectFirstFreeCell(inventory.GetWidth(), GetUsableRegularRows(player), (int x, int y) => IsUsableRegularCell(inventory, player, new Vector2i(x, y)), (int x, int y) => IsCellOccupied(occupied, x, y), out cell);
			pos = new Vector2i(cell.X, cell.Y);
			return result;
		}

		internal static bool TryRedirectUnsafePlayerInventoryInsert(Player player, Inventory inventory, ItemData item, ref Vector2i pos)
		{
			//IL_0015: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || inventory == null || item == null)
			{
				return false;
			}
			if (CanUseCell(player, inventory, item, pos))
			{
				return true;
			}
			if (TryFindSafeInsertCell(player, inventory, item, out var pos2))
			{
				pos = pos2;
				return true;
			}
			return false;
		}

		private static bool TryFindSafeInsertCell(Player player, Inventory inventory, ItemData item, out Vector2i pos)
		{
			//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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			if (TryFindFreeAutomaticPlacementCell(player, inventory, item, out pos))
			{
				return true;
			}
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (CanUseEmptySpecialSlot(player, inventory, item, slotDefinition))
				{
					Vector2i slotGridPos = GetSlotGridPos(inventory, slotDefinition);
					if (CanUseCell(player, inventory, item, slotGridPos) && CellContainsOnly(inventory, slotGridPos, item))
					{
						pos = slotGridPos;
						return true;
					}
				}
			}
			pos = new Vector2i(-1, -1);
			return false;
		}

		internal static bool CanUseCell(Player player, Inventory inventory, ItemData item, Vector2i pos)
		{
			//IL_0002: 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)
			InventoryCellKind inventoryCellKind = GetInventoryCellKind(player, inventory, pos);
			bool flag;
			switch (inventoryCellKind)
			{
			case InventoryCellKind.ExternalReserved:
				return true;
			case InventoryCellKind.Equipment:
			case InventoryCellKind.CustomEquipment:
			case InventoryCellKind.Quick:
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			SlotDefinition slot;
			if (flag)
			{
				return TryGetUsableSpecialSlotAtCell(player, inventory, item, pos, out slot);
			}
			switch (inventoryCellKind)
			{
			case InventoryCellKind.RegularLocked:
				return ShouldPreserveProgressiveRowsDuringLoad(inventory, player);
			default:
				return false;
			case InventoryCellKind.RegularUnlocked:
			case InventoryCellKind.Hotbar:
				return true;
			}
		}

		internal static InventoryCellKind GetInventoryCellKind(Player? player, Inventory inventory, Vector2i pos)
		{
			//IL_0004: 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_0070: 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_00a0: 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)
			if (inventory == null || IsOutOfBounds(inventory, pos))
			{
				return InventoryCellKind.Outside;
			}
			if (TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot))
			{
				if (slot.Kind == SlotKind.Quick && (Object)(object)player != (Object)null && !IsQuickSlotUnlocked(player, slot))
				{
					return InventoryCellKind.QuickLocked;
				}
				if (slot.Kind != SlotKind.Quick && (Object)(object)player != (Object)null && !IsEquipmentSlotUnlocked(player, inventory, slot))
				{
					return InventoryCellKind.EquipmentLocked;
				}
				return slot.Kind switch
				{
					SlotKind.Quick => InventoryCellKind.Quick, 
					SlotKind.CustomEquipment => InventoryCellKind.CustomEquipment, 
					_ => InventoryCellKind.Equipment, 
				};
			}
			if (IsExternalReservedCell(pos, includeRestockableSlots: true))
			{
				return InventoryCellKind.ExternalReserved;
			}
			int fixedRegularRows = GetFixedRegularRows();
			if (pos.y >= fixedRegularRows)
			{
				return InventoryCellKind.Outside;
			}
			if ((Object)(object)player != (Object)null && IsLockedRowCell(player, pos))
			{
				return InventoryCellKind.RegularLocked;
			}
			if (pos.y != 0)
			{
				return InventoryCellKind.RegularUnlocked;
			}
			return InventoryCellKind.Hotbar;
		}

		private static bool CanUseSpecialSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if (item != null && slot != null && slot.Accepts(item) && !IsJewelcraftingUtilityGemBlockedForSlot(item, slot))
			{
				return IsSpecialSlotUnlocked(player, inventory, slot);
			}
			return false;
		}

		private static bool CanUseEmptySpecialSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if (CanUseSpecialSlot(player, inventory, item, slot))
			{
				return FindItemForSlot(player, inventory, slot) == null;
			}
			return false;
		}

		private static bool TryGetUsableSpecialSlotAtCell(Player player, Inventory inventory, ItemData item, Vector2i pos, out SlotDefinition? slot)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			slot = null;
			if (!TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot2) || slot2 == null || !CanUseSpecialSlot(player, inventory, item, slot2))
			{
				return false;
			}
			slot = slot2;
			return true;
		}

		private static bool TryGetEmptyUsableSpecialSlotAtCell(Player player, Inventory inventory, ItemData item, Vector2i pos, out SlotDefinition? slot)
		{
			//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)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetUsableSpecialSlotAtCell(player, inventory, item, pos, out slot))
			{
				return false;
			}
			return inventory.GetItemAt(pos.x, pos.y) == null;
		}

		private static bool IsRegularActionItem(Player player, Inventory inventory, ItemData item, bool includeHotbar)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return InventoryActionCellPolicyCore.CanUseContainerActionSource(GetInventoryCellKind(player, inventory, item.m_gridPos), includeHotbar);
		}

		private static bool IsFavoriteProtected(Player player, Inventory inventory, ItemData item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return IsFavoriteSlot(player, item.m_gridPos);
		}

		private static bool IsFavoriteSlot(Player player, Vector2i pos)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EnsureFavoritesLoaded(player);
			return FavoriteSlots.Contains(pos);
		}

		private static InventoryPlacementScope GetInventoryPlacementScope(Inventory inventory, out Player? player)
		{
			player = null;
			if (inventory == null)
			{
				return InventoryPlacementScope.General;
			}
			if (TryGetLocalPlayerInventory(inventory, out player))
			{
				if (!ShouldPreserveProgressiveRowsDuringLoad(inventory, player))
				{
					return InventoryPlacementScope.LocalPlayer;
				}
				return InventoryPlacementScope.LoadPreservation;
			}
			if (IsInventoryLoadPreserving(inventory))
			{
				return InventoryPlacementScope.LoadPreservation;
			}
			if (!IsContainerInventory(inventory))
			{
				return InventoryPlacementScope.General;
			}
			return InventoryPlacementScope.Container;
		}

		private static bool IsContainerInventory(Inventory inventory)
		{
			if (inventory == null)
			{
				return false;
			}
			Container val = (((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_currentContainer : null);
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && val.m_inventory == inventory)
			{
				return true;
			}
			for (int num = InventoryContainers.KnownContainers.Count - 1; num >= 0; num--)
			{
				Container val2 = InventoryContainers.KnownContainers[num];
				if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2))
				{
					InventoryContainers.KnownContainers.RemoveAt(num);
				}
				else if (val2.m_inventory == inventory)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryOverrideFindEmptySlot(Inventory inventory, ref Vector2i result)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0055: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			Player player;
			switch (GetInventoryPlacementScope(inventory, out player))
			{
			case InventoryPlacementScope.Container:
				result = FindTopFirstEmptySlot(inventory);
				return false;
			case InventoryPlacementScope.LoadPreservation:
				result = FindTopFirstRegularLoadPreservationSlot(inventory);
				return false;
			case InventoryPlacementScope.LocalPlayer:
			{
				result = (Vector2i)(TryFindFreeAutomaticPlacementCell(player, inventory, GetCurrentInventoryAddItemDataStackLookupItem(), out var pos) ? pos : new Vector2i(-1, -1));
				return false;
			}
			default:
				return true;
			}
		}

		private static bool TryFindFreeAutomaticPlacementCell(Player player, Inventory inventory, ItemData? incoming, out Vector2i pos)
		{
			//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)
			HashSet<Vector2i> occupied = BuildOccupiedCellSet(inventory);
			InventorySlotSafetyCore.GridCell cell;
			bool result = InventoryPlacementPolicyCore.TrySelectAutomaticPlacementCell(inventory.GetWidth(), GetUsableRegularRows(player), QuickSlotAcceptsItem(incoming), (int x, int y) => IsUsableRegularCell(inventory, player, new Vector2i(x, y)), (int x, int y) => IsCellOccupied(occupied, x, y), out cell);
			pos = new Vector2i(cell.X, cell.Y);
			return result;
		}

		private static Vector2i FindTopFirstEmptySlot(Inventory inventory)
		{
			//IL_0068: 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)
			HashSet<Vector2i> occupied = BuildOccupiedCellSet(inventory);
			if (!InventorySlotSafetyCore.TrySelectFirstFreeCell(inventory.GetWidth(), inventory.GetHeight(), (int _, int _) => true, (int x, int y) => IsCellOccupied(occupied, x, y), out var cell))
			{
				return new Vector2i(-1, -1);
			}
			return new Vector2i(cell.X, cell.Y);
		}

		internal static bool TryOverrideFindFreeStackItem(Inventory inventory, string name, int quality, float worldLevel, ref ItemData? result)
		{
			result = null;
			if (inventory == null || string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			ItemData currentInventoryAddItemDataStackLookupItem = GetCurrentInventoryAddItemDataStackLookupItem();
			if (currentInventoryAddItemDataStackLookupItem != null)
			{
				if (IsTrustedCustomDataStackingItem(currentInventoryAddItemDataStackLookupItem))
				{
					return true;
				}
				if (!HasNoCustomData(currentInventoryAddItemDataStackLookupItem))
				{
					return false;
				}
			}
			ItemData val = null;
			foreach (ItemData item in inventory.m_inventory)
			{
				if (CanStackIntoItem(item, name, quality, worldLevel) && (val == null || item.m_gridPos.y < val.m_gridPos.y || (item.m_gridPos.y == val.m_gridPos.y && item.m_gridPos.x < val.m_gridPos.x)))
				{
					val = item;
				}
			}
			result = val;
			return false;
		}

		private static Vector2i FindTopFirstRegularLoadPreservationSlot(Inventory inventory)
		{
			//IL_000e: 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)
			if (TryFindFreeRegularLoadPreservationCell(inventory, out var pos))
			{
				return pos;
			}
			return new Vector2i(-1, -1);
		}

		private static bool TryFindFreeRegularLoadPreservationCell(Inventory inventory, out Vector2i pos)
		{
			//IL_006b: 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)
			int rowCount = Math.Min(GetFixedRegularRows(), inventory.GetHeight());
			HashSet<Vector2i> occupied = BuildOccupiedCellSet(inventory);
			InventorySlotSafetyCore.GridCell cell;
			bool result = InventorySlotSafetyCore.TrySelectFirstFreeCell(inventory.GetWidth(), rowCount, (int x, int y) => !IsExternalReservedForCompat(new Vector2i(x, y)), (int x, int y) => IsCellOccupied(occupied, x, y), out cell);
			pos = new Vector2i(cell.X, cell.Y);
			return result;
		}

		private static bool IsInventorySlotsTailCell(Inventory inventory, Vector2i pos)
		{
			//IL_000e: 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)
			if (inventory != null)
			{
				return InventorySlotSafetyCore.IsInventorySlotsTailCell(inventory.GetWidth(), GetFixedRegularRows(), new InventorySlotSafetyCore.GridCell(pos.x, pos.y));
			}
			return false;
		}

		private static int CountRegularLoadPreservationEmptyCells(Inventory inventory)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = Math.Min(GetFixedRegularRows(), inventory.GetHeight());
			HashSet<Vector2i> occupied = BuildOccupiedCellSet(inventory);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					if (!IsExternalReservedForCompat(new Vector2i(j, i)) && !IsCellOccupied(occupied, j, i))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static bool CanStackIntoItem(ItemData? item, string name, int quality, float worldLevel)
		{
			if (item?.m_shared != null && HasNoCustomData(item) && item.m_shared.m_name == name && item.m_quality == quality && item.m_stack < item.m_shared.m_maxStackSize)
			{
				return (float)item.m_worldLevel == worldLevel;
			}
			return false;
		}

		internal static bool BeginInventoryAddItemDataStackLookup(ItemData item)
		{
			PushInventoryAddItemDataStackLookupItem(item);
			return true;
		}

		internal static void EndInventoryAddItemDataStackLookup(bool active)
		{
			if (active)
			{
				PopInventoryAddItemDataStackLookupItem();
			}
		}

		internal static bool TryOverrideGetEmptySlots(Inventory inventory, ref int result)
		{
			Player player;
			switch (GetInventoryPlacementScope(inventory, out player))
			{
			case InventoryPlacementScope.Container:
				result = CountAllEmptyCells(inventory);
				return false;
			case InventoryPlacementScope.LoadPreservation:
				result = CountRegularLoadPreservationEmptyCells(inventory);
				return false;
			case InventoryPlacementScope.LocalPlayer:
				result = CountUsableRegularEmptyCells(inventory, player);
				return false;
			default:
				return true;
			}
		}

		private static int CountAllEmptyCells(Inventory inventory)
		{
			return CountAllEmptyCells(inventory, BuildOccupiedCellSet(inventory));
		}

		private static int CountAllEmptyCells(Inventory inventory, HashSet<Vector2i> occupied)
		{
			return InventoryPlacementPolicyCore.CountTopFirstPolicyEmptyCells(inventory.GetWidth(), inventory.GetHeight(), (int _, int _) => true, (int x, int y) => IsCellOccupied(occupied, x, y));
		}

		private static int CountUsableRegularEmptyCells(Inventory inventory, Player player)
		{
			return CountUsableRegularEmptyCells(inventory, player, BuildOccupiedCellSet(inventory));
		}

		private static int CountUsableRegularEmptyCells(Inventory inventory, Player player, HashSet<Vector2i> occupied)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = Math.Min(GetUsableRegularRows(player), inventory.GetHeight());
			Vector2i pos = default(Vector2i);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					((Vector2i)(ref pos))..ctor(j, i);
					if (IsUsableRegularCell(inventory, player, pos) && !IsCellOccupied(occupied, j, i))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static int CountUsableRegularEmptyCellsCached(Inventory inventory, Player player)
		{
			int num = ComputeInventoryPlacementCacheContext(player, inventory);
			if (InventorySafety.UsableRegularEmptyCellCacheInventory == inventory && InventorySafety.UsableRegularEmptyCellCacheVersion == InventorySafety.InventoryPlacementCacheVersion && InventorySafety.UsableRegularEmptyCellCacheContext == num)
			{
				return InventorySafety.UsableRegularEmptyCellCacheCount;
			}
			int num2 = CountUsableRegularEmptyCells(inventory, player);
			InventorySafety.UsableRegularEmptyCellCacheInventory = inventory;
			InventorySafety.UsableRegularEmptyCellCacheVersion = InventorySafety.InventoryPlacementCacheVersion;
			InventorySafety.UsableRegularEmptyCellCacheContext = num;
			InventorySafety.UsableRegularEmptyCellCacheCount = num2;
			return num2;
		}

		internal static bool TryOverrideHaveEmptySlot(Inventory inventory, ref bool result)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Player player;
			Vector2i pos;
			switch (GetInventoryPlacementScope(inventory, out player))
			{
			case InventoryPlacementScope.Container:
				result = FindTopFirstEmptySlot(inventory).x >= 0;
				return false;
			case InventoryPlacementScope.LoadPreservation:
				result = TryFindFreeRegularLoadPreservationCell(inventory, out pos);
				return false;
			case InventoryPlacementScope.LocalPlayer:
				result = TryFindFreeRegularCell(player, inventory, out pos);
				return false;
			default:
				return true;
			}
		}

		internal static bool TryOverrideCanAddItem(Inventory inventory, ItemData item, int stack, ref bool result)
		{
			if (item?.m_shared == null || !TryGetLocalPlayerInventory(inventory, out Player player))
			{
				return true;
			}
			result = CanAddItemToUsablePlayerSlots(player, inventory, item, stack);
			return false;
		}

		private static bool CanAddItemToUsablePlayerSlots(Player player, Inventory inventory, ItemData item, int stack)
		{
			int num = ((stack <= 0) ? item.m_stack : stack);
			if (num <= 0)
			{
				return true;
			}
			if (!IsCraftingInventoryLimitNoticeActive() && TryGetCachedCanAddItemFailure(player, inventory, item, num))
			{
				return false;
			}
			if (!CanAddWithinInventoryLimits(inventory, item, num, out var maxAllowed))
			{
				RecordCraftingInventoryLimitRejection(item, maxAllowed);
				CacheCanAddItemFailure(player, inventory, item, num);
				return false;
			}
			int num2 = Math.Max(1, item.m_shared.m_maxStackSize);
			long num3 = CountStackSpaceForIncomingItem(inventory, item);
			if (num3 >= num)
			{
				return true;
			}
			num3 += (long)CountUsableRegularEmptyCellsCached(inventory, player) * (long)num2;
			if (num3 >= num)
			{
				return true;
			}
			if (CanAutoPlaceItemInSpecialSlot(player, inventory, item))
			{
				num3 += num2;
			}
			bool num4 = num3 >= num;
			if (!num4)
			{
				CacheCanAddItemFailure(player, inventory, item, num);
			}
			return num4;
		}

		private static bool CanAddWithinInventoryLimits(Inventory inventory, ItemData item, int incomingAmount, out int maxAllowed)
		{
			maxAllowed = -1;
			if (incomingAmount <= 0 || item?.m_shared == null || InventoryLimits.Count == 0 || inventory == null || inventory.ContainsItem(item) || IsInventoryLoadPreserving(inventory) || !TryGetLocalPlayerInventory(inventory, out Player _))
			{
				return true;
			}
			bool flag = false;
			foreach (string key in InventoryLimits.Keys)
			{
				if (ItemMatchesYamlReferenceToken(item, key))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return true;
			}
			EnsureInventoryLimitCountCache(inventory);
			long num = long.MinValue;
			foreach (KeyValuePair<string, int> inventoryLimit in InventoryLimits)
			{
				if (!ItemMatchesYamlReferenceToken(item, inventoryLimit.Key))
				{
					continue;
				}
				InventorySafety.InventoryLimitCountCache.TryGetValue(inventoryLimit.Key, out var value);
				if (!InventoryPlacementPolicyCore.CanAcceptInventoryLimit(value, incomingAmount, inventoryLimit.Value))
				{
					long num2 = Math.Max(0L, value) + incomingAmount - inventoryLimit.Value;
					if (num2 > num || (num2 == num && (maxAllowed < 0 || inventoryLimit.Value < maxAllowed)))
					{
						num = num2;
						maxAllowed = inventoryLimit.Value;
					}
				}
			}
			return maxAllowed < 0;
		}

		private static void EnsureInventoryLimitCountCache(Inventory inventory)
		{
			if (InventorySafety.InventoryLimitCountCacheInventory == inventory && InventorySafety.InventoryLimitCountCachePlacementVersion == InventorySafety.InventoryPlacementCacheVersion && InventorySafety.InventoryLimitCountCacheRuleVersion == InventoryDefinitions.InventoryLimitVersion)
			{
				return;
			}
			Dictionary<string, long> inventoryLimitCountCache = InventorySafety.InventoryLimitCountCache;
			inventoryLimitCountCache.Clear();
			foreach (string key in InventoryLimits.Keys)
			{
				inventoryLimitCountCache[key] = 0L;
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item?.m_shared == null || item.m_stack <= 0)
				{
					continue;
				}
				foreach (string key2 in InventoryLimits.Keys)
				{
					if (ItemMatchesYamlReferenceToken(item, key2))
					{
						inventoryLimitCountCache[key2] += item.m_stack;
					}
				}
			}
			InventorySafety.InventoryLimitCountCacheInventory = inventory;
			InventorySafety.InventoryLimitCountCachePlacementVersion = InventorySafety.InventoryPlacementCacheVersion;
			InventorySafety.InventoryLimitCountCacheRuleVersion = InventoryDefinitions.InventoryLimitVersion;
		}

		internal static bool TryValidatePlayerInventoryLimit(Inventory inventory, ItemData item, int amount, ref bool result)
		{
			if (CanAddWithinInventoryLimits(inventory, item, amount, out var maxAllowed))
			{
				return true;
			}
			result = false;
			if (TryGetLocalPlayerInventory(inventory, out Player player))
			{
				ShowInventoryLimitReached(player, item, maxAllowed);
			}
			return false;
		}

		private static void ShowInventoryLimitReached(Player player, ItemData item, int maxAllowed, bool force = false)
		{
			string itemPrefabName = GetItemPrefabName(item);
			string text = item.m_shared?.m_name ?? "";
			string text2 = StripLocalizationToken(text);
			if (string.IsNullOrWhiteSpace(text2))
			{
				text2 = ((!string.IsNullOrWhiteSpace(itemPrefabName)) ? itemPrefabName : "Item");
			}
			string newValue = LocalizeUi(text, text2);
			string text3 = $"{itemPrefabName}|{text}|{maxAllowed}";
			float unscaledTime = Time.unscaledTime;
			if (force || !string.Equals(InventorySafety.LastInventoryLimitMessageKey, text3, StringComparison.Ordinal) || !(unscaledTime - InventorySafety.LastInventoryLimitMessageTime < 0.5f))
			{
				InventorySafety.LastInventoryLimitMessageKey = text3;
				InventorySafety.LastInventoryLimitMessageTime = unscaledTime;
				string text4 = LocalizeUi("$inventoryslots_inventory_limit_reached", "{item}: you can carry at most {max}.").Replace("{item}", newValue).Replace("{max}", maxAllowed.ToString());
				((Character)player).Message((MessageType)2, text4, 0, (Sprite)null);
			}
		}

		internal static void OnHumanoidPickupResult(Humanoid humanoid, GameObject itemObject, bool result)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			if (!result && !((Object)(object)humanoid != (Object)(object)Player.m_localPlayer) && !IsUnityNull((Object?)(object)itemObject))
			{
				ItemData val = itemObject.GetComponent<ItemDrop>()?.m_itemData;
				Inventory inventory = humanoid.GetInventory();
				if (val?.m_shared != null && !CanAddWithinInventoryLimits(inventory, val, val.m_stack, out var maxAllowed))
				{
					ShowInventoryLimitReached((Player)humanoid, val, maxAllowed, force: true);
				}
			}
		}

		private static bool TryGetCachedCanAddItemFailure(Player player, Inventory inventory, ItemData item, int requestedStack)
		{
			if (!CanCacheCanAddItemFailure(item))
			{
				return false;
			}
			int num = ComputeInventoryPlacementCacheContext(player, inventory);
			int num2 = ComputeCanAddItemCacheItemKey(item);
			if (InventorySafety.CanAddItemFailureCacheInventory == inventory && InventorySafety.CanAddItemFailureCacheVersion == InventorySafety.InventoryPlacementCacheVersion && InventorySafety.CanAddItemFailureCacheContext == num && InventorySafety.CanAddItemFailureCacheItemKey == num2)
			{
				return InventorySafety.CanAddItemFailureCacheRequestedStack == requestedStack;
			}
			return false;
		}

		private static void CacheCanAddItemFailure(Player player, Inventory inventory, ItemData item, int requestedStack)
		{
			if (CanCacheCanAddItemFailure(item))
			{
				InventorySafety.CanAddItemFailureCacheInventory = inventory;
				InventorySafety.CanAddItemFailureCacheVersion = InventorySafety.InventoryPlacementCacheVersion;
				InventorySafety.CanAddItemFailureCacheContext = ComputeInventoryPlacementCacheContext(player, inventory);
				InventorySafety.CanAddItemFailureCacheItemKey = ComputeCanAddItemCacheItemKey(item);
				InventorySafety.CanAddItemFailureCacheRequestedStack = requestedStack;
			}
		}

		private static bool CanCacheCanAddItemFailure(ItemData item)
		{
			if (item?.m_shared != null)
			{
				if (!HasNoCustomData(item))
				{
					return IsTrustedCustomDataStackingItem(item);
				}
				return true;
			}
			return false;
		}

		private static int ComputeInventoryPlacementCacheContext(Player player, Inventory inventory)
		{
			return (((((17 * 31 + ((inventory != null) ? inventory.GetWidth() : 0)) * 31 + ((inventory != null) ? inventory.GetHeight() : 0)) * 31 + GetUsableRegularRows(player)) * 31 + InventoryDefinitions.SlotDefinitionVersion) * 31 + GetKnownMaterialHash(player)) * 31 + (inventory?.m_inventory?.Count).GetValueOrDefault();
		}

		private static int ComputeCanAddItemCacheItemKey(ItemData item)
		{
			return ((((17 * 31 + StringComparer.Ordinal.GetHashCode(item.m_shared?.m_name ?? "")) * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(GetItemPrefabName(item))) * 31 + item.m_quality) * 31 + item.m_worldLevel.GetHashCode()) * 31 + Math.Max(1, item.m_shared?.m_maxStackSize ?? 1);
		}

		private static HashSet<Vector2i> BuildOccupiedCellSet(Inventory inventory)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
			if (inventory?.m_inventory == null)
			{
				return hashSet;
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null)
				{
					hashSet.Add(item.m_gridPos);
				}
			}
			return hashSet;
		}

		private static bool IsCellOccupied(HashSet<Vector2i> occupied, int x, int y)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return occupied.Contains(new Vector2i(x, y));
		}

		private static void InvalidateInventoryPlacementCaches()
		{
			InventorySafety.InventoryPlacementCacheVersion++;
			InventorySafety.UsableRegularEmptyCellCacheInventory = null;
			InventorySafety.UsableRegularEmptyCellCacheVersion = -1;
			InventorySafety.UsableRegularEmptyCellCacheContext = 0;
			InventorySafety.UsableRegularEmptyCellCacheCount = 0;
			InventorySafety.CanAddItemFailureCacheInventory = null;
			InventorySafety.CanAddItemFailureCacheVersion = -1;
			InventorySafety.CanAddItemFailureCacheContext = 0;
			InventorySafety.CanAddItemFailureCacheItemKey = 0;
			InventorySafety.CanAddItemFailureCacheRequestedStack = 0;
			InventorySafety.InventoryLimitCountCacheInventory = null;
			InventorySafety.InventoryLimitCountCachePlacementVersion = -1;
			InventorySafety.InventoryLimitCountCacheRuleVersion = -1;
			InventorySafety.InventoryLimitCountCache.Clear();
		}

		private static int CountStackSpaceForIncomingItem(Inventory inventory, ItemData item)
		{
			if (inventory == null || item?.m_shared == null)
			{
				return 0;
			}
			if (!IsTrustedCustomDataStackingItem(item) && !HasNoCustomData(item))
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData item2 in inventory.m_inventory)
			{
				if (CanStackIncomingItemInto(item2, item))
				{
					num += Math.Max(0, item2.m_shared.m_maxStackSize - item2.m_stack);
				}
			}
			return num;
		}

		private static bool CanStackIncomingItemInto(ItemData? existing, ItemData incoming)
		{
			if (existing?.m_shared != null && existing.m_stack < existing.m_shared.m_maxStackSize)
			{
				return CanShareInventoryStack(existing, incoming);
			}
			return false;
		}

		private static bool CanShareInventoryStack(ItemData? existing, ItemData? incoming)
		{
			if (existing?.m_shared == null || incoming?.m_shared == null)
			{
				return false;
			}
			if ((IsTrustedCustomDataStackingItem(incoming) || (HasNoCustomData(incoming) && HasNoCustomData(existing))) && existing.m_shared.m_name == incoming.m_shared.m_name && existing.m_quality == incoming.m_quality)
			{
				return (float)existing.m_worldLevel == (float)incoming.m_worldLevel;
			}
			return false;
		}

		internal static void OnInventoryAddItemData(Inventory inventory, ItemData item, ref bool result)
		{
			if (!result && item != null && TryGetLocalPlayerInventory(inventory, out Player player) && CanAddWithinInventoryLimits(inventory, item, item.m_stack, out var _))
			{
				result = TryAutoPlaceItemInSpecialSlot(player, inventory, item);
			}
		}

		internal static bool TryPreserveLoadedSlotTailItem(Inventory inventory, ItemData item, ref bool result)
		{
			//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)
			if (item == null)
			{
				return true;
			}
			Vector2i target = item.m_gridPos;
			if (!TryPreserveLoadedSlotTailItem(inventory, item, ref target, ref result))
			{
				return true;
			}
			return false;
		}

		private static bool TryPreserveLoadedSlotTailItem(Inventory inventory, ItemData item, ref Vector2i target, ref bool result)
		{
			//IL_0023: 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_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)
			if (item == null || !TryPrepareLoadPreservationTailInsert(inventory, target))
			{
				return false;
			}
			EnsureInventoryHeightForLoad(inventory);
			if (target.y >= inventory.GetHeight())
			{
				inventory.m_height = target.y + 1;
			}
			if (InventorySlotSafetyCore.TrySelectLoadPreservationTailCell(inventory.GetWidth(), inventory.GetHeight(), GetFixedRegularRows(), new InventorySlotSafetyCore.GridCell(target.x, target.y), (int x, int y) => IsInventoryCellOccupiedByOtherItem(inventory, item, x, y), out var selectedCell))
			{
				target = new Vector2i(selectedCell.X, selectedCell.Y);
				if (target.y >= inventory.GetHeight())
				{
					inventory.m_height = target.y + 1;
				}
			}
			item.m_gridPos = target;
			if (!inventory.ContainsItem(item))
			{
				inventory.m_inventory.Add(item);
			}
			result = true;
			return true;
		}

		private static bool TryPrepareLoadPreservationTailInsert(Inventory inventory, Vector2i target)
		{
			//IL_000c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null || !IsInventoryLoadPreserving(inventory) || !IsInventorySlotsTailCell(inventory, target))
			{
				return false;
			}
			EnsureInventoryHeightForLoad(inventory);
			if (target.y >= inventory.GetHeight())
			{
				inventory.m_height = target.y + 1;
			}
			return true;
		}

		private static bool IsInventoryCellOccupiedByOtherItem(Inventory inventory, ItemData item, int x, int y)
		{
			foreach (ItemData item2 in inventory.m_inventory)
			{
				if (item2 != null && item2 != item && item2.m_gridPos.x == x && item2.m_gridPos.y == y)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryValidatePlayerInventoryInsert(Inventory inventory, ItemData item, ref Vector2i pos, ref bool result)
		{
			return TryValidatePlayerInventoryInsert(inventory, item, ref pos, ref result, preserveLoadedTailItem: true);
		}

		private static bool TryValidatePlayerInventoryInsert(Inventory inventory, ItemData item, ref Vector2i pos, ref bool result, bool preserveLoadedTailItem)
		{
			//IL_001c: 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)
			if (item == null)
			{
				return true;
			}
			if (preserveLoadedTailItem && TryPreserveLoadedSlotTailItem(inventory, item, ref pos, ref result))
			{
				return false;
			}
			if (!preserveLoadedTailItem && TryPrepareLoadPreservationTailInsert(inventory, pos))
			{
				return true;
			}
			if (!TryGetLocalPlayerInventory(inventory, out Player player))
			{
				return true;
			}
			if (CanUseCell(player, inventory, item, pos))
			{
				return true;
			}
			if (TryRedirectUnsafePlayerInventoryInsert(player, inventory, item, ref pos))
			{
				return true;
			}
			result = false;
			return false;
		}

		internal static bool TryValidatePlayerInventoryInsert(Inventory inventory, ItemData item, ref int x, ref int y, ref bool result)
		{
			//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)
			Vector2i pos = default(Vector2i);
			((Vector2i)(ref pos))..ctor(x, y);
			bool result2 = TryValidatePlayerInventoryInsert(inventory, item, ref pos, ref result);
			x = pos.x;
			y = pos.y;
			return result2;
		}

		internal static bool TryValidatePlayerInventoryMoveItemToThis(Inventory inventory, ref bool result, Inventory fromInventory, ItemData item, int amount, ref int x, ref int y)
		{
			//IL_0045: 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)
			int amount2 = Math.Min(Math.Max(0, amount), Math.Max(0, item.m_stack));
			if (inventory != fromInventory && !TryValidatePlayerInventoryLimit(inventory, item, amount2, ref result))
			{
				return false;
			}
			Vector2i pos = default(Vector2i);
			((Vector2i)(ref pos))..ctor(x, y);
			bool result2 = TryValidatePlayerInventoryInsert(inventory, item, ref pos, ref result, preserveLoadedTailItem: false);
			x = pos.x;
			y = pos.y;
			return result2;
		}

		internal static void OnPlayerInventoryItemPlaced(Inventory inventory, ItemData item, Vector2i pos, bool result)
		{
			//IL_0012: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			if (result && item != null && TryGetLocalPlayerInventory(inventory, out Player player) && TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot))
			{
				ItemData item2 = inventory.GetItemAt(pos.x, pos.y) ?? item;
				TryEquipIntoSlot(player, inventory, item2, slot);
			}
		}

		private static void PositionQuickSlotPanel(InventoryGrid playerGrid, RectTransform quickPanel, Vector3 targetGridLocalPosition, float elementSpace)
		{
			//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)
			//IL_0067: 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_0072: 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)
			//IL_005d: 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_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)
			RectTransform quickSlotPanelStableParent = GetQuickSlotPanelStableParent(playerGrid);
			if ((Object)(object)quickSlotPanelStableParent != (Object)null && (Object)(object)((Transform)quickPanel).parent != (Object)(object)quickSlotPanelStableParent)
			{
				((Transform)quickPanel).SetParent((Transform)(object)quickSlotPanelStableParent, false);
			}
			DestroyDuplicateQuickSlotPanels(playerGrid, quickPanel);
			Vector3 targetPosition = targetGridLocalPosition;
			if ((Object)(object)((Transform)quickPanel).parent != (Object)(object)playerGrid.m_gridRoot)
			{
				Transform parent = ((Transform)quickPanel).parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val != null)
				{
					Vector3 val2 = ((Transform)playerGrid.m_gridRoot).TransformPoint(targetGridLocalPosition);
					targetPosition = ((Transform)val).InverseTransformPoint(val2);
				}
			}
			CaptureQuickSlotHudAnchor(quickPanel, targetPosition, elementSpace);
			((Transform)quickPanel).localPosition = ApplyQuickSlotPanelIntroAnimation(quickPanel, targetPosition, elementSpace);
		}

		private static void CaptureQuickSlotHudAnchor(RectTransform quickPanel, Vector3 targetPosition, float elementSpace)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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)
			if ((_quickSlotHudFollowsPanel != null && _quickSlotHudFollowsPanel.Value == Toggle.Off) || (Object)(object)quickPanel == (Object)null || (Object)(object)((Transform)quickPanel).parent == (Object)null || (Object)(object)Hud.instance == (Object)null || (Object)(object)Hud.instance.m_rootObject == (Object)null)
			{
				return;
			}
			RectTransform component = Hud.instance.m_rootObject.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			Vector3 localPosition = ((Transform)quickPanel).localPosition;
			((Transform)quickPanel).localPosition = targetPosition;
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			quickPanel.GetWorldCorners(array);
			((Transform)quickPanel).localPosition = localPosition;
			Vector3 val = ((Transform)component).InverseTransformPoint(array[1]);
			float num = Mathf.Max(1f, elementSpace);
			int num2;
			if (InventoryPanels.QuickSlotHudAnchorValid)
			{
				Vector3 val2 = InventoryPanels.QuickSlotHudAnchoredPosition - val;
				if (!(((Vector3)(ref val2)).sqrMagnitude > 0.0001f))
				{
					num2 = ((Mathf.Abs(InventoryPanels.QuickSlotHudElementSpace - num) > 0.01f) ? 1 : 0);
					goto IL_00eb;
				}
			}
			num2 = 1;
			goto IL_00eb;
			IL_00eb:
			InventoryPanels.QuickSlotHudAnchoredPosition = val;
			InventoryPanels.QuickSlotHudElementSpace = num;
			InventoryPanels.QuickSlotHudAnchorValid = true;
			if (num2 != 0 && !InventoryPanels.DraggingQuickSlotsPanelOffset)
			{
				SaveQuickSlotHudAnchor();
			}
		}

		private static void OnQuickSlotHudFollowsPanelChanged()
		{
			if (_quickSlotHudFollowsPanel.Value == Toggle.Off)
			{
				SaveQuickSlotHudAnchor();
			}
		}

		private static RectTransform? GetQuickSlotPanelStableParent(InventoryGrid playerGrid)
		{
			Canvas val = (((Object)(object)InventoryGui.instance != (Object)null) ? ((Component)InventoryGui.instance).GetComponentInParent<Canvas>() : null);
			if ((Object)(object)val != (Object)null)
			{
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val2 != null)
				{
					return val2;
				}
			}
			return playerGrid.m_gridRoot;
		}

		private static void DestroyDuplicateQuickSlotPanels(InventoryGrid playerGrid, RectTransform current)
		{
			HashSet<Transform> hashSet = new HashSet<Transform>();
			if ((Object)(object)((Transform)current).parent != (Object)null)
			{
				hashSet.Add(((Transform)current).parent);
			}
			if ((Object)(object)playerGrid.m_gridRoot != (Object)null)
			{
				hashSet.Add((Transform)(object)playerGrid.m_gridRoot);
			}
			foreach (Transform item in hashSet)
			{
				for (int num = item.childCount - 1; num >= 0; num--)
				{
					Transform child = item.GetChild(num);
					if (!((Object)(object)child == (Object)(object)current) && string.Equals(((Object)child).name, "InventorySlots_QuickSlotPanel", StringComparison.Ordinal))
					{
						Object.Destroy((Object)(object)((Component)child).gameObject);
					}
				}
			}
		}

		private static Vector3 ApplyQuickSlotPanelIntroAnimation(RectTransform panel, Vector3 targetPosition, float elementSpace)
		{
			//IL_000c: 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_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_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!InventoryPanels.QuickSlotPanelIntroActive)
			{
				return targetPosition;
			}
			float num = Mathf.Max(0.01f, InventoryPanels.QuickSlotPanelIntroDuration);
			float num2 = Time.unscaledTime - InventoryPanels.QuickSlotPanelIntroStartTime;
			if (num2 >= num)
			{
				InventoryPanels.QuickSlotPanelIntroActive = false;
				return targetPosition;
			}
			float num3 = Mathf.Clamp01(num2 / num);
			num3 = num3 * num3 * (3f - 2f * num3);
			float num4 = Mathf.Lerp(0f - GetQuickSlotPanelOffscreenDistance(panel, elementSpace), 0f, num3);
			return targetPosition + new Vector3(0f, num4, 0f);
		}

		private static float GetQuickSlotPanelOffscreenDistance(RectTransform panel, float elementSpace)
		{
			//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)
			Transform parent = ((Transform)panel).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			float num;
			if (val == null)
			{
				num = Screen.height;
			}
			else
			{
				Rect rect = val.rect;
				num = ((Rect)(ref rect)).height;
			}
			return Mathf.Max(num + Mathf.Max(1f, elementSpace) * 3f, Mathf.Max(1f, elementSpace) * 12f);
		}

		internal static void StartQuickSlotPanelIntroAnimation()
		{
			InventoryPanels.QuickSlotPanelOutroActive = false;
			InventoryPanels.QuickSlotPanelOutroStartPositions.Clear();
			InventoryPanels.QuickSlotPanelIntroStartTime = Time.unscaledTime;
			InventoryPanels.QuickSlotPanelIntroDuration = GetInventoryGuiAnimationDuration();
			InventoryPanels.QuickSlotPanelIntroActive = true;
		}

		internal static void StopQuickSlotPanelIntroAnimation()
		{
			InventoryPanels.QuickSlotPanelIntroActive = false;
		}

		internal static void StartQuickSlotPanelOutroAnimation()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			StopQuickSlotPanelIntroAnimation();
			InventoryPanels.QuickSlotPanelOutroStartPositions.Clear();
			foreach (RectTransform value in InventoryPanels.QuickSlotPanels.Values)
			{
				if (!IsUnityNull((Object?)(object)value) && ((Component)value).gameObject.activeSelf)
				{
					InventoryPanels.QuickSlotPanelOutroStartPositions[((Object)value).GetInstanceID()] = ((Transform)value).localPosition;
				}
			}
			if (InventoryPanels.QuickSlotPanelOutroStartPositions.Count == 0)
			{
				HideQuickSlotInventoryPanels();
				return;
			}
			InventoryPanels.QuickSlotPanelOutroStartTime = Time.unscaledTime;
			InventoryPanels.QuickSlotPanelOutroDuration = GetInventoryGuiAnimationDuration();
			InventoryPanels.QuickSlotPanelOutroActive = true;
		}

		internal static void UpdateQuickSlotInventoryPanelsWhileHidden()
		{
			//IL_00c8: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_011b: 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)
			if (!InventoryPanels.QuickSlotPanelOutroActive)
			{
				HideQuickSlotInventoryPanels();
				return;
			}
			float num = Mathf.Max(0.01f, InventoryPanels.QuickSlotPanelOutroDuration);
			float num2 = Time.unscaledTime - InventoryPanels.QuickSlotPanelOutroStartTime;
			if (num2 >= num)
			{
				HideQuickSlotInventoryPanels();
				return;
			}
			float num3 = Mathf.Clamp01(num2 / num);
			num3 = num3 * num3 * (3f - 2f * num3);
			foreach (RectTransform value2 in InventoryPanels.QuickSlotPanels.Values)
			{
				if (!IsUnityNull((Object?)(object)value2))
				{
					int instanceID = ((Object)value2).GetInstanceID();
					if (!InventoryPanels.QuickSlotPanelOutroStartPositions.TryGetValue(instanceID, out var value))
					{
						value = ((Transform)value2).localPosition;
						InventoryPanels.QuickSlotPanelOutroStartPositions[instanceID] = value;
					}
					float elementSpace = ((value2.sizeDelta.x > 1f) ? (value2.sizeDelta.x / 3f) : 70f);
					float num4 = Mathf.Lerp(0f, 0f - GetQuickSlotPanelOffscreenDistance(value2, elementSpace), num3);
					((Transform)value2).localPosition = value + new Vector3(0f, num4, 0f);
					((Component)value2).gameObject.SetActive(true);
				}
			}
		}

		internal static void HideQuickSlotInventoryPanels()
		{
			StopQuickSlotPanelIntroAnimation();
			InventoryPanels.QuickSlotPanelOutroActive = false;
			InventoryPanels.QuickSlotPanelOutroStartPositions.Clear();
			foreach (RectTransform value in InventoryPanels.QuickSlotPanels.Values)
			{
				if (!IsUnityNull((Object?)(object)value))
				{
					((Component)value).gameObject.SetActive(false);
				}
			}
		}

		private static float GetInventoryGuiAnimationDuration()
		{
			//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)
			Animator val = (((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_animator : null);
			if ((Object)(object)val == (Object)null)
			{
				return 0.25f;
			}
			RuntimeAnimatorController runtimeAnimatorController = val.runtimeAnimatorController;
			if ((Object)(object)runtimeAnimatorController != (Object)null)
			{
				AnimationClip val2 = (from c in runtimeAnimatorController.animationClips
					where (Object)(object)c != (Object)null && c.length > 0.05f && c.length < 2f
					orderby IsLikelyInventoryOpenClip(((Object)c).name) descending, Mathf.Abs(c.length - 0.25f)
					select c).FirstOrDefault();
				if ((Object)(object)val2 != (Object)null)
				{
					return Mathf.Clamp(val2.length, 0.05f, 1f);
				}
			}
			AnimatorStateInfo currentAnimatorStateInfo = val.GetCurrentAnimatorStateInfo(0);
			if (!(((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length > 0.05f) || !(((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length < 2f))
			{
				return 0.25f;
			}
			return Mathf.Clamp(((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length, 0.05f, 1f);
		}

		private static bool IsLikelyInventoryOpenClip(string clipName)
		{
			if (!string.IsNullOrWhiteSpace(clipName) && clipName.IndexOf("invent", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				if (clipName.IndexOf("open", StringComparison.OrdinalIgnoreCase) < 0 && clipName.IndexOf("show", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return clipName.IndexOf("in", StringComparison.OrdinalIgnoreCase) >= 0;
				}
				return true;
			}
			return false;
		}

		private static void UpdateQuickSlotsHud(Player player)
		{
			//IL_0080: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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)
			if (GetQuickSlotCount() <= 0 || (Object)(object)Hud.instance == (Object)null || (Object)(object)Hud.instance.m_rootObject == (Object)null)
			{
				ClearQuickSlotsHud();
				return;
			}
			List<SlotDefinition> quickPanelSlots = GetQuickPanelSlots(player);
			if (quickPanelSlots.Count == 0)
			{
				ClearQuickSlotsHud();
				return;
			}
			HotkeyBar val = EnsureQuickSlotsHotkeyBar();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)InventoryPanels.QuickSlotsHotkeyBarRect == (Object)null))
			{
				float quickSlotHudElementSpace = GetQuickSlotHudElementSpace();
				int quickPanelRows = GetQuickPanelRows(quickPanelSlots.Count);
				((Transform)InventoryPanels.QuickSlotsHotkeyBarRect).localPosition = GetQuickSlotHudPosition();
				InventoryPanels.QuickSlotsHotkeyBarRect.sizeDelta = new Vector2(3f * quickSlotHudElementSpace, (float)quickPanelRows * quickSlotHudElementSpace);
				val.m_elementSpace = quickSlotHudElementSpace;
				EnsureQuickSlotsHotkeyBarElementCount(val, quickPanelSlots.Count);
				Inventory inventory = ((Humanoid)player).GetInventory();
				for (int i = 0; i < quickPanelSlots.Count; i++)
				{
					SlotDefinition slot = quickPanelSlots[i];
					Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
					ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
					UpdateQuickSlotsHotkeyBarElement(player, val.m_elements[i], i, slot, itemAt, quickSlotHudElementSpace);
				}
			}
		}

		private static HotkeyBar? EnsureQuickSlotsHotkeyBar()
		{
			Transform val = (((Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null) ? Hud.instance.m_rootObject.transform : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (!IsUnityNull((Object?)(object)InventoryPanels.QuickSlotsHotkeyBarRect) && (Object)(object)((Transform)InventoryPanels.QuickSlotsHotkeyBarRect).parent == (Object)(object)val)
			{
				InventoryPanels.QuickSlotsHotkeyBar = ((Component)InventoryPanels.QuickSlotsHotkeyBarRect).GetComponent<HotkeyBar>();
				ConfigureQuickSlotsHotkeyBarRect(InventoryPanels.QuickSlotsHotkeyBarRect);
				((Component)InventoryPanels.QuickSlotsHotkeyBarRect).gameObject.SetActive(true);
				return InventoryPanels.QuickSlotsHotkeyBar;
			}
			Transform val2 = val.Find("InventorySlots_QuickSlotsHotKeyBar");
			InventoryPanels.QuickSlotsHotkeyBarRect = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<RectTransform>() : null);
			if ((Object)(object)InventoryPanels.QuickSlotsHotkeyBarRect == (Object)null)
			{
				Transform val3 = val.Find("HotKeyBar");
				RectTransform val4 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponent<RectTransform>() : null);
				if ((Object)(object)val4 == (Object)null)
				{
					return null;
				}
				InventoryPanels.QuickSlotsHotkeyBarRect = Object.Instantiate<RectTransform>(val4, val, false);
				((Object)InventoryPanels.QuickSlotsHotkeyBarRect).name = "InventorySlots_QuickSlotsHotKeyBar";
				((Transform)InventoryPanels.QuickSlotsHotkeyBarRect).SetSiblingIndex(((Transform)val4).GetSiblingIndex() + 1);
			}
			InventoryPanels.QuickSlotsHotkeyBar = ((Component)InventoryPanels.QuickSlotsHotkeyBarRect).GetComponent<HotkeyBar>();
			if ((Object)(object)InventoryPanels.QuickSlotsHotkeyBar == (Object)null)
			{
				return null;
			}
			((Behaviour)InventoryPanels.QuickSlotsHotkeyBar).enabled = false;
			InventoryPanels.QuickSlotsHotkeyBar.m_selected = -1;
			ClearQuickSlotsHotkeyBarChildren(InventoryPanels.QuickSlotsHotkeyBar);
			ConfigureQuickSlotsHotkeyBarRect(InventoryPanels.QuickSlotsHotkeyBarRect);
			((Component)InventoryPanels.QuickSlotsHotkeyBarRect).gameObject.SetActive(true);
			return InventoryPanels.QuickSlotsHotkeyBar;
		}

		private static void ConfigureQuickSlotsHotkeyBarRect(RectTransform rect)
		{
			//IL_000b: 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_0035: 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_004b: 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)
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = new Vector2(0f, 1f);
			rect.pivot = new Vector2(0f, 1f);
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
			((Transform)rect).localPosition = GetQuickSlotHudPosition();
		}

		private static void ClearQuickSlotsHotkeyBarChildren(HotkeyBar hotkeyBar)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			foreach (ElementData element in hotkeyBar.m_elements)
			{
				if (!IsUnityNull((Object?)(object)element.m_go))
				{
					Object.Destroy((Object)(object)element.m_go);
				}
			}
			hotkeyBar.m_elements.Clear();
			hotkeyBar.m_items.Clear();
			RectTransform val = (RectTransform)((Component)hotkeyBar).transform;
			GameObject elementPrefab = hotkeyBar.m_elementPrefab;
			for (int num = ((Transform)val).childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)((Transform)val).GetChild(num)).gameObject;
				if ((Object)(object)gameObject == (Object)(object)elementPrefab)
				{
					gameObject.SetActive(false);
				}
				else
				{
					gameObject.SetActive(false);
					Object.Destroy((Object)(object)gameObject);
				}
			}
		}

		private static void EnsureQuickSlotsHotkeyBarElementCount(HotkeyBar hotkeyBar, int count)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			while (hotkeyBar.m_elements.Count > count)
			{
				ElementData val = hotkeyBar.m_elements[hotkeyBar.m_elements.Count - 1];
				if (!IsUnityNull((Object?)(object)val.m_go))
				{
					Object.Destroy((Object)(object)val.m_go);
				}
				hotkeyBar.m_elements.RemoveAt(hotkeyBar.m_elements.Count - 1);
			}
			while (hotkeyBar.m_elements.Count < count)
			{
				ElementData val2 = new ElementData();
				val2.m_go = CreateCleanQuickHudElement(((Component)hotkeyBar).transform, hotkeyBar.m_elements.Count);
				Transform obj = val2.m_go.transform.Find("icon");
				val2.m_icon = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
				Transform obj2 = val2.m_go.transform.Find("durability");
				val2.m_durability = ((obj2 != null) ? ((Component)obj2).GetComponent<GuiBar>() : null);
				Transform obj3 = val2.m_go.transform.Find("amount");
				val2.m_amount = ((obj3 != null) ? ((Component)obj3).GetComponent<TMP_Text>() : null);
				Transform obj4 = val2.m_go.transform.Find("equiped");
				val2.m_equiped = ((obj4 != null) ? ((Component)obj4).gameObject : null);
				Transform obj5 = val2.m_go.transform.Find("queued");
				val2.m_queued = ((obj5 != null) ? ((Component)obj5).gameObject : null);
				Transform obj6 = val2.m_go.transform.Find("selected");
				val2.m_selection = ((obj6 != null) ? ((Component)obj6).gameObject : null);
				val2.m_used = false;
				hotkeyBar.m_elements.Add(val2);
				(val2.m_go.GetComponent<QuickHudSlotMarker>() ?? val2.m_go.AddComponent<QuickHudSlotMarker>()).Index = hotkeyBar.m_elements.Count - 1;
				UIInputHandler obj7 = val2.m_go.GetComponent<UIInputHandler>() ?? val2.m_go.AddComponent<UIInputHandler>();
				obj7.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(obj7.m_onLeftClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					SelectQuickHudSlot(((Component)handler).GetComponentInParent<QuickHudSlotMarker>());
				});
				obj7.m_onRightClick = (Action<UIInputHandler>)Delegate.Combine(obj7.m_onRightClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					UseQuickHudSlot(((Component)handler).GetComponentInParent<QuickHudSlotMarker>());
				});
			}
		}

		private static GameObject CreateCleanQuickHudElement(Transform parent, int index)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_0092: 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_00ed: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: 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_019d: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"InventorySlots_QuickHotkeySlot{index + 1}", new Type[5]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(UIInputHandler),
				typeof(UITooltip),
				typeof(QuickHudSlotMarker)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).color = new Color(0.055f, 0.035f, 0.025f, 0.25f);
			((Graphic)component).raycastTarget = true;
			CreateTopLeftImageChild("equiped", val.transform, new Color(0.42f, 0.68f, 0.92f, 0.34f), active: false);
			CreateTopLeftImageChild("queued", val.transform, new Color(1f, 0.68f, 0.18f, 0.28f), active: false);
			CreateTopLeftImageChild("selected", val.transform, new Color(1f, 1f, 1f, 0.16f), active: false);
			((Graphic)((Component)CreateTopLeftImageChild("icon", val.transform, Color.white, active: false)).GetComponent<Image>()).raycastTarget = false;
			RectTransform val2 = CreateTopLeftImageChild("durability", val.transform, new Color(0f, 0f, 0f, 0.7f), active: false);
			RectTransform val3 = CreateTopLeftImageChild("fill", (Transform)(object)val2, Color.white, active: true);
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = new Vector2(1f, 1f);
			val3.pivot = new Vector2(0f, 0.5f);
			val3.offsetMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			QuickHudSlotMarker component2 = val.GetComponent<QuickHudSlotMarker>();
			component2.DurabilityObject = ((Component)val2).gameObject;
			component2.DurabilityFill = ((Component)val3).GetComponent<Image>();
			CreateTextRect("amount", val.transform, out TMP_Text text);
			((Graphic)text).raycastTarget = false;
			text.alignment = (TextAlignmentOptions)1026;
			text.textWrappingMode = (TextWrappingModes)0;
			CreateTextRect("binding", val.transform, out TMP_Text text2);
			((Graphic)text2).raycastTarget = false;
			text2.alignment = (TextAlignmentOptions)257;
			text2.textWrappingMode = (TextWrappingModes)0;
			component2.BindingText = text2;
			return val;
		}

		private static void UpdateQuickSlotsHotkeyBarElement(Player player, ElementData element, int index, SlotDefinition slot, ItemData? item, float elementSpace)
		{
			//IL_001c: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			if (IsUnityNull((Object?)(object)element.m_go))
			{
				return;
			}
			element.m_go.transform.localPosition = GetQuickSlotPanelElementPosition(index, elementSpace);
			element.m_go.transform.localScale = Vector3.one;
			element.m_go.SetActive(true);
			element.m_used = item != null;
			QuickHudSlotMarker quickHudSlotMarker = element.m_go.GetComponent<QuickHudSlotMarker>() ?? element.m_go.AddComponent<QuickHudSlotMarker>();
			quickHudSlotMarker.Index = index;
			ConfigureQuickHudElementLayout(element, quickHudSlotMarker, elementSpace);
			ConfigureQuickSlotsHotkeyBarElementBackground(element);
			UpdateQuickSlotsHotkeyBarBinding(element, quickHudSlotMarker, slot);
			GameObject selection = element.m_selection;
			if (selection != null)
			{
				selection.SetActive(false);
			}
			GameObject equiped = element.m_equiped;
			if (equiped != null)
			{
				equiped.SetActive(false);
			}
			GameObject queued = element.m_queued;
			if (queued != null)
			{
				queued.SetActive(false);
			}
			if (item == null)
			{
				Image icon = element.m_icon;
				if (icon != null)
				{
					((Component)icon).gameObject.SetActive(false);
				}
				SetQuickHudDurability(element, quickHudSlotMarker, null);
				TMP_Text amount = element.m_amount;
				if (amount != null)
				{
					((Component)amount).gameObject.SetActive(false);
				}
				quickHudSlotMarker.TooltipHash = 0;
				SetQuickHotkeyBarTooltip(element, quickHudSlotMarker, "empty|" + slot.Id + "|" + slot.Name, slot.Name, "");
				return;
			}
			Image icon2 = element.m_icon;
			if (icon2 != null)
			{
				((Component)icon2).gameObject.SetActive(true);
			}
			if ((Object)(object)element.m_icon != (Object)null)
			{
				element.m_icon.sprite = item.GetIcon();
				((Graphic)element.m_icon).color = Color.white;
			}
			SetQuickHudDurability(element, quickHudSlotMarker, item);
			bool flag = item.m_shared.m_maxStackSize > 1;
			TMP_Text amount2 = element.m_amount;
			if (amount2 != null)
			{
				((Component)amount2).gameObject.SetActive(flag);
			}
			if (flag && (Object)(object)element.m_amount != (Object)null)
			{
				element.m_amount.text = $"{item.m_stack}/{item.m_shared.m_maxStackSize}";
			}
			GameObject equiped2 = element.m_equiped;
			if (equiped2 != null)
			{
				equiped2.SetActive(IsQuickSlotHudItemEquipped(player, item));
			}
			int quickHudTooltipHash = GetQuickHudTooltipHash(item);
			if (quickHudSlotMarker.TooltipHash != quickHudTooltipHash)
			{
				quickHudSlotMarker.TooltipHash = quickHudTooltipHash;
				SetQuickHotkeyBarTooltip(element, quickHudSlotMarker, "item|" + quickHudTooltipHash.ToString("X8"), item.m_shared.m_name, item.GetTooltip(-1));
			}
		}

		private static void ConfigureQuickHudElementLayout(ElementData element, QuickHudSlotMarker marker, float elementSpace)
		{
			//IL_004f: 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_0079: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_01d2: 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_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: 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_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: 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_02ec: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = element.m_go.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val == null)
			{
				return;
			}
			float num = Mathf.Max(24f, elementSpace - 8f);
			string text = num.ToString("0.###");
			if (!string.Equals(marker.LayoutSignature, text, StringComparison.Ordinal))
			{
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.pivot = new Vector2(0f, 1f);
				val.sizeDelta = new Vector2(num, num);
				((Transform)val).localRotation = Quaternion.identity;
				ConfigureQuickHudFullCellChild(((Transform)val).Find("equiped"), num);
				ConfigureQuickHudFullCellChild(((Transform)val).Find("queued"), num);
				ConfigureQuickHudFullCellChild(((Transform)val).Find("selected"), num);
				Transform obj = ((Transform)val).Find("icon");
				RectTransform val2 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val2 != null)
				{
					float num2 = Mathf.Clamp(num * 0.08f, 4f, 9f);
					val2.anchorMin = new Vector2(0f, 1f);
					val2.anchorMax = new Vector2(0f, 1f);
					val2.pivot = new Vector2(0f, 1f);
					val2.anchoredPosition = new Vector2(num2, 0f - num2);
					val2.sizeDelta = new Vector2(Mathf.Max(1f, num - num2 * 2f), Mathf.Max(1f, num - num2 * 2f));
					((Transform)val2).localScale = Vector3.one;
					((Transform)val2).localRotation = Quaternion.identity;
				}
				Transform obj2 = ((Transform)val).Find("durability");
				RectTransform val3 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				if (val3 != null)
				{
					float num3 = Mathf.Clamp(num * 0.08f, 4f, 8f);
					val3.anchorMin = new Vector2(0f, 0f);
					val3.anchorMax = new Vector2(1f, 0f);
					val3.pivot = new Vector2(0.5f, 0f);
					val3.offsetMin = new Vector2(num3, num3);
					val3.offsetMax = new Vector2(0f - num3, num3 + Mathf.Clamp(num * 0.08f, 4f, 7f));
					((Transform)val3).localScale = Vector3.one;
					((Transform)val3).localRotation = Quaternion.identity;
				}
				Transform obj3 = ((Transform)val).Find("amount");
				ConfigureQuickHudText((obj3 != null) ? ((Component)obj3).GetComponent<TMP_Text>() : null, num, (TextAlignmentOptions)1026, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 1f));
				Transform obj4 = ((Transform)val).Find("binding");
				ConfigureQuickHudText((obj4 != null) ? ((Component)obj4).GetComponent<TMP_Text>() : null, num, (TextAlignmentOptions)257, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(2f, -2f));
				marker.LayoutSignature = text;
			}
		}

		private static void ConfigureQuickHudFullCellChild(Transform? child, float cellSize)
		{
			//IL_0016: 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_0040: 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_0058: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
			if (val != null)
			{
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.pivot = new Vector2(0f, 1f);
				val.anchoredPosition = Vector2.zero;
				val.sizeDelta = new Vector2(cellSize, cellSize);
				((Transform)val).localScale = Vector3.one;
				((Transform)val).localRotation = Quaternion.identity;
			}
		}

		private static void ConfigureQuickHudText(TMP_Text? text, float cellSize, TextAlignmentOptions alignment, Vector2 anchor, Vector2 pivot, Vector2 anchoredPosition)
		{
			//IL_0011: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)text == (Object)null))
			{
				ApplyDefaultFontAsset(text);
				text.alignment = alignment;
				text.enableAutoSizing = true;
				text.fontSizeMin = 8f;
				text.fontSizeMax = Mathf.Clamp(cellSize * 0.24f, 12f, 16f);
				text.textWrappingMode = (TextWrappingModes)0;
				text.overflowMode = (TextOverflowModes)0;
				((Graphic)text).raycastTarget = false;
				RectTransform rectTransform = text.rectTransform;
				rectTransform.anchorMin = anchor;
				rectTransform.anchorMax = anchor;
				rectTransform.pivot = pivot;
				rectTransform.anchoredPosition = anchoredPosition;
				rectTransform.sizeDelta = new Vector2(cellSize, Mathf.Clamp(cellSize * 0.32f, 18f, 26f));
				((Transform)rectTransform).localScale = Vector3.one;
				((Transform)rectTransform).localRotation = Quaternion.identity;
			}
		}

		private static void SetQuickHudDurability(ElementData element, QuickHudSlotMarker marker, ItemData? item)
		{
			//IL_00da: 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_015f: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = marker.DurabilityObject;
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
			{
				Transform val2 = element.m_go.transform.Find("durability");
				val = (marker.DurabilityObject = (((Object)(object)val2 != (Object)null) ? ((Component)val2).gameObject : null));
			}
			bool flag = item != null && item.m_shared.m_useDurability && item.m_durability < item.GetMaxDurability();
			if (val != null)
			{
				val.SetActive(flag);
			}
			if (!flag || item == null)
			{
				return;
			}
			if ((Object)(object)element.m_durability != (Object)null && !IsUnityNull((Object?)(object)element.m_durability))
			{
				if (item.m_durability <= 0f)
				{
					element.m_durability.SetValue(1f);
					element.m_durability.SetColor((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.clear);
				}
				else
				{
					element.m_durability.SetValue(item.GetDurabilityPercentage());
					element.m_durability.ResetColor();
				}
				return;
			}
			Image durabilityFill = marker.DurabilityFill;
			if (!((Object)(object)durabilityFill == (Object)null) && !IsUnityNull((Object?)(object)durabilityFill))
			{
				float num = ((item.m_durability <= 0f) ? 1f : Mathf.Clamp01(item.GetDurabilityPercentage()));
				Color color = ((item.m_durability <= 0f && Mathf.Sin(Time.time * 10f) <= 0f) ? Color.clear : Color.white);
				((Graphic)durabilityFill).color = color;
				RectTransform rectTransform = ((Graphic)durabilityFill).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = new Vector2(num, 1f);
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
			}
		}

		private static bool IsQuickSlotHudItemEquipped(Player player, ItemData item)
		{
			try
			{
				return ((Humanoid)player).IsItemEquiped(item) || item.m_equipped;
			}
			catch
			{
				return item.m_equipped;
			}
		}

		private static void ConfigureQuickSlotsHotkeyBarElementBackground(ElementData element)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			Image component = element.m_go.GetComponent<Image>();
			if (!((Object)(object)component == (Object)null))
			{
				Color color = ((Graphic)component).color;
				color.a = 0.25f;
				((Graphic)component).color = color;
				((Graphic)component).raycastTarget = true;
			}
		}

		private static void UpdateQuickSlotsHotkeyBarBinding(ElementData element, QuickHudSlotMarker marker, SlotDefinition slot)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text val = (((Object)(object)marker.BindingText != (Object)null && !IsUnityNull((Object?)(object)marker.BindingText)) ? marker.BindingText : null);
			if ((Object)(object)val == (Object)null)
			{
				Transform val2 = element.m_go.transform.Find("binding");
				val = (marker.BindingText = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<TMP_Text>() : null));
			}
			if (!((Object)(object)val == (Object)null))
			{
				string quickSlotBindingText = GetQuickSlotBindingText(slot);
				string text = slot.Id + "|" + quickSlotBindingText;
				if (!string.Equals(marker.BindingSignature, text, StringComparison.Ordinal))
				{
					ApplyDefaultFontAsset(val);
					val.text = quickSlotBindingText;
					((Behaviour)val).enabled = true;
					val.enableAutoSizing = true;
					val.fontSizeMin = 12f;
					val.fontSizeMax = 16f;
					val.alignment = (TextAlignmentOptions)257;
					val.textWrappingMode = (TextWrappingModes)0;
					val.overflowMode = (TextOverflowModes)0;
					((Graphic)val).color = new Color(0.68f, 0.88f, 1f, 1f);
					marker.BindingSignature = text;
				}
			}
		}

		private static void SetQuickHotkeyBarTooltip(ElementData element, QuickHudSlotMarker marker, string signature, string topic, string text)
		{
			if (!string.Equals(marker.TooltipSignature, signature, StringComparison.Ordinal) || !string.Equals(marker.TooltipTopic, topic, StringComparison.Ordinal) || !string.Equals(marker.TooltipText, text ?? "", StringComparison.Ordinal))
			{
				UITooltip obj = element.m_go.GetComponent<UITooltip>() ?? element.m_go.AddComponent<UITooltip>();
				EnsureTooltipPrefab(obj);
				obj.m_topic = topic;
				obj.m_text = text ?? "";
				marker.TooltipSignature = signature;
				marker.TooltipTopic = topic;
				marker.TooltipText = text ?? "";
			}
		}

		private static int GetQuickHudTooltipHash(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return 0;
			}
			int num = 17;
			num = num * 31 + StringComparer.Ordinal.GetHashCode(GetItemPrefabName(item));
			num = num * 31 + StringComparer.Ordinal.GetHashCode(item.m_shared.m_name ?? "");
			num = num * 31 + item.m_quality;
			num = num * 31 + item.m_variant;
			num = num * 31 + item.m_stack;
			num = num * 31 + Mathf.RoundToInt(item.m_durability * 1000f);
			num = num * 31 + (item.m_equipped ? 1 : 0);
			if (item.m_customData != null)
			{
				foreach (KeyValuePair<string, string> customDatum in item.m_customData)
				{
					num = num * 31 + StringComparer.Ordinal.GetHashCode(customDatum.Key ?? "");
					num = num * 31 + StringComparer.Ordinal.GetHashCode(customDatum.Value ?? "");
				}
			}
			return num;
		}

		private static float GetQuickSlotHudElementSpace()
		{
			if (InventoryPanels.QuickSlotHudAnchorValid)
			{
				return Mathf.Max(1f, InventoryPanels.QuickSlotHudElementSpace);
			}
			if ((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)InventoryGui.instance.m_playerGrid != (Object)null)
			{
				return Mathf.Max(1f, InventoryGui.instance.m_playerGrid.m_elementSpace);
			}
			return GetHudElementSpace();
		}

		private static Vector3 GetQuickSlotHudPosition()
		{
			//IL_001c: 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)
			if (!InventoryPanels.QuickSlotHudAnchorValid)
			{
				return Vector2.op_Implicit(QuickSlotsHudFallbackPosition);
			}
			return InventoryPanels.QuickSlotHudAnchoredPosition;
		}

		private static float GetHudElementSpace()
		{
			Transform val = (((Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null) ? Hud.instance.m_rootObject.transform.Find("HotKeyBar") : null);
			HotkeyBar val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<HotkeyBar>() : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return 70f;
			}
			return val2.m_elementSpace;
		}

		internal static void EnsureTooltipPrefab(UITooltip? tooltip)
		{
			if (!((Object)(object)tooltip == (Object)null) && !((Object)(object)tooltip.m_tooltipPrefab != (Object)null))
			{
				UITooltip val = FindTooltipPrefabSource();
				if ((Object)(object)val != (Object)null && (Object)(object)val.m_tooltipPrefab != (Object)null)
				{
					tooltip.m_tooltipPrefab = val.m_tooltipPrefab;
				}
			}
		}

		private static UITooltip? FindTooltipPrefabSource()
		{
			InventoryGui instance = InventoryGui.instance;
			UITooltip val = (((Object)(object)instance?.m_playerGrid?.m_elementPrefab != (Object)null) ? instance.m_playerGrid.m_elementPrefab.GetComponent<UITooltip>() : null);
			if ((Object)(object)val?.m_tooltipPrefab != (Object)null)
			{
				return val;
			}
			if (instance?.m_playerGrid?.m_elements != null)
			{
				foreach (Element element in instance.m_playerGrid.m_elements)
				{
					val = ((!IsUnityNull((Object?)(object)element?.m_go)) ? element.m_go.GetComponent<UITooltip>() : null);
					if ((Object)(object)val?.m_tooltipPrefab != (Object)null)
					{
						return val;
					}
				}
			}
			Transform val2 = (((Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null) ? Hud.instance.m_rootObject.transform.Find("HotKeyBar") : null);
			HotkeyBar val3 = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<HotkeyBar>() : null);
			val = (((Object)(object)val3?.m_elementPrefab != (Object)null) ? val3.m_elementPrefab.GetComponent<UITooltip>() : null);
			if ((Object)(object)val?.m_tooltipPrefab != (Object)null)
			{
				return val;
			}
			if (val3?.m_elements != null)
			{
				foreach (ElementData element2 in val3.m_elements)
				{
					val = (((Object)(object)element2?.m_go != (Object)null) ? element2.m_go.GetComponent<UITooltip>() : null);
					if ((Object)(object)val?.m_tooltipPrefab != (Object)null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static void SelectQuickHudSlot(QuickHudSlotMarker? marker)
		{
			//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_0061: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)marker == (Object)null) && InventoryGui.IsVisible() && !((Object)(object)InventoryGui.instance == (Object)null) && !((Object)(object)InventoryGui.instance.m_playerGrid == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (TryGetQuickSlotDefinition(marker.Index, out SlotDefinition slot))
				{
					Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
					ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
					InventoryGui.instance.OnSelectedItem(InventoryGui.instance.m_playerGrid, itemAt, slotGridPos, (Modifier)0);
				}
			}
		}

		private static void UseQuickHudSlot(QuickHudSlotMarker? marker)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			if (TryGetQuickSlotDefinition(marker.Index, out SlotDefinition slot))
			{
				Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
				ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
				if (itemAt != null && slot.Accepts(itemAt))
				{
					((Humanoid)Player.m_localPlayer).UseItem(inventory, itemAt, InventoryGui.IsVisible());
					inventory.Changed();
				}
			}
		}

		private static void ClearQuickSlotsHud()
		{
			if (!IsUnityNull((Object?)(object)InventoryPanels.QuickSlotsHotkeyBarRect))
			{
				Object.Destroy((Object)(object)((Component)InventoryPanels.QuickSlotsHotkeyBarRect).gameObject);
			}
			InventoryPanels.QuickSlotsHotkeyBarRect = null;
			InventoryPanels.QuickSlotsHotkeyBar = null;
		}

		private static Vector3 GetCustomSlotPanelElementPosition(int index, float elementSpace)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)(index / 3) * elementSpace, (float)(-(index % 3)) * elementSpace, 0f);
		}

		private static Vector3 GetQuickSlotPanelElementPosition(int index, float elementSpace)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)(index % 3) * elementSpace, (float)(-(index / 3)) * elementSpace, 0f);
		}

		private static int GetCustomPanelColumns(int slotCount)
		{
			if (slotCount > 0)
			{
				return Mathf.CeilToInt((float)slotCount / 3f);
			}
			return 0;
		}

		private static int GetQuickPanelRows(int slotCount)
		{
			if (slotCount > 0)
			{
				return Mathf.CeilToInt((float)slotCount / 3f);
			}
			return 0;
		}

		private static int GetInventoryViewportRows(int totalRegularRows)
		{
			int num = Mathf.Clamp(totalRegularRows, 4, 9);
			if (!UseExpandableInventoryRows())
			{
				return Mathf.Max(1, num);
			}
			int lastExpandableInventoryRows = GetLastExpandableInventoryRows(num);
			return Mathf.Clamp(Mathf.Min(num, lastExpandableInventoryRows), 1, Mathf.Max(1, num));
		}

		private static int UpdatePlayerInventoryScroll(InventoryGrid playerGrid, int viewportRows, int totalRegularRows)
		{
			if (UseExpandableInventoryRows())
			{
				HandlePlayerInventoryExpandableWheel(playerGrid, totalRegularRows);
				viewportRows = GetInventoryViewportRows(totalRegularRows);
			}
			return viewportRows;
		}

		private static bool UseExpandableInventoryRows()
		{
			if (_inventoryRowsDisplayMode != null)
			{
				return _inventoryRowsDisplayMode.Value == InventoryRowsDisplayMode.Expandable;
			}
			return true;
		}

		private static void HandlePlayerInventoryExpandableWheel(InventoryGrid playerGrid, int totalRegularRows)
		{
			if (totalRegularRows > 4 && InventoryGui.IsVisible() && !ShouldSuppressInventoryContainerRowsWheel() && (IsMouseOverPlayerInventory(playerGrid) || IsGamepadUiScrollActive()))
			{
				float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Discrete);
				if (!(Mathf.Abs(uiScrollDelta) < 0.01f))
				{
					int num = ((uiScrollDelta < 0f) ? 1 : (-1));
					SetExpandableInventoryRows(GetLastExpandableInventoryRows(totalRegularRows) + num, totalRegularRows);
				}
			}
		}

		private static int GetLastExpandableInventoryRows(int totalRegularRows)
		{
			EnsureLastExpandableInventoryRowsLoaded();
			int num = Mathf.Clamp(totalRegularRows, 4, 9);
			return Mathf.Clamp(InventoryPanels.LastExpandableInventoryRows, 4, num);
		}

		private static void SetExpandableInventoryRows(int rows, int totalRegularRows)
		{
			EnsureLastExpandableInventoryRowsLoaded();
			int num = Mathf.Clamp(totalRegularRows, 4, 9);
			int num2 = Mathf.Clamp(rows, 4, num);
			if (InventoryPanels.LastExpandableInventoryRows != num2)
			{
				InventoryPanels.LastExpandableInventoryRows = num2;
				SaveLastExpandableInventoryRows();
			}
		}

		private static void EnsureLastExpandableInventoryRowsLoaded()
		{
			if (InventoryPanels.LastExpandableInventoryRowsLoaded)
			{
				return;
			}
			InventoryPanels.LastExpandableInventoryRowsLoaded = true;
			try
			{
				EnsureClientStateLoaded();
				InventoryPanels.LastExpandableInventoryRows = Mathf.Clamp(InventoryClient.ClientState.Inventory.LastExpandableRows, 4, 9);
			}
			catch (Exception)
			{
			}
		}

		private static void SaveLastExpandableInventoryRows()
		{
			try
			{
				EnsureClientStateLoaded();
				InventoryClient.ClientState.Inventory.LastExpandableRows = InventoryPanels.LastExpandableInventoryRows;
				SaveClientState();
			}
			catch (Exception)
			{
			}
		}

		private static bool IsMouseOverPlayerInventory(InventoryGrid playerGrid)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			if ((Object)(object)playerGrid == (Object)null)
			{
				return false;
			}
			Vector2 uiMousePosition = GetUiMousePosition();
			if ((Object)(object)playerGrid.m_gridRoot != (Object)null && RectContainsScreenPoint(playerGrid.m_gridRoot, uiMousePosition))
			{
				return true;
			}
			if ((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)InventoryGui.instance.m_player != (Object)null)
			{
				return RectContainsScreenPoint(InventoryGui.instance.m_player, uiMousePosition);
			}
			return false;
		}

		private static bool RectContainsScreenPoint(RectTransform rectTransform, Vector2 screenPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_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_001b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Vector2.op_Implicit(((Transform)rectTransform).InverseTransformPoint(Vector2.op_Implicit(screenPoint)));
			Rect rect = rectTransform.rect;
			return ((Rect)(ref rect)).Contains(val);
		}

		private static Vector3 GetSidePanelBasePosition(Vector3 origin, int inventoryWidth, float elementSpace)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			return origin + new Vector3(((float)inventoryWidth + 1.45f) * elementSpace, 0f, 0f);
		}

		internal static bool TryGetSlotAtGridPos(Inventory inventory, Vector2i pos, out SlotDefinition? slot)
		{
			//IL_0010: 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)
			slot = null;
			int width = inventory.GetWidth();
			int fixedRegularRows = GetFixedRegularRows();
			if (pos.y < fixedRegularRows)
			{
				return false;
			}
			int num = (pos.y - fixedRegularRows) * width + pos.x;
			if (num < 0 || num >= SlotDefinitions.Count)
			{
				return false;
			}
			slot = SlotDefinitions[num];
			return true;
		}

		internal static bool TryGetSlotById(string id, out SlotDefinition? slot)
		{
			slot = null;
			for (int i = 0; i < SlotDefinitions.Count; i++)
			{
				SlotDefinition slotDefinition = SlotDefinitions[i];
				if (string.Equals(slotDefinition.Id, id, StringComparison.Ordinal))
				{
					slot = slotDefinition;
					return true;
				}
			}
			return false;
		}

		private static List<SlotDefinition> GetCustomPanelSlots(Player? player = null, Inventory? inventory = null)
		{
			if (!IsEquipmentSlotProgressionEnabled() || (Object)(object)player == (Object)null)
			{
				return GetCachedCustomPanelSlots();
			}
			string visibleEquipmentSlotUnlockSignature = GetVisibleEquipmentSlotUnlockSignature(player, inventory);
			if (InventoryDefinitions.VisibleCustomPanelSlotCacheVersion == InventoryDefinitions.SlotDefinitionVersion && string.Equals(InventoryDefinitions.VisibleCustomPanelSlotCacheSignature, visibleEquipmentSlotUnlockSignature, StringComparison.Ordinal))
			{
				return InventoryDefinitions.VisibleCustomPanelSlotCache;
			}
			InventoryDefinitions.VisibleCustomPanelSlotCache.Clear();
			foreach (SlotDefinition cachedCustomPanelSlot in GetCachedCustomPanelSlots())
			{
				if (IsEquipmentSlotUnlocked(player, inventory, cachedCustomPanelSlot))
				{
					InventoryDefinitions.VisibleCustomPanelSlotCache.Add(cachedCustomPanelSlot);
				}
			}
			InventoryDefinitions.VisibleCustomPanelSlotCacheVersion = InventoryDefinitions.SlotDefinitionVersion;
			InventoryDefinitions.VisibleCustomPanelSlotCacheSignature = visibleEquipmentSlotUnlockSignature;
			return InventoryDefinitions.VisibleCustomPanelSlotCache;
		}

		private static List<SlotDefinition> GetQuickPanelSlots(Player? player = null)
		{
			int unlockedQuickSlotCount = GetUnlockedQuickSlotCount(player);
			if (InventoryDefinitions.QuickPanelSlotCacheVersion == InventoryDefinitions.SlotDefinitionVersion && InventoryDefinitions.QuickPanelSlotCacheUnlockedCount == unlockedQuickSlotCount)
			{
				return InventoryDefinitions.QuickPanelSlotCache;
			}
			InventoryDefinitions.QuickPanelSlotCache.Clear();
			for (int i = 0; i < SlotDefinitions.Count; i++)
			{
				SlotDefinition slotDefinition = SlotDefinitions[i];
				if (slotDefinition.Kind == SlotKind.Quick && slotDefinition.QuickSlotIndex >= 0 && slotDefinition.QuickSlotIndex < unlockedQuickSlotCount)
				{
					InventoryDefinitions.QuickPanelSlotCache.Add(slotDefinition);
				}
			}
			InventoryDefinitions.QuickPanelSlotCacheVersion = InventoryDefinitions.SlotDefinitionVersion;
			InventoryDefinitions.QuickPanelSlotCacheUnlockedCount = unlockedQuickSlotCount;
			return InventoryDefinitions.QuickPanelSlotCache;
		}

		private static bool TryGetQuickSlotDefinition(int quickSlotIndex, out SlotDefinition? slot)
		{
			if (InventoryDefinitions.QuickSlotDefinitionCacheVersion != InventoryDefinitions.SlotDefinitionVersion)
			{
				InventoryDefinitions.QuickSlotDefinitionCache.Clear();
				for (int i = 0; i < SlotDefinitions.Count; i++)
				{
					SlotDefinition slotDefinition = SlotDefinitions[i];
					if (slotDefinition.Kind == SlotKind.Quick && slotDefinition.QuickSlotIndex >= 0)
					{
						InventoryDefinitions.QuickSlotDefinitionCache[slotDefinition.QuickSlotIndex] = slotDefinition;
					}
				}
				InventoryDefinitions.QuickSlotDefinitionCacheVersion = InventoryDefinitions.SlotDefinitionVersion;
			}
			return InventoryDefinitions.QuickSlotDefinitionCache.TryGetValue(quickSlotIndex, out slot);
		}

		private static Vector2i GetSlotGridPos(Inventory inventory, SlotDefinition slot)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			int num = SlotDefinitions.IndexOf(slot);
			int width = inventory.GetWidth();
			return new Vector2i(num % width, GetFixedRegularRows() + num / width);
		}

		private static List<SlotDefinition> GetCachedCustomPanelSlots()
		{
			if (InventoryDefinitions.CustomPanelSlotCacheVersion == InventoryDefinitions.SlotDefinitionVersion)
			{
				return InventoryDefinitions.CustomPanelSlotCache;
			}
			InventoryDefinitions.CustomPanelSlotCache.Clear();
			for (int i = 0; i < SlotDefinitions.Count; i++)
			{
				SlotDefinition slotDefinition = SlotDefinitions[i];
				if (slotDefinition.Kind != SlotKind.Quick)
				{
					InventoryDefinitions.CustomPanelSlotCache.Add(slotDefinition);
				}
			}
			InventoryDefinitions.CustomPanelSlotCacheVersion = InventoryDefinitions.SlotDefinitionVersion;
			return InventoryDefinitions.CustomPanelSlotCache;
		}

		internal static bool IsLockedRowCell(Player player, Vector2i pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (pos.y >= GetUsableRegularRows(player))
			{
				return pos.y < GetFixedRegularRows();
			}
			return false;
		}

		private static bool IsExternalReservedCell(Vector2i pos, bool includeRestockableSlots)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsBetterArcheryQuiverCell(pos, includeRestockableSlots);
		}

		internal static bool IsExternalReservedForCompat(Vector2i pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsExternalReservedCell(pos, includeRestockableSlots: true);
		}

		private static bool IsOutOfBounds(Inventory inventory, Vector2i pos)
		{
			//IL_0000: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (pos.x >= 0 && pos.x < inventory.GetWidth() && pos.y >= 0)
			{
				return pos.y >= inventory.GetHeight();
			}
			return true;
		}

		internal static int GetInventoryFullHeight(int width)
		{
			return GetFullHeightForWidth(width);
		}

		private static int GetFullHeightForWidth(int width)
		{
			return GetFixedRegularRows() + GetSlotTailRows(width);
		}

		private static int GetFixedRegularRows()
		{
			return 9;
		}

		private static int GetSlotTailRows(int width)
		{
			if (SlotDefinitions.Count != 0)
			{
				return Mathf.CeilToInt((float)SlotDefinitions.Count / (float)Mathf.Max(1, width));
			}
			return 0;
		}

		private static int GetUsableRegularRows(Player player)
		{
			return 4 + CalculateUnlockedRows(player);
		}

		private static int CalculateUnlockedRows(Player player)
		{
			if (_progressiveRowsEnabled == null || _progressiveRowsEnabled.Value.IsOff())
			{
				return GetMaxExtraRows();
			}
			RefreshItemNameTokens();
			int maxExtraRows = GetMaxExtraRows();
			int num = 0;
			for (int i = 0; i < maxExtraRows && IsRowUnlocked(player, _rowUnlockItems[i].Value); i++)
			{
				num++;
			}
			return num;
		}

		private static int GetMaxExtraRows()
		{
			if (_maxExtraRows != null)
			{
				return Mathf.Clamp(_maxExtraRows.Value, 0, 5);
			}
			return 5;
		}

		private static int GetQuickSlotCount()
		{
			return ((_quickSlotRows != null) ? Mathf.Clamp(_quickSlotRows.Value, 0, 3) : 0) * 3;
		}

		private static int GetUnlockedQuickSlotCount(Player? player)
		{
			int quickSlotCount = GetQuickSlotCount();
			if (quickSlotCount <= 0)
			{
				return 0;
			}
			return Mathf.Clamp(GetUnlockedQuickSlotRows(player) * 3, 0, quickSlotCount);
		}

		private static int GetUnlockedQuickSlotRows(Player? player)
		{
			int quickSlotCount = GetQuickSlotCount();
			if (quickSlotCount <= 0)
			{
				return 0;
			}
			int num = Mathf.CeilToInt((float)quickSlotCount / 3f);
			if (num <= 1 || (Object)(object)player == (Object)null || _quickSlotProgressionEnabled == null || _quickSlotProgressionEnabled.Value.IsOff())
			{
				return num;
			}
			int naturallyUnlockedQuickSlotRows = GetNaturallyUnlockedQuickSlotRows(player, num);
			return GetStableUnlockedQuickSlotRows(player, naturallyUnlockedQuickSlotRows, num);
		}

		private static int GetNaturallyUnlockedQuickSlotRows(Player? player, int reservedRows)
		{
			if (reservedRows <= 1 || (Object)(object)player == (Object)null || _quickSlotProgressionEnabled == null || _quickSlotProgressionEnabled.Value.IsOff())
			{
				return Math.Max(0, reservedRows);
			}
			RefreshItemNameTokens();
			int result = 1;
			if (reservedRows >= 2 && _quickSlotRowUnlockItems.Length != 0 && IsRowUnlocked(player, _quickSlotRowUnlockItems[0].Value))
			{
				result = 2;
				if (reservedRows >= 3 && _quickSlotRowUnlockItems.Length > 1 && IsRowUnlocked(player, _quickSlotRowUnlockItems[1].Value))
				{
					result = 3;
				}
				return Mathf.Clamp(result, 1, reservedRows);
			}
			return result;
		}

		private static int GetStableUnlockedQuickSlotRows(Player player, int unlockedRows, int reservedRows)
		{
			string playerId = GetPlayerId(player);
			if (!string.Equals(QuickSlotProgressionCachePlayerId, playerId, StringComparison.Ordinal))
			{
				QuickSlotProgressionCachePlayerId = playerId;
				QuickSlotProgressionCachedRows = 0;
			}
			if (QuickSlotProgressionCachedRows <= 0)
			{
				QuickSlotProgressionCachedRows = unlockedRows;
			}
			else if (!player.m_isLoading)
			{
				HashSet<string> knownMaterial = player.m_knownMaterial;
				if (knownMaterial != null && knownMaterial.Count > 0)
				{
					QuickSlotProgressionCachedRows = Math.Max(QuickSlotProgressionCachedRows, unlockedRows);
				}
			}
			return Mathf.Clamp(Math.Max(unlockedRows, QuickSlotProgressionCachedRows), 1, reservedRows);
		}

		internal static void OnPlayerProgressionReset(Player player)
		{
			if (!IsUnityNull((Object?)(object)player) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				QuickSlotProgressionResetPendingPlayerId = GetPlayerId(player);
				QuickSlotProgressionResetWarningPlayerId = "";
				InvalidateQuickSlotProgressionPanelCache();
				RequestInventoryStateEnsure(player, InventoryStateEnsureReason.ProgressionReset, InventoryStateAuditLevel.FullIntegrity);
			}
		}

		private static bool HasPendingQuickSlotProgressionReset(Player player)
		{
			if (!IsUnityNull((Object?)(object)player) && (Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return string.Equals(QuickSlotProgressionResetPendingPlayerId, GetPlayerId(player), StringComparison.Ordinal);
			}
			return false;
		}

		private static void PreserveOccupiedQuickSlotRowsDuringLoad(Player player, Inventory inventory)
		{
			if (IsUnityNull((Object?)(object)player) || inventory == null)
			{
				return;
			}
			int highestOccupiedQuickSlotRow = GetHighestOccupiedQuickSlotRow(inventory);
			if (highestOccupiedQuickSlotRow > 1)
			{
				string playerId = GetPlayerId(player);
				if (!string.Equals(QuickSlotProgressionCachePlayerId, playerId, StringComparison.Ordinal))
				{
					QuickSlotProgressionCachePlayerId = playerId;
					QuickSlotProgressionCachedRows = 0;
				}
				int quickSlotProgressionCachedRows = QuickSlotProgressionCachedRows;
				QuickSlotProgressionCachedRows = Math.Max(QuickSlotProgressionCachedRows, highestOccupiedQuickSlotRow);
				if (QuickSlotProgressionCachedRows != quickSlotProgressionCachedRows)
				{
					InvalidateQuickSlotProgressionPanelCache();
				}
			}
		}

		private static bool IsItemProgressionLookupReady(Player player)
		{
			if (player.m_isLoading)
			{
				return false;
			}
			RefreshItemNameTokens();
			ObjectDB instance = ObjectDB.instance;
			if (!IsUnityNull((Object?)(object)instance))
			{
				List<GameObject> items = instance.m_items;
				if (items != null && items.Count > 0)
				{
					return ItemNameTokens.Count > 0;
				}
			}
			return false;
		}

		private static bool IsRegularRowProgressionLookupReady(Player player)
		{
			if (_progressiveRowsEnabled == null || _progressiveRowsEnabled.Value.IsOff() || GetMaxExtraRows() <= 0)
			{
				return true;
			}
			return IsItemProgressionLookupReady(player);
		}

		private static bool IsQuickSlotProgressionLookupReady(Player player, int configuredRows)
		{
			if (configuredRows <= 1 || _quickSlotProgressionEnabled == null || _quickSlotProgressionEnabled.Value.IsOff())
			{
				return true;
			}
			return IsItemProgressionLookupReady(player);
		}

		private static bool ReconcilePendingQuickSlotProgressionReset(Player player, Inventory inventory)
		{
			if (!HasPendingQuickSlotProgressionReset(player) || inventory == null)
			{
				return false;
			}
			int quickSlotCount = GetQuickSlotCount();
			int num = ((quickSlotCount > 0) ? Mathf.CeilToInt((float)quickSlotCount / 3f) : 0);
			if (!IsQuickSlotProgressionLookupReady(player, num))
			{
				return false;
			}
			int naturallyUnlockedQuickSlotRows = GetNaturallyUnlockedQuickSlotRows(player, num);
			int movedItemCount = 0;
			int blockedItemCount = 0;
			int num2 = InventorySlotSafetyCore.ResolveQuickSlotProgressionResetRows(num, naturallyUnlockedQuickSlotRows, delegate(int row)
			{
				int movedItemCount2;
				int rowItemCount;
				bool num3 = TryMoveQuickSlotProgressionRowToRegularCells(player, inventory, row, out movedItemCount2, out rowItemCount);
				movedItemCount += movedItemCount2;
				if (!num3)
				{
					blockedItemCount = rowItemCount;
				}
				return num3;
			});
			string text = (QuickSlotProgressionCachePlayerId = GetPlayerId(player));
			QuickSlotProgressionCachedRows = num2;
			InvalidateQuickSlotProgressionPanelCache();
			if (num2 <= naturallyUnlockedQuickSlotRows)
			{
				QuickSlotProgressionResetPendingPlayerId = "";
				QuickSlotProgressionResetWarningPlayerId = "";
			}
			else
			{
				QuickSlotProgressionResetPendingPlayerId = text;
				WarnQuickSlotProgressionResetDeferred(player, text, num2, blockedItemCount);
			}
			return movedItemCount > 0;
		}

		private static bool TryMoveQuickSlotProgressionRowToRegularCells(Player player, Inventory inventory, int row, out int movedItemCount, out int rowItemCount)
		{
			//IL_0021: 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_00d1: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition slot) && slot.Kind == SlotKind.Quick && slot.QuickSlotIndex >= 0 && slot.QuickSlotIndex / 3 + 1 == row)
				{
					list.Add(item);
				}
			}
			movedItemCount = 0;
			rowItemCount = list.Count;
			if (list.Count == 0)
			{
				return true;
			}
			if (CountUsableRegularEmptyCells(inventory, player) < list.Count)
			{
				return false;
			}
			List<Vector2i> list2 = new List<Vector2i>(list.Count);
			foreach (ItemData item2 in list)
			{
				list2.Add(item2.m_gridPos);
				if (TryFindFreeAutomaticPlacementCell(player, inventory, null, out var pos))
				{
					item2.m_gridPos = pos;
					movedItemCount++;
					continue;
				}
				for (int i = 0; i < movedItemCount; i++)
				{
					list[i].m_gridPos = list2[i];
				}
				movedItemCount = 0;
				return false;
			}
			return true;
		}

		private static int GetHighestOccupiedQuickSlotRow(Inventory inventory)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition slot) && slot.Kind == SlotKind.Quick && slot.QuickSlotIndex >= 0)
				{
					num = Math.Max(num, slot.QuickSlotIndex / 3 + 1);
				}
			}
			return num;
		}

		private static void WarnQuickSlotProgressionResetDeferred(Player player, string playerId, int requiredRows, int blockedItemCount)
		{
			if (!string.Equals(QuickSlotProgressionResetWarningPlayerId, playerId, StringComparison.Ordinal))
			{
				QuickSlotProgressionResetWarningPlayerId = playerId;
				((Character)player).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
				Log.LogWarning((object)($"Quick slot progression reset kept rows 1-{requiredRows} available because row {requiredRows} contains {blockedItemCount} item(s) " + "and there was not enough regular inventory space to move the whole row safely. Free inventory space; InventorySlots will retry automatically."));
			}
		}

		private static void InvalidateQuickSlotProgressionPanelCache()
		{
			InventoryDefinitions.QuickPanelSlotCacheVersion = -1;
			InventoryDefinitions.QuickPanelSlotCacheUnlockedCount = -1;
			InventoryDefinitions.QuickPanelSlotCache.Clear();
		}

		private static bool IsQuickSlotUnlocked(Player? player, SlotDefinition slot)
		{
			if (slot.Kind == SlotKind.Quick && !((Object)(object)player == (Object)null))
			{
				if (slot.QuickSlotIndex >= 0)
				{
					return slot.QuickSlotIndex < GetUnlockedQuickSlotCount(player);
				}
				return false;
			}
			return true;
		}

		private static bool IsSpecialSlotUnlocked(Player? player, Inventory? inventory, SlotDefinition slot)
		{
			if (slot.Kind != SlotKind.Quick)
			{
				return IsEquipmentSlotUnlocked(player, inventory, slot);
			}
			return IsQuickSlotUnlocked(player, slot);
		}

		private static bool IsEquipmentSlotUnlocked(Player? player, Inventory? inventory, SlotDefinition slot)
		{
			if (slot.Kind == SlotKind.Quick || !IsEquipmentSlotProgressionEnabled() || (Object)(object)player == (Object)null)
			{
				return true;
			}
			if (InventoryContainsAcceptedSlotItem(inventory, slot) || PlayerHasAcceptedEquippedItem(player, slot))
			{
				return true;
			}
			RefreshEquipmentSlotUnlockCache(player);
			if (InventoryDefinitions.EquipmentSlotUnlockCache.TryGetValue(slot.Id, out var value))
			{
				return value;
			}
			bool flag = PlayerKnowsAcceptedSlotItem(player, slot);
			InventoryDefinitions.EquipmentSlotUnlockCache[slot.Id] = flag;
			return flag;
		}

		private static bool IsEquipmentSlotProgressionEnabled()
		{
			if (_equipmentSlotProgressionEnabled != null)
			{
				return _equipmentSlotProgressionEnabled.Value.IsOn();
			}
			return false;
		}

		private static bool InventoryContainsAcceptedSlotItem(Inventory? inventory, SlotDefinition slot)
		{
			if (inventory?.m_inventory == null)
			{
				return false;
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && slot.Accepts(item))
				{
					return true;
				}
			}
			return false;
		}

		private static bool PlayerHasAcceptedEquippedItem(Player player, SlotDefinition slot)
		{
			ItemData val = (ItemData)(slot.Id switch
			{
				"helmet" => ((Humanoid)player).m_helmetItem, 
				"chest" => ((Humanoid)player).m_chestItem, 
				"legs" => ((Humanoid)player).m_legItem, 
				"cape" => ((Humanoid)player).m_shoulderItem, 
				"trinket" => ((Humanoid)player).m_trinketItem, 
				"utility" => ((Humanoid)player).m_utilityItem, 
				_ => null, 
			});
			if (val != null)
			{
				return slot.Accepts(val);
			}
			return false;
		}

		private static void RefreshEquipmentSlotUnlockCache(Player player)
		{
			string equipmentSlotUnlockCacheSignature = GetEquipmentSlotUnlockCacheSignature(player);
			if (!string.Equals(InventoryDefinitions.EquipmentSlotUnlockCacheSignature, equipmentSlotUnlockCacheSignature, StringComparison.Ordinal))
			{
				InventoryDefinitions.EquipmentSlotUnlockCache.Clear();
				InventoryDefinitions.EquipmentSlotUnlockCacheSignature = equipmentSlotUnlockCacheSignature;
				InvalidateVisibleCustomPanelSlots();
			}
		}

		private static string GetVisibleEquipmentSlotUnlockSignature(Player player, Inventory? inventory)
		{
			int num = ObjectDB.instance?.m_items?.Count ?? (-1);
			return $"{GetPlayerId(player)}|{InventoryDefinitions.SlotDefinitionVersion}|{num}|{GetKnownMaterialHash(player)}|{GetAcceptedEquipmentInventoryHash(inventory)}";
		}

		private static string GetEquipmentSlotUnlockCacheSignature(Player player)
		{
			int num = ObjectDB.instance?.m_items?.Count ?? (-1);
			return $"{GetPlayerId(player)}|{InventoryDefinitions.SlotDefinitionVersion}|{num}|{GetKnownMaterialHash(player)}";
		}

		private static int GetKnownMaterialHash(Player player)
		{
			int num = 17;
			if (player.m_knownMaterial != null)
			{
				foreach (string item in player.m_knownMaterial)
				{
					num = num * 31 + StringComparer.Ordinal.GetHashCode(item ?? "");
				}
			}
			return num;
		}

		private static int GetAcceptedEquipmentInventoryHash(Inventory? inventory)
		{
			int num = 17;
			if (inventory?.m_inventory != null)
			{
				foreach (ItemData item in inventory.m_inventory)
				{
					if (item?.m_shared != null)
					{
						num = num * 31 + StringComparer.Ordinal.GetHashCode(item.m_shared.m_name ?? "");
						num = num * 31 + item.m_quality;
						num = num * 31 + item.m_variant;
					}
				}
			}
			return num;
		}

		private static bool PlayerKnowsAcceptedSlotItem(Player player, SlotDefinition slot)
		{
			if (player.m_knownMaterial == null || player.m_knownMaterial.Count == 0)
			{
				return false;
			}
			RefreshItemNameTokens();
			ObjectDB instance = ObjectDB.instance;
			if (IsUnityNull((Object?)(object)instance) || instance.m_items == null)
			{
				return false;
			}
			foreach (GameObject item in instance.m_items)
			{
				if (!IsUnityNull((Object?)(object)item))
				{
					ItemData val = item.GetComponent<ItemDrop>()?.m_itemData;
					if (val?.m_shared != null && slot.Accepts(val) && PlayerKnowsItem(player, item, val))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool PlayerKnowsItem(Player player, GameObject prefab, ItemData item)
		{
			string text = item.m_shared?.m_name ?? "";
			if (!PlayerKnowsMaterial(player, text) && !PlayerKnowsMaterialToken(player, ((Object)prefab).name) && !PlayerKnowsMaterialToken(player, text))
			{
				return PlayerKnowsMaterialToken(player, StripLocalizationToken(text));
			}
			return true;
		}

		private static bool PlayerKnowsMaterialToken(Player player, string token)
		{
			if (ItemNameTokens.TryGetValue(CleanPrefabName(token), out string value))
			{
				return PlayerKnowsMaterial(player, value);
			}
			return false;
		}

		private static bool PlayerKnowsMaterial(Player player, string sharedName)
		{
			if (!string.IsNullOrWhiteSpace(sharedName) && player.m_knownMaterial != null)
			{
				return player.m_knownMaterial.Contains(sharedName);
			}
			return false;
		}

		private static void InvalidateSlotDefinitionCaches()
		{
			InventoryDefinitions.SlotDefinitionVersion++;
			InventoryDefinitions.CustomPanelSlotCacheVersion = -1;
			InventoryDefinitions.QuickPanelSlotCacheVersion = -1;
			InventoryDefinitions.QuickPanelSlotCacheUnlockedCount = -1;
			InventoryDefinitions.QuickSlotDefinitionCacheVersion = -1;
			InventoryDefinitions.CustomPanelSlotCache.Clear();
			InventoryDefinitions.QuickPanelSlotCache.Clear();
			InventoryDefinitions.QuickSlotDefinitionCache.Clear();
			InvalidateVisibleCustomPanelSlots();
		}

		private static void InvalidateVisibleCustomPanelSlots()
		{
			InventoryDefinitions.VisibleCustomPanelSlotCacheVersion = -1;
			InventoryDefinitions.VisibleCustomPanelSlotCacheSignature = "";
		}

		private static bool IsRowUnlocked(Player player, string configuredItems)
		{
			foreach (string item in SplitConfiguredList(configuredItems))
			{
				if (player.m_knownMaterial.Contains(item))
				{
					return true;
				}
				if (ItemNameTokens.TryGetValue(item, out string value) && player.m_knownMaterial.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<string> SplitConfiguredList(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				yield break;
			}
			string[] array = value.Split(new char[3] { ',', ';', '|' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					yield return text;
				}
			}
		}

		private static void UpdatePlayerInventoryPanelBackground(int visibleRegularRows)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)InventoryGui.instance == (Object)null || (Object)(object)InventoryGui.instance.m_player == (Object)null)
			{
				return;
			}
			int num = Mathf.Max(0, visibleRegularRows - 4);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, -1f * ((float)num / 4f - 0.01f * (float)Mathf.Max(num - 1, 0)));
			string[] array = new string[2] { "Bkg", "Darken" };
			foreach (string childName in array)
			{
				RectTransform orRestorePlayerInventoryPanelBackgroundChild = GetOrRestorePlayerInventoryPanelBackgroundChild(InventoryGui.instance.m_player, childName);
				if ((Object)(object)orRestorePlayerInventoryPanelBackgroundChild != (Object)null)
				{
					CapturePlayerInventoryPanelBackgroundSnapshot(childName, orRestorePlayerInventoryPanelBackgroundChild);
					RestorePlayerInventoryPanelBackgroundVisual(childName, orRestorePlayerInventoryPanelBackgroundChild);
					Vector2 val2 = orRestorePlayerInventoryPanelBackgroundChild.anchorMin - val;
					if (((Vector2)(ref val2)).sqrMagnitude > 0.0001f)
					{
						orRestorePlayerInventoryPanelBackgroundChild.anchorMin = val;
					}
				}
			}
		}

		private static RectTransform? GetOrRestorePlayerInventoryPanelBackgroundChild(RectTransform playerPanel, string childName)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Transform)playerPanel).Find(childName);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			if (!PlayerInventoryPanelBackgroundSnapshots.ContainsKey(childName))
			{
				return null;
			}
			val2 = new GameObject(childName, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>();
			((Transform)val2).SetParent((Transform)(object)playerPanel, false);
			((Object)val2).name = childName;
			if (string.Equals(childName, "Darken", StringComparison.Ordinal))
			{
				((Transform)val2).SetAsFirstSibling();
			}
			else
			{
				((Transform)val2).SetSiblingIndex(Mathf.Min(1, ((Transform)playerPanel).childCount - 1));
			}
			return val2;
		}

		private static void CapturePlayerInventoryPanelBackgroundSnapshot(string childName, RectTransform rect)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_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)
			if (!PlayerInventoryPanelBackgroundSnapshots.ContainsKey(childName))
			{
				Image component = ((Component)rect).GetComponent<Image>();
				if (!((Object)(object)component == (Object)null) && !IsUnityNull((Object?)(object)component) && !((Object)(object)component.sprite == (Object)null) && !IsUnityNull((Object?)(object)component.sprite) && ((Component)rect).gameObject.activeSelf && ((Behaviour)component).enabled && !(((Graphic)component).color.a <= 0.05f))
				{
					PlayerInventoryPanelBackgroundSnapshots[childName] = new PlayerInventoryPanelBackgroundSnapshot(((Component)rect).gameObject.activeSelf, ((Behaviour)component).enabled, component.sprite, component.type, component.pixelsPerUnitMultiplier, ((Graphic)component).material, ((Graphic)component).color, rect.anchorMax, rect.pivot, rect.offsetMin, rect.offsetMax, rect.anchoredPosition, rect.sizeDelta, ((Transform)rect).localScale, ((Transform)rect).localRotation);
				}
			}
		}

		private static void RestorePlayerInventoryPanelBackgroundVisual(string childName, RectTransform rect)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_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_00a0: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_00eb: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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_010e: 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_014e: 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_0168: 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_015d: 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_01ea: 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_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			if (PlayerInventoryPanelBackgroundSnapshots.TryGetValue(childName, out var value))
			{
				if (!((Component)rect).gameObject.activeSelf && value.ActiveSelf)
				{
					((Component)rect).gameObject.SetActive(true);
				}
				Vector2 val = rect.anchorMax - value.AnchorMax;
				if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
				{
					rect.anchorMax = value.AnchorMax;
				}
				val = rect.pivot - value.Pivot;
				if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
				{
					rect.pivot = value.Pivot;
				}
				val = rect.offsetMin - value.OffsetMin;
				if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
				{
					rect.offsetMin = value.OffsetMin;
				}
				val = rect.offsetMax - value.OffsetMax;
				if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
				{
					rect.offsetMax = value.OffsetMax;
				}
				val = rect.anchoredPosition - value.AnchoredPosition;
				if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
				{
					rect.anchoredPosition = value.AnchoredPosition;
				}
				val = rect.sizeDelta - value.SizeDelta;
				if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
				{
					rect.sizeDelta = value.SizeDelta;
				}
				if (((Transform)rect).localScale != value.LocalScale)
				{
					((Transform)rect).localScale = value.LocalScale;
				}
				if (((Transform)rect).localRotation != value.LocalRotation)
				{
					((Transform)rect).localRotation = value.LocalRotation;
				}
				Image val2 = ((Component)rect).GetComponent<Image>();
				if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2))
				{
					val2 = ((Component)rect).gameObject.AddComponent<Image>();
				}
				if (((Behaviour)val2).enabled != value.ImageEnabled)
				{
					((Behaviour)val2).enabled = value.ImageEnabled;
				}
				if ((Object)(object)val2.sprite != (Object)(object)value.Sprite)
				{
					val2.sprite = value.Sprite;
				}
				if (val2.type != value.Type)
				{
					val2.type = value.Type;
				}
				if (Math.Abs(val2.pixelsPerUnitMultiplier - value.PixelsPerUnitMultiplier) > 0.0001f)
				{
					val2.pixelsPerUnitMultiplier = value.PixelsPerUnitMultiplier;
				}
				if ((Object)(object)((Graphic)val2).material != (Object)(object)value.Material)
				{
					((Graphic)val2).material = value.Material;
				}
				if (((Graphic)val2).color != value.Color)
				{
					((Graphic)val2).color = value.Color;
				}
				if (((Graphic)val2).raycastTarget)
				{
					((Graphic)val2).raycastTarget = false;
				}
			}
		}

		private static void UpdateSlotBindingLabel(Element element, SlotDefinition? slot, bool hideEquipmentSlotName = false)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			if (IsUnityNull((Object?)(object)element?.m_go))
			{
				return;
			}
			InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
			TMP_Text val = (((Object)(object)inventoryGridElementUiCache != (Object)null && (Object)(object)inventoryGridElementUiCache.BindingText != (Object)null && !IsUnityNull((Object?)(object)inventoryGridElementUiCache.BindingText)) ? inventoryGridElementUiCache.BindingText : null);
			if ((Object)(object)val == (Object)null)
			{
				Transform val2 = element.m_go.transform.Find("binding");
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				val = ((Component)val2).GetComponent<TMP_Text>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((Object)(object)inventoryGridElementUiCache != (Object)null)
				{
					inventoryGridElementUiCache.BindingText = val;
				}
			}
			string text = ((slot == null || hideEquipmentSlotName) ? "" : ((slot.Kind == SlotKind.Quick) ? GetQuickSlotBindingText(slot) : slot.Name));
			string text2 = string.Format("{0}|{1}|{2}|{3}", slot?.Id ?? "", slot?.Kind.ToString() ?? "", hideEquipmentSlotName, text);
			if (!((Object)(object)inventoryGridElementUiCache != (Object)null) || !string.Equals(inventoryGridElementUiCache.BindingSignature, text2, StringComparison.Ordinal))
			{
				ApplyDefaultFontAsset(val);
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchorMin = Vector2.zero;
					component.anchorMax = Vector2.one;
					component.offsetMin = new Vector2(4f, 1f);
					component.offsetMax = new Vector2(-4f, -1f);
					component.anchoredPosition = Vector2.zero;
					component.sizeDelta = Vector2.zero;
				}
				val.enableAutoSizing = true;
				val.fontSizeMin = ((slot != null && slot.Kind == SlotKind.Quick) ? 12f : 7f);
				val.fontSizeMax = ((slot != null && slot.Kind == SlotKind.Quick) ? 16f : 12f);
				val.textWrappingMode = (TextWrappingModes)0;
				val.overflowMode = (TextOverflowModes)1;
				val.alignment = (TextAlignmentOptions)((slot != null && slot.Kind == SlotKind.Quick) ? 257 : 514);
				((Graphic)val).color = new Color(0.68f, 0.88f, 1f, 1f);
				val.text = text;
				((Behaviour)val).enabled = !string.IsNullOrWhiteSpace(text);
				if ((Object)(object)inventoryGridElementUiCache != (Object)null)
				{
					inventoryGridElementUiCache.BindingSignature = text2;
				}
			}
		}

		private static string GetQuickSlotBindingText(SlotDefinition slot)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (slot.QuickSlotIndex < 0)
			{
				return "";
			}
			string first = ((_quickSlotHotkeys != null && slot.QuickSlotIndex < _quickSlotHotkeys.Length) ? _quickSlotHotkeys[slot.QuickSlotIndex].Value.GetCompactDisplayText() : "");
			string second = ((_controllerQuickSlotButtons != null && slot.QuickSlotIndex < _controllerQuickSlotButtons.Length) ? GetControllerHotkeyDisplayText(_controllerQuickSlotButtons[slot.QuickSlotIndex]) : "");
			return JoinShortcutDisplayTexts(first, second);
		}

		private static Vector3 GetGridOrigin(InventoryGrid playerGrid)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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)
			RectTransform val = (RectTransform)((Component)playerGrid).transform;
			if ((Object)(object)val != (Object)null)
			{
				float num = ((playerGrid.m_inventory != null) ? playerGrid.m_inventory.GetWidth() : playerGrid.m_width);
				Rect rect = val.rect;
				return new Vector3(((Rect)(ref rect)).width / 2f - num * playerGrid.m_elementSpace / 2f, 0f, 0f);
			}
			if (playerGrid.m_elements.Count == 0 || IsUnityNull((Object?)(object)playerGrid.m_elements[0]?.m_go))
			{
				return Vector3.zero;
			}
			Transform transform = playerGrid.m_elements[0].m_go.transform;
			if ((Object)(object)transform.parent != (Object)(object)playerGrid.m_gridRoot)
			{
				transform.SetParent((Transform)(object)playerGrid.m_gridRoot, false);
			}
			return transform.localPosition;
		}

		private static RectTransform? EnsureSlotPanel(InventoryGrid playerGrid, string panelName, Dictionary<int, RectTransform> cache)
		{
			//IL_00ee: 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_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)playerGrid).GetInstanceID();
			if (cache.TryGetValue(instanceID, out RectTransform value) && !IsUnityNull((Object?)(object)value))
			{
				if (panelName != "InventorySlots_QuickSlotPanel" && (Object)(object)((Transform)value).parent != (Object)(object)playerGrid.m_gridRoot)
				{
					((Transform)value).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
				}
				((Component)value).gameObject.SetActive(true);
				return value;
			}
			Transform val = ((Transform)playerGrid.m_gridRoot).Find(panelName);
			if ((Object)(object)val == (Object)null && string.Equals(panelName, "InventorySlots_QuickSlotPanel", StringComparison.Ordinal))
			{
				RectTransform quickSlotPanelStableParent = GetQuickSlotPanelStableParent(playerGrid);
				val = (((Object)(object)quickSlotPanelStableParent != (Object)null) ? ((Transform)quickSlotPanelStableParent).Find(panelName) : null);
			}
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = new GameObject(panelName, new Type[4]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(UIInputHandler),
					typeof(InventoryPanelDragMarker)
				}).GetComponent<RectTransform>();
				((Transform)val2).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
			}
			((Object)val2).name = panelName;
			Image obj = ((Component)val2).GetComponent<Image>() ?? ((Component)val2).gameObject.AddComponent<Image>();
			((Graphic)obj).color = Color.clear;
			((Graphic)obj).raycastTarget = true;
			UIInputHandler val3 = ((Component)val2).GetComponent<UIInputHandler>() ?? ((Component)val2).gameObject.AddComponent<UIInputHandler>();
			InventoryPanelDragMarker inventoryPanelDragMarker = ((Component)val2).GetComponent<InventoryPanelDragMarker>() ?? ((Component)val2).gameObject.AddComponent<InventoryPanelDragMarker>();
			inventoryPanelDragMarker.PanelName = panelName;
			if (!inventoryPanelDragMarker.Initialized)
			{
				inventoryPanelDragMarker.Initialized = true;
				val3.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(val3.m_onLeftDown, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					StartInventoryPanelDrag(((Component)handler).GetComponent<InventoryPanelDragMarker>());
				});
				val3.m_onLeftUp = (Action<UIInputHandler>)Delegate.Combine(val3.m_onLeftUp, (Action<UIInputHandler>)delegate
				{
					StopInventoryPanelDrag();
				});
			}
			val2.anchorMin = new Vector2(0.5f, 0.5f);
			val2.anchorMax = new Vector2(0.5f, 0.5f);
			val2.pivot = new Vector2(0f, 1f);
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			((Component)val2).gameObject.SetActive(true);
			cache[instanceID] = val2;
			return val2;
		}

		private static RectTransform? DisableSlotPanel(InventoryGrid playerGrid, string panelName, Dictionary<int, RectTransform> cache)
		{
			int instanceID = ((Object)playerGrid).GetInstanceID();
			if (cache.TryGetValue(instanceID, out RectTransform value) && !IsUnityNull((Object?)(object)value))
			{
				if ((Object)(object)InventoryPanels.DraggedInventoryPanel == (Object)(object)value)
				{
					StopInventoryPanelDrag();
				}
				((Component)value).gameObject.SetActive(false);
				return null;
			}
			Transform val = (((Object)(object)playerGrid.m_gridRoot != (Object)null) ? ((Transform)playerGrid.m_gridRoot).Find(panelName) : null);
			if ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)InventoryPanels.DraggedInventoryPanel == (Object)(object)((Component)val).GetComponent<RectTransform>())
				{
					StopInventoryPanelDrag();
				}
				((Component)val).gameObject.SetActive(false);
			}
			return null;
		}

		private static void StartInventoryPanelDrag(InventoryPanelDragMarker? marker)
		{
			//IL_0065: 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_0084: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null || !InventoryGui.IsVisible())
			{
				return;
			}
			bool flag = marker.PanelName == "InventorySlots_QuickSlotPanel";
			bool flag2 = marker.PanelName == "InventorySlots_CustomSlotPanel";
			if (flag || flag2)
			{
				RectTransform component = ((Component)marker).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null) && TryGetInventoryPanelDragLocalMousePosition(out var localMousePosition))
				{
					InventoryPanels.DraggedInventoryPanel = component;
					InventoryPanels.InventoryPanelDragStartLocalMouse = localMousePosition;
					InventoryPanels.InventoryPanelDragStartOffset = (flag ? InventoryPanels.QuickSlotsPanelRuntimeOffset : InventoryPanels.EquipmentSlotsPanelRuntimeOffset);
					InventoryPanels.DraggingQuickSlotsPanelOffset = flag;
					InventoryPanels.DraggingEquipmentSlotsPanelOffset = flag2;
				}
			}
		}

		private static void StopInventoryPanelDrag()
		{
			CommitDraggedInventoryPanelOffset();
			InventoryPanels.DraggedInventoryPanel = null;
			InventoryPanels.DraggingQuickSlotsPanelOffset = false;
			InventoryPanels.DraggingEquipmentSlotsPanelOffset = false;
		}

		private static void LoadInventoryPanelPositionsFromClientState()
		{
			//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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			EnsureClientStateLoaded();
			InventoryPanels.EquipmentSlotsPanelRuntimeOffset = GetClientPanelPosition(InventoryClient.ClientState.Inventory.EquipmentSlotsPanelPosition, EquipmentSlotsPanelFixedOffset);
			InventoryPanels.QuickSlotsPanelRuntimeOffset = GetClientPanelPosition(InventoryClient.ClientState.Inventory.QuickSlotsPanelPosition, QuickSlotsPanelFixedOffset);
			InventoryPanels.QuickSlotHudAnchoredPosition = Vector2.op_Implicit(GetClientPanelPosition(InventoryClient.ClientState.Inventory.QuickSlotsHudPosition, QuickSlotsHudFallbackPosition));
			InventoryPanels.QuickSlotHudElementSpace = Mathf.Max(1f, InventoryClient.ClientState.Inventory.QuickSlotsHudElementSpace);
			InventoryPanels.QuickSlotHudAnchorValid = true;
		}

		private static Vector2 GetClientPanelPosition(InventorySlotsClientPanelPosition? position, Vector2 fallback)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (position != null)
			{
				return new Vector2(position.X, position.Y);
			}
			return fallback;
		}

		private static void CommitDraggedInventoryPanelOffset()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (InventoryPanels.DraggingQuickSlotsPanelOffset)
			{
				SaveInventoryPanelPosition(isQuickSlotsPanel: true, InventoryPanels.QuickSlotsPanelRuntimeOffset);
				if (_quickSlotHudFollowsPanel.Value == Toggle.On)
				{
					SaveQuickSlotHudAnchor();
				}
			}
			else if (InventoryPanels.DraggingEquipmentSlotsPanelOffset)
			{
				SaveInventoryPanelPosition(isQuickSlotsPanel: false, InventoryPanels.EquipmentSlotsPanelRuntimeOffset);
			}
		}

		private static void SaveInventoryPanelPosition(bool isQuickSlotsPanel, Vector2 value)
		{
			//IL_0039: 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_0073: 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)
			EnsureClientStateLoaded();
			InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition = (isQuickSlotsPanel ? InventoryClient.ClientState.Inventory.QuickSlotsPanelPosition : InventoryClient.ClientState.Inventory.EquipmentSlotsPanelPosition);
			if (!(Mathf.Abs(inventorySlotsClientPanelPosition.X - value.x) <= 0.01f) || !(Mathf.Abs(inventorySlotsClientPanelPosition.Y - value.y) <= 0.01f))
			{
				inventorySlotsClientPanelPosition.X = value.x;
				inventorySlotsClientPanelPosition.Y = value.y;
				SaveClientState();
			}
		}

		private static void SaveQuickSlotHudAnchor()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_00a9: 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)
			if (InventoryPanels.QuickSlotHudAnchorValid)
			{
				EnsureClientStateLoaded();
				InventorySlotsClientPanelPosition quickSlotsHudPosition = InventoryClient.ClientState.Inventory.QuickSlotsHudPosition;
				Vector3 quickSlotHudAnchoredPosition = InventoryPanels.QuickSlotHudAnchoredPosition;
				float num = Mathf.Max(1f, InventoryPanels.QuickSlotHudElementSpace);
				if (!(Mathf.Abs(quickSlotsHudPosition.X - quickSlotHudAnchoredPosition.x) <= 0.01f) || !(Mathf.Abs(quickSlotsHudPosition.Y - quickSlotHudAnchoredPosition.y) <= 0.01f) || !(Mathf.Abs(InventoryClient.ClientState.Inventory.QuickSlotsHudElementSpace - num) <= 0.01f))
				{
					quickSlotsHudPosition.X = quickSlotHudAnchoredPosition.x;
					quickSlotsHudPosition.Y = quickSlotHudAnchoredPosition.y;
					InventoryClient.ClientState.Inventory.QuickSlotsHudElementSpace = num;
					SaveClientState();
				}
			}
		}

		private static bool UpdateInventoryPanelDragging()
		{
			//IL_0061: 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_0071: 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_0099: 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_00cf: 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)
			if ((Object)(object)InventoryPanels.DraggedInventoryPanel == (Object)null || (!InventoryPanels.DraggingQuickSlotsPanelOffset && !InventoryPanels.DraggingEquipmentSlotsPanelOffset))
			{
				return false;
			}
			if (!Input.GetMouseButton(0) || !((Component)InventoryPanels.DraggedInventoryPanel).gameObject.activeInHierarchy)
			{
				StopInventoryPanelDrag();
				return false;
			}
			if (!TryGetInventoryPanelDragLocalMousePosition(out var localMousePosition))
			{
				StopInventoryPanelDrag();
				return false;
			}
			Vector2 val = localMousePosition - InventoryPanels.InventoryPanelDragStartLocalMouse;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(InventoryPanels.InventoryPanelDragStartOffset.x + val.x, InventoryPanels.InventoryPanelDragStartOffset.y + val.y);
			if (InventoryPanels.DraggingQuickSlotsPanelOffset)
			{
				InventoryPanels.QuickSlotsPanelRuntimeOffset = val2;
				return true;
			}
			if (InventoryPanels.DraggingEquipmentSlotsPanelOffset)
			{
				InventoryPanels.EquipmentSlotsPanelRuntimeOffset = val2;
				return true;
			}
			return false;
		}

		private static bool TryUpdateDraggedInventoryPanelPositionOnly(InventoryGrid playerGrid, Vector3 origin, int inventoryWidth)
		{
			//IL_005a: 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_0067: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_011d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerGrid == (Object)null || (Object)(object)playerGrid.m_gridRoot == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)playerGrid).GetInstanceID();
			InventoryPanels.CustomSlotPanels.TryGetValue(instanceID, out RectTransform value);
			InventoryPanels.QuickSlotPanels.TryGetValue(instanceID, out RectTransform value2);
			if (IsUnityNull((Object?)(object)value))
			{
				value = null;
			}
			if (IsUnityNull((Object?)(object)value2))
			{
				value2 = null;
			}
			Vector3 sidePanelBasePosition = GetSidePanelBasePosition(origin, inventoryWidth, playerGrid.m_elementSpace);
			bool flag = false;
			if ((Object)(object)value != (Object)null)
			{
				((Transform)value).localPosition = sidePanelBasePosition + Vector2.op_Implicit(InventoryPanels.EquipmentSlotsPanelRuntimeOffset);
				flag |= InventoryPanels.DraggingEquipmentSlotsPanelOffset;
			}
			if ((Object)(object)value2 != (Object)null)
			{
				bool flag2 = (Object)(object)value != (Object)null && ((Component)value).gameObject.activeSelf;
				float num = (0f - ((flag2 ? 3f : 0f) + (flag2 ? 0.35f : 0f))) * playerGrid.m_elementSpace;
				Vector3 targetGridLocalPosition = sidePanelBasePosition + new Vector3(0f, num, 0f) + Vector2.op_Implicit(InventoryPanels.QuickSlotsPanelRuntimeOffset);
				PositionQuickSlotPanel(playerGrid, value2, targetGridLocalPosition, playerGrid.m_elementSpace);
				flag |= InventoryPanels.DraggingQuickSlotsPanelOffset;
			}
			return flag;
		}

		private static bool TryGetInventoryPanelDragLocalMousePosition(out Vector2 localMousePosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			localMousePosition = Vector2.zero;
			RectTransform val = (((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)InventoryGui.instance.m_playerGrid != (Object)null) ? InventoryGui.instance.m_playerGrid.m_gridRoot : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Canvas componentInParent = ((Component)val).GetComponentInParent<Canvas>();
			Camera val2 = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
			return RectTransformUtility.ScreenPointToLocalPointInRectangle(val, Vector2.op_Implicit(Input.mousePosition), val2, ref localMousePosition);
		}

		private static void UpdateVanillaPanelBackground(RectTransform panel, float width, float height)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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)
			if ((Object)(object)panel == (Object)null || IsVanillaPlayerInventoryPanel(panel))
			{
				return;
			}
			Rect rect = panel.rect;
			if (Math.Abs(((Rect)(ref rect)).width - width) > 0.01f && Math.Abs(panel.sizeDelta.x - width) > 0.01f)
			{
				panel.SetSizeWithCurrentAnchors((Axis)0, width);
			}
			rect = panel.rect;
			if (Math.Abs(((Rect)(ref rect)).height - height) > 0.01f && Math.Abs(panel.sizeDelta.y - height) > 0.01f)
			{
				panel.SetSizeWithCurrentAnchors((Axis)1, height);
			}
			SetPanelBackgroundVisible(panel, visible: true);
			RectTransform val = EnsurePanelBackgroundChild(panel, "Bkg", new Color(0f, 0f, 0f, 0.45f));
			RectTransform val2 = EnsurePanelBackgroundChild(panel, "Darken", new Color(0f, 0f, 0f, 0.2f));
			if (!IsVanillaPlayerInventoryPanelBackground(val) && !IsVanillaPlayerInventoryPanelBackground(val2))
			{
				ConfigureBackgroundRect(val, width, height);
				ConfigureBackgroundRect(val2, width, height);
				if (((Transform)val2).GetSiblingIndex() != 0)
				{
					((Transform)val2).SetAsFirstSibling();
				}
				int num = Mathf.Min(1, ((Transform)val).parent.childCount - 1);
				if (((Transform)val).GetSiblingIndex() != num)
				{
					((Transform)val).SetSiblingIndex(num);
				}
				if (string.Equals(((Object)panel).name, "InventorySlots_QuickSlotPanel", StringComparison.Ordinal) || string.Equals(((Object)panel).name, "InventorySlots_CustomSlotPanel", StringComparison.Ordinal))
				{
					ConfigureSlotPanelDragBorder(panel, width, height, ((Object)panel).name);
				}
			}
		}

		private static void SetPanelBackgroundVisible(RectTransform panel, bool visible)
		{
			if ((Object)(object)panel == (Object)null)
			{
				return;
			}
			string[] array = new string[3] { "Bkg", "Darken", "InventorySlots_DragBorder" };
			foreach (string text in array)
			{
				Transform val = ((Transform)panel).Find(text);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(visible);
				}
			}
		}

		private static RectTransform EnsurePanelBackgroundChild(RectTransform panel, string childName, Color fallbackColor)
		{
			//IL_00b1: 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)
			Transform val = ((Transform)panel).Find(childName);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				if (!IsVanillaPlayerInventoryPanelBackground(val2))
				{
					return val2;
				}
				val2 = null;
			}
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			Transform val3 = (((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)InventoryGui.instance.m_player != (Object)null) ? ((Transform)InventoryGui.instance.m_player).Find(childName) : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val2 = ((Component)Object.Instantiate<Transform>(val3, (Transform)(object)panel, false)).GetComponent<RectTransform>();
				((Object)val2).name = childName;
				if ((Object)(object)((Transform)val2).parent != (Object)(object)panel || IsVanillaPlayerInventoryPanelBackground(val2))
				{
					val2 = CreateFallbackPanelBackgroundChild(panel, childName, fallbackColor);
				}
			}
			else
			{
				val2 = CreateFallbackPanelBackgroundChild(panel, childName, fallbackColor);
			}
			Graphic[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].raycastTarget = false;
			}
			return val2;
		}

		private static RectTransform CreateFallbackPanelBackgroundChild(RectTransform panel, string childName, Color fallbackColor)
		{
			//IL_0021: 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)
			RectTransform component = new GameObject(childName, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)panel, false);
			((Graphic)((Component)component).GetComponent<Image>()).color = fallbackColor;
			return component;
		}

		private static void ConfigureSlotPanelDragBorder(RectTransform panel, float width, float height, string panelName)
		{
			RectTransform obj = EnsureSlotPanelDragBorder(panel, panelName);
			ConfigureBackgroundRect(obj, width, height);
			((Transform)obj).SetSiblingIndex(Mathf.Min(2, ((Transform)panel).childCount - 1));
			((Component)obj).gameObject.SetActive(true);
		}

		private static RectTransform EnsureSlotPanelDragBorder(RectTransform panel, string panelName)
		{
			//IL_0067: 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)
			Transform val = ((Transform)panel).Find("InventorySlots_DragBorder");
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = new GameObject("InventorySlots_DragBorder", new Type[4]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(UIInputHandler),
					typeof(InventoryPanelDragMarker)
				}).GetComponent<RectTransform>();
				((Transform)val2).SetParent((Transform)(object)panel, false);
			}
			Image obj = ((Component)val2).GetComponent<Image>() ?? ((Component)val2).gameObject.AddComponent<Image>();
			obj.sprite = GetSolidUiSprite();
			((Graphic)obj).color = Color.clear;
			((Graphic)obj).raycastTarget = true;
			InventoryPanelDragMarker inventoryPanelDragMarker = ((Component)val2).GetComponent<InventoryPanelDragMarker>() ?? ((Component)val2).gameObject.AddComponent<InventoryPanelDragMarker>();
			inventoryPanelDragMarker.PanelName = panelName;
			UIInputHandler val3 = ((Component)val2).GetComponent<UIInputHandler>() ?? ((Component)val2).gameObject.AddComponent<UIInputHandler>();
			if (!inventoryPanelDragMarker.Initialized)
			{
				inventoryPanelDragMarker.Initialized = true;
				val3.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(val3.m_onLeftDown, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					StartInventoryPanelDrag(((Component)handler).GetComponent<InventoryPanelDragMarker>());
				});
				val3.m_onLeftUp = (Action<UIInputHandler>)Delegate.Combine(val3.m_onLeftUp, (Action<UIInputHandler>)delegate
				{
					StopInventoryPanelDrag();
				});
			}
			return val2;
		}

		private static void ConfigureBackgroundRect(RectTransform rect, float width, float height)
		{
			//IL_0014: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!IsVanillaPlayerInventoryPanelBackground(rect))
			{
				SetRectLayout(rect, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0.5f, 0.5f), new Vector2(width / 2f, (0f - height) / 2f), new Vector2(width + 32f, height + 32f));
			}
		}

		private static bool IsVanillaPlayerInventoryPanel(RectTransform rect)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance?.m_player != (Object)null && !IsUnityNull((Object?)(object)instance.m_player))
			{
				return (Object)(object)rect == (Object)(object)instance.m_player;
			}
			return false;
		}

		private static bool IsVanillaPlayerInventoryPanelBackground(RectTransform? rect)
		{
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance?.m_player != (Object)null && !IsUnityNull((Object?)(object)instance.m_player) && (Object)(object)((Transform)rect).parent == (Object)(object)instance.m_player)
			{
				if (!string.Equals(((Object)rect).name, "Bkg", StringComparison.Ordinal))
				{
					return string.Equals(((Object)rect).name, "Darken", StringComparison.Ordinal);
				}
				return true;
			}
			return false;
		}

		private static bool BeginInventoryLoadPreservation(Inventory? inventory)
		{
			if (inventory == null)
			{
				return false;
			}
			InventorySafety.LoadPreservationInventoryDepth.TryGetValue(inventory, out var value);
			InventorySafety.LoadPreservationInventoryDepth[inventory] = value + 1;
			return true;
		}

		private static void EndInventoryLoadPreservation(Inventory? inventory)
		{
			if (inventory != null && InventorySafety.LoadPreservationInventoryDepth.TryGetValue(inventory, out var value))
			{
				if (value <= 1)
				{
					InventorySafety.LoadPreservationInventoryDepth.Remove(inventory);
				}
				else
				{
					InventorySafety.LoadPreservationInventoryDepth[inventory] = value - 1;
				}
			}
		}

		private static bool IsInventoryLoadPreserving(Inventory? inventory)
		{
			if (inventory != null)
			{
				return InventorySafety.LoadPreservationInventoryDepth.ContainsKey(inventory);
			}
			return false;
		}

		private static void PushInventoryAddItemDataStackLookupItem(ItemData item)
		{
			InventorySafety.InventoryAddItemDataStackLookupItems.Push(item);
		}

		private static void PopInventoryAddItemDataStackLookupItem()
		{
			if (InventorySafety.InventoryAddItemDataStackLookupItems.Count > 0)
			{
				InventorySafety.InventoryAddItemDataStackLookupItems.Pop();
			}
		}

		private static ItemData? GetCurrentInventoryAddItemDataStackLookupItem()
		{
			if (InventorySafety.InventoryAddItemDataStackLookupItems.Count <= 0)
			{
				return null;
			}
			return InventorySafety.InventoryAddItemDataStackLookupItems.Peek();
		}

		private static float GetAdvancedConfigFloat(ConfigEntry<float>? config, float fallback)
		{
			return config?.Value ?? fallback;
		}

		private static void UpdatePlayerStatPanels(RectTransform equipmentPanel, int equipmentColumns, float elementSpace)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)equipmentPanel == (Object)null)
			{
				RestorePlayerStatPanels();
				return;
			}
			if ((Object)(object)instance.m_armor == (Object)null || (Object)(object)instance.m_weight == (Object)null || !((Component)equipmentPanel).gameObject.activeInHierarchy)
			{
				RestorePlayerStatPanels();
				return;
			}
			RectTransform val = EnsurePlayerStatPanelHost(equipmentPanel);
			float num = (float)Mathf.Max(1, equipmentColumns) * elementSpace;
			((Transform)val).localPosition = new Vector3(num + 16f + -8f, -16f, 0f) + Vector2.op_Implicit(PlayerStatPanelsFixedOffset);
			val.SetSizeWithCurrentAnchors((Axis)0, elementSpace * 1.35f);
			val.SetSizeWithCurrentAnchors((Axis)1, elementSpace * 1.6f);
			((Component)val).gameObject.SetActive(true);
			((Transform)val).SetAsFirstSibling();
			MovePlayerStatPanelGroup(instance, val);
			LayoutPlayerStatPanels(elementSpace);
			((Transform)val).SetAsFirstSibling();
		}

		private static RectTransform EnsurePlayerStatPanelHost(RectTransform equipmentPanel)
		{
			//IL_00d0: 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_010c: 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_0134: 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)
			if ((Object)(object)InventoryPanels.PlayerStatPanelHost != (Object)null && !IsUnityNull((Object?)(object)InventoryPanels.PlayerStatPanelHost) && (Object)(object)((Transform)InventoryPanels.PlayerStatPanelHost).parent == (Object)(object)equipmentPanel)
			{
				return InventoryPanels.PlayerStatPanelHost;
			}
			Transform val = ((Transform)equipmentPanel).Find("InventorySlots_PlayerStatPanelHost");
			InventoryPanels.PlayerStatPanelHost = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)InventoryPanels.PlayerStatPanelHost == (Object)null)
			{
				InventoryPanels.PlayerStatPanelHost = new GameObject("InventorySlots_PlayerStatPanelHost", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			}
			((Transform)InventoryPanels.PlayerStatPanelHost).SetParent((Transform)(object)equipmentPanel, false);
			InventoryPanels.PlayerStatPanelHost.anchorMin = new Vector2(0f, 1f);
			InventoryPanels.PlayerStatPanelHost.anchorMax = new Vector2(0f, 1f);
			InventoryPanels.PlayerStatPanelHost.pivot = new Vector2(0f, 1f);
			((Transform)InventoryPanels.PlayerStatPanelHost).localScale = Vector3.one;
			((Transform)InventoryPanels.PlayerStatPanelHost).localRotation = Quaternion.identity;
			return InventoryPanels.PlayerStatPanelHost;
		}

		private static void MovePlayerStatPanelGroup(InventoryGui gui, RectTransform host)
		{
			RectTransform playerStatPanelRoot = GetPlayerStatPanelRoot(gui, gui.m_armor);
			RectTransform playerStatPanelRoot2 = GetPlayerStatPanelRoot(gui, gui.m_weight);
			if ((Object)(object)playerStatPanelRoot == (Object)null || (Object)(object)playerStatPanelRoot2 == (Object)null)
			{
				return;
			}
			if ((Object)(object)((Transform)playerStatPanelRoot).parent != (Object)null && (Object)(object)((Transform)playerStatPanelRoot).parent == (Object)(object)((Transform)playerStatPanelRoot2).parent)
			{
				Transform parent = ((Transform)playerStatPanelRoot).parent;
				int siblingIndex = ((Transform)playerStatPanelRoot).GetSiblingIndex();
				int siblingIndex2 = ((Transform)playerStatPanelRoot2).GetSiblingIndex();
				int num = Mathf.Min(siblingIndex, siblingIndex2);
				int num2 = Mathf.Max(siblingIndex, siblingIndex2);
				List<RectTransform> list = new List<RectTransform>();
				for (int i = num; i <= num2 && i < parent.childCount; i++)
				{
					Transform child = parent.GetChild(i);
					RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (val != null && ShouldMovePlayerStatSibling(gui, val))
					{
						list.Add(val);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					PlayerStatPanelKind kind = ((!((Object)(object)list[j] == (Object)(object)playerStatPanelRoot)) ? (((Object)(object)list[j] == (Object)(object)playerStatPanelRoot2) ? PlayerStatPanelKind.Weight : ((!IsSynergyStatPanel(list[j])) ? PlayerStatPanelKind.Between : PlayerStatPanelKind.Synergy)) : PlayerStatPanelKind.Armor);
					MovePlayerStatPanelRoot(list[j], kind, host, j);
				}
				MoveNamedPlayerStatPanelExtras(gui, host, list.Count);
			}
			else
			{
				MovePlayerStatPanelRoot(playerStatPanelRoot, PlayerStatPanelKind.Armor, host, 0);
				MovePlayerStatPanelRoot(playerStatPanelRoot2, PlayerStatPanelKind.Weight, host, 1);
				MoveNamedPlayerStatPanelExtras(gui, host, 2);
			}
		}

		private static void MoveNamedPlayerStatPanelExtras(InventoryGui gui, RectTransform host, int nextSortOrder)
		{
			Transform player = (Transform)(object)gui.m_player;
			string[] playerStatPanelExtraNames = PlayerStatPanelExtraNames;
			foreach (string text in playerStatPanelExtraNames)
			{
				Transform obj = player.Find(text);
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val != null && ShouldMovePlayerStatSibling(gui, val))
				{
					MovePlayerStatPanelRoot(val, (!IsSynergyStatPanel(val)) ? PlayerStatPanelKind.Between : PlayerStatPanelKind.Synergy, host, nextSortOrder++);
				}
			}
			int num = Math.Max(nextSortOrder, 100);
			playerStatPanelExtraNames = QuickStackStoreMiniButtonNames;
			foreach (string text2 in playerStatPanelExtraNames)
			{
				Transform obj2 = player.Find(text2);
				RectTransform val2 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				if (val2 != null)
				{
					MovePlayerStatPanelRoot(val2, PlayerStatPanelKind.QuickStackMiniButton, host, num++);
				}
			}
		}

		private static void MovePlayerStatPanelRoot(RectTransform root, PlayerStatPanelKind kind, RectTransform host, int sortOrder)
		{
			MovedPlayerStatPanel movedPlayerStatPanel = InventoryPanels.MovedPlayerStatPanels.FirstOrDefault((MovedPlayerStatPanel panel) => (Object)(object)panel.Rect == (Object)(object)root && !IsUnityNull((Object?)(object)panel.Rect));
			if (movedPlayerStatPanel == null)
			{
				movedPlayerStatPanel = new MovedPlayerStatPanel(kind, root, sortOrder);
				InventoryPanels.MovedPlayerStatPanels.Add(movedPlayerStatPanel);
			}
			else
			{
				movedPlayerStatPanel.Kind = kind;
				movedPlayerStatPanel.SortOrder = sortOrder;
			}
			((Transform)root).SetParent((Transform)(object)host, false);
		}

		private static bool ShouldMovePlayerStatSibling(InventoryGui gui, RectTransform sibling)
		{
			if ((Object)(object)sibling == (Object)null || (Object)(object)sibling == (Object)(object)InventoryPanels.PlayerStatPanelHost || ((Object)sibling).name.StartsWith("InventorySlots_", StringComparison.Ordinal) || string.Equals(((Object)sibling).name, "CoinPocketUI", StringComparison.Ordinal))
			{
				return false;
			}
			if ((Object)(object)gui.m_pvp != (Object)null && ((Object)(object)((Component)sibling).transform == (Object)(object)((Component)gui.m_pvp).transform || ((Component)gui.m_pvp).transform.IsChildOf((Transform)(object)sibling)))
			{
				return false;
			}
			return true;
		}

		private static bool IsSynergyStatPanel(RectTransform rect)
		{
			if ((Object)(object)rect != (Object)null)
			{
				return ((Object)rect).name.IndexOf("Synergy", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static RectTransform? GetPlayerStatPanelRoot(InventoryGui gui, TMP_Text text)
		{
			if ((Object)(object)text == (Object)null)
			{
				return null;
			}
			MovedPlayerStatPanel movedPlayerStatPanel = InventoryPanels.MovedPlayerStatPanels.FirstOrDefault((MovedPlayerStatPanel panel) => !IsUnityNull((Object?)(object)panel.Rect) && text.transform.IsChildOf((Transform)(object)panel.Rect));
			if (movedPlayerStatPanel != null)
			{
				return movedPlayerStatPanel.Rect;
			}
			RectTransform result = ((Component)text).GetComponent<RectTransform>();
			Transform val = text.transform;
			while ((Object)(object)val.parent != (Object)null && (Object)(object)val.parent != (Object)(object)gui.m_infoPanel && (Object)(object)val.parent != (Object)(object)gui.m_player)
			{
				val = val.parent;
				RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if (val2 != null)
				{
					result = val2;
				}
			}
			return result;
		}

		private static void LayoutPlayerStatPanels(float elementSpace)
		{
			//IL_0088: 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_00bc: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			foreach (MovedPlayerStatPanel item in from panel in InventoryPanels.MovedPlayerStatPanels
				orderby panel.SortOrder, panel.Kind
				select panel)
			{
				if (!IsUnityNull((Object?)(object)item.Rect))
				{
					item.Rect.anchorMin = new Vector2(0f, 1f);
					item.Rect.anchorMax = new Vector2(0f, 1f);
					item.Rect.pivot = new Vector2(0f, 1f);
					((Transform)item.Rect).localScale = Vector3.one;
					((Transform)item.Rect).localRotation = Quaternion.identity;
					if (item.Kind == PlayerStatPanelKind.QuickStackMiniButton)
					{
						((Transform)item.Rect).localPosition = new Vector3((float)num2 * 40f, (float)(-num) * elementSpace * 0.72f, 0f);
						num2++;
					}
					else
					{
						((Transform)item.Rect).localPosition = new Vector3(0f, (float)(-num) * elementSpace * 0.72f, 0f) + GetPlayerStatPanelOffset(item.Kind);
						num++;
					}
					((Transform)item.Rect).SetAsLastSibling();
				}
			}
		}

		private static Vector3 GetPlayerStatPanelOffset(PlayerStatPanelKind kind)
		{
			//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_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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002f: 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)
			return (Vector3)(kind switch
			{
				PlayerStatPanelKind.Armor => Vector2.op_Implicit(ArmorPanelFixedOffset), 
				PlayerStatPanelKind.Weight => Vector2.op_Implicit(WeightPanelFixedOffset), 
				PlayerStatPanelKind.Synergy => Vector2.op_Implicit(SynergyPanelFixedOffset), 
				_ => Vector3.zero, 
			});
		}

		internal static void RestorePlayerStatPanels()
		{
			for (int num = InventoryPanels.MovedPlayerStatPanels.Count - 1; num >= 0; num--)
			{
				InventoryPanels.MovedPlayerStatPanels[num].Restore();
			}
			InventoryPanels.MovedPlayerStatPanels.Clear();
			if ((Object)(object)InventoryPanels.PlayerStatPanelHost != (Object)null && !IsUnityNull((Object?)(object)InventoryPanels.PlayerStatPanelHost))
			{
				((Component)InventoryPanels.PlayerStatPanelHost).gameObject.SetActive(false);
			}
		}

		private static void UpdateInventoryTrashPanel(InventoryGui gui, InventoryGrid playerGrid, Player player, Vector3 gridOrigin, int viewportRows)
		{
			//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_00be: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			ConfigEntry<Toggle> enableInventoryTrashPanel = _enableInventoryTrashPanel;
			if (enableInventoryTrashPanel == null || enableInventoryTrashPanel.Value != Toggle.On || (Object)(object)gui == (Object)null || (Object)(object)playerGrid == (Object)null || (Object)(object)playerGrid.m_gridRoot == (Object)null || (Object)(object)gui.m_takeAllButton == (Object)null || !InventoryGui.IsVisible())
			{
				SetActionPanelActive(_inventoryTrashPanel, active: false);
				return;
			}
			_inventoryTrashPanel = EnsureActionPanel(playerGrid.m_gridRoot, "InventorySlots_TrashPanel", _inventoryTrashPanel);
			if (!((Object)(object)_inventoryTrashPanel == (Object)null))
			{
				float num = Mathf.Max(1f, playerGrid.m_elementSpace);
				float num2 = Mathf.Clamp(num * 0.72f, 42f, 58f);
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(num2, num2);
				Vector2 val2 = _inventoryTrashPanel.sizeDelta - val;
				if (((Vector2)(ref val2)).sqrMagnitude > 0.0001f)
				{
					_inventoryTrashPanel.sizeDelta = val;
				}
				if (((Transform)_inventoryTrashPanel).localScale != Vector3.one)
				{
					((Transform)_inventoryTrashPanel).localScale = Vector3.one;
				}
				if (((Transform)_inventoryTrashPanel).localRotation != Quaternion.identity)
				{
					((Transform)_inventoryTrashPanel).localRotation = Quaternion.identity;
				}
				Vector3 val3 = gridOrigin + new Vector3(7f * num + (num - num2) * 0.5f, (float)(-Mathf.Max(1, viewportRows)) * num - 8f, 0f);
				Vector3 val4 = ((Transform)_inventoryTrashPanel).localPosition - val3;
				if (((Vector3)(ref val4)).sqrMagnitude > 0.0001f)
				{
					((Transform)_inventoryTrashPanel).localPosition = val3;
				}
				DisableActionPanelChildren(_inventoryTrashPanel);
				RectTransform? inventoryTrashPanel = _inventoryTrashPanel;
				Button takeAllButton = gui.m_takeAllButton;
				object obj = <>O.<19>__TryClickInventoryTrashPanel;
				if (obj == null)
				{
					UnityAction val5 = TryClickInventoryTrashPanel;
					<>O.<19>__TryClickInventoryTrashPanel = val5;
					obj = (object)val5;
				}
				Button val6 = EnsureActionButton(inventoryTrashPanel, takeAllButton, "InventorySlots_TrashButton", "", (UnityAction)obj);
				RectTransform val7 = LayoutActionButton(val6, 0, num2, num2, 0f);
				if ((Object)(object)val6 != (Object)null && (Object)(object)val7 != (Object)null)
				{
					ConfigureInventoryTrashButton(val6, num2);
					bool canTrash = CanStartInventoryTrash(gui, player, showMessage: false);
					SetButtonInteractable(val6, HasHeldTrashCandidate(gui));
					SetInventoryTrashButtonVisual(val6, canTrash);
				}
				SetActionPanelActive(_inventoryTrashPanel, active: true);
				if ((Object)(object)((Transform)_inventoryTrashPanel).parent != (Object)null && ((Transform)_inventoryTrashPanel).GetSiblingIndex() != ((Transform)_inventoryTrashPanel).parent.childCount - 1)
				{
					((Transform)_inventoryTrashPanel).SetAsLastSibling();
				}
			}
		}

		private static void OnInventoryTrashPanelConfigChanged()
		{
			ConfigEntry<Toggle> enableInventoryTrashPanel = _enableInventoryTrashPanel;
			if (enableInventoryTrashPanel == null || enableInventoryTrashPanel.Value != Toggle.On)
			{
				SetActionPanelActive(_inventoryTrashPanel, active: false);
				CloseInventoryTrashConfirmDialog();
			}
		}

		private static bool HasHeldTrashCandidate(InventoryGui gui)
		{
			if ((Object)(object)gui != (Object)null && (Object)(object)gui.m_dragGo != (Object)null && gui.m_dragItem != null)
			{
				return gui.m_dragInventory != null;
			}
			return false;
		}

		private static void ConfigureInventoryTrashButton(Button button, float buttonSize)
		{
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			InventoryTrashButtonMarker inventoryTrashButtonMarker = ((Component)button).GetComponent<InventoryTrashButtonMarker>() ?? ((Component)button).gameObject.AddComponent<InventoryTrashButtonMarker>();
			if (!inventoryTrashButtonMarker.TextSuppressed)
			{
				TMP_Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
				foreach (TMP_Text obj in componentsInChildren)
				{
					obj.text = "";
					((Behaviour)obj).enabled = false;
				}
				Text[] componentsInChildren2 = ((Component)button).GetComponentsInChildren<Text>(true);
				foreach (Text obj2 in componentsInChildren2)
				{
					obj2.text = "";
					((Behaviour)obj2).enabled = false;
				}
				inventoryTrashButtonMarker.TextSuppressed = true;
			}
			if ((Object)(object)inventoryTrashButtonMarker.Icon == (Object)null || IsUnityNull((Object?)(object)inventoryTrashButtonMarker.Icon))
			{
				Transform val = ((Component)button).transform.Find("InventorySlots_TrashIcon");
				inventoryTrashButtonMarker.Icon = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Image>() : null);
				if ((Object)(object)inventoryTrashButtonMarker.Icon == (Object)null || IsUnityNull((Object?)(object)inventoryTrashButtonMarker.Icon))
				{
					GameObject val2 = new GameObject("InventorySlots_TrashIcon", new Type[3]
					{
						typeof(RectTransform),
						typeof(CanvasRenderer),
						typeof(Image)
					});
					((Transform)(RectTransform)val2.transform).SetParent(((Component)button).transform, false);
					inventoryTrashButtonMarker.Icon = val2.GetComponent<Image>();
				}
			}
			Sprite inventoryTrashIconSprite = GetInventoryTrashIconSprite();
			float num = Mathf.Max(18f, buttonSize * 0.58f);
			string text = $"{buttonSize:0.###}|{num:0.###}|{GetUnityObjectId((Object?)(object)inventoryTrashIconSprite)}|{_uiLocalizationVersion}";
			if (!string.Equals(inventoryTrashButtonMarker.LayoutSignature, text, StringComparison.Ordinal))
			{
				SetRectLayout((RectTransform)((Component)inventoryTrashButtonMarker.Icon).transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(num, num));
				if ((Object)(object)inventoryTrashButtonMarker.Icon.sprite != (Object)(object)inventoryTrashIconSprite)
				{
					inventoryTrashButtonMarker.Icon.sprite = inventoryTrashIconSprite;
				}
				if (!inventoryTrashButtonMarker.Icon.preserveAspect)
				{
					inventoryTrashButtonMarker.Icon.preserveAspect = true;
				}
				if (((Graphic)inventoryTrashButtonMarker.Icon).raycastTarget)
				{
					((Graphic)inventoryTrashButtonMarker.Icon).raycastTarget = false;
				}
				UITooltip val3 = ((Component)button).GetComponent<UITooltip>() ?? ((Component)button).gameObject.AddComponent<UITooltip>();
				string text2 = LocalizeUi("$inventoryslots_trash_title", "Trash");
				string text3 = LocalizeUi("$inventoryslots_trash_tooltip", "Drop a held inventory item here to delete it after confirmation.");
				if (val3.m_topic != text2)
				{
					val3.m_topic = text2;
				}
				if (val3.m_text != text3)
				{
					val3.m_text = text3;
				}
				inventoryTrashButtonMarker.LayoutSignature = text;
			}
		}

		private static void SetInventoryTrashButtonVisual(Button button, bool canTrash)
		{
			//IL_0072: 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)
			InventoryTrashButtonMarker component = ((Component)button).GetComponent<InventoryTrashButtonMarker>();
			if ((Object)(object)component?.Icon != (Object)null && !IsUnityNull((Object?)(object)component.Icon) && (!component.HasVisualState || component.LastCanTrash != canTrash))
			{
				((Graphic)component.Icon).color = (canTrash ? new Color(1f, 0.82f, 0.55f, 1f) : new Color(0.75f, 0.75f, 0.75f, 0.65f));
				component.LastCanTrash = canTrash;
				component.HasVisualState = true;
			}
		}

		private static Sprite GetInventoryTrashIconSprite()
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00bb: 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_00df: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_inventoryTrashIconSprite != (Object)null && !IsUnityNull((Object?)(object)_inventoryTrashIconSprite))
			{
				return _inventoryTrashIconSprite;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				name = "InventorySlots_TrashIconTexture",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Color white = Color.white;
			Color[] array = (Color[])(object)new Color[4096];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = val2;
			}
			DrawTrashLine(array, 64, 19, 18, 45, 18, 3, white);
			DrawTrashLine(array, 64, 25, 13, 39, 13, 3, white);
			DrawTrashLine(array, 64, 23, 22, 27, 50, 3, white);
			DrawTrashLine(array, 64, 41, 22, 37, 50, 3, white);
			DrawTrashLine(array, 64, 27, 50, 37, 50, 3, white);
			DrawTrashLine(array, 64, 30, 26, 30, 45, 2, white);
			DrawTrashLine(array, 64, 34, 26, 34, 45, 2, white);
			val.SetPixels(array);
			val.Apply(false, true);
			_inventoryTrashIconSprite = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
			((Object)_inventoryTrashIconSprite).name = "InventorySlots_TrashIcon";
			return _inventoryTrashIconSprite;
		}

		private static void DrawTrashLine(Color[] pixels, int textureSize, int x0, int y0, int x1, int y1, int thickness, Color color)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Abs(x1 - x0);
			int num2 = ((x0 < x1) ? 1 : (-1));
			int num3 = -Math.Abs(y1 - y0);
			int num4 = ((y0 < y1) ? 1 : (-1));
			int num5 = num + num3;
			while (true)
			{
				DrawTrashPoint(pixels, textureSize, x0, y0, thickness, color);
				if (x0 != x1 || y0 != y1)
				{
					int num6 = 2 * num5;
					if (num6 >= num3)
					{
						num5 += num3;
						x0 += num2;
					}
					if (num6 <= num)
					{
						num5 += num;
						y0 += num4;
					}
					continue;
				}
				break;
			}
		}

		private static void DrawTrashPoint(Color[] pixels, int textureSize, int x, int y, int thickness, Color color)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Max(1, thickness);
			for (int i = y - num; i <= y + num; i++)
			{
				for (int j = x - num; j <= x + num; j++)
				{
					if (j >= 0 && j < textureSize && i >= 0 && i < textureSize)
					{
						int num2 = textureSize - 1 - i;
						pixels[num2 * textureSize + j] = color;
					}
				}
			}
		}

		private static void TryClickInventoryTrashPanel()
		{
			InventoryGui instance = InventoryGui.instance;
			Player localPlayer = Player.m_localPlayer;
			if (CanStartInventoryTrash(instance, localPlayer, showMessage: true))
			{
				int amount = Mathf.Clamp(instance.m_dragAmount, 1, instance.m_dragItem.m_stack);
				ShowInventoryTrashConfirmDialog(instance, instance.m_dragInventory, instance.m_dragItem, amount);
			}
		}

		private static bool CanStartInventoryTrash(InventoryGui? gui, Player? player, bool showMessage)
		{
			ConfigEntry<Toggle> enableInventoryTrashPanel = _enableInventoryTrashPanel;
			if (enableInventoryTrashPanel == null || enableInventoryTrashPanel.Value != Toggle.On)
			{
				return false;
			}
			if ((Object)(object)gui == (Object)null || (Object)(object)player == (Object)null || !InventoryGui.IsVisible())
			{
				return false;
			}
			if (player.m_isLoading || ((Character)player).IsTeleporting())
			{
				return false;
			}
			if ((Object)(object)gui.m_dragGo == (Object)null || gui.m_dragItem == null || gui.m_dragInventory == null)
			{
				if (showMessage)
				{
					ShowInventoryTrashMessage(player, "$inventoryslots_trash_no_item", "Pick up an item first.");
				}
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || gui.m_dragInventory != inventory)
			{
				if (showMessage)
				{
					ShowInventoryTrashMessage(player, "$inventoryslots_trash_player_inventory_only", "Only player inventory items can be trashed.");
				}
				return false;
			}
			return CanTrashInventoryItem(player, inventory, gui.m_dragItem, showMessage);
		}

		private static bool CanTrashInventoryItem(Player player, Inventory inventory, ItemData item, bool showMessage)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null || item == null || !inventory.ContainsItem(item))
			{
				if (showMessage)
				{
					ShowInventoryTrashMessage(player, "$inventoryslots_trash_item_missing", "That item is no longer available.");
				}
				return false;
			}
			if (!CanTrashInventoryCell(player, inventory, item.m_gridPos))
			{
				if (showMessage)
				{
					ShowInventoryTrashMessage(player, "$inventoryslots_trash_hotbar_item", "Only regular inventory items can be trashed.");
				}
				return false;
			}
			if (IsFavoriteProtected(player, inventory, item))
			{
				if (showMessage)
				{
					ShowInventoryTrashMessage(player, "$inventoryslots_trash_favorite_item", "Favorite items cannot be trashed.");
				}
				return false;
			}
			return true;
		}

		private static bool CanTrashInventoryCell(Player player, Inventory inventory, Vector2i pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return InventoryActionCellPolicyCore.CanTrashSlot(GetInventoryCellKind(player, inventory, pos));
		}

		private static void ShowInventoryTrashConfirmDialog(InventoryGui gui, Inventory inventory, ItemData item, int amount)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00e1: 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_010d: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			CloseInventoryTrashConfirmDialog();
			if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_splitPanel == (Object)null || inventory == null || item == null || amount <= 0)
			{
				return;
			}
			_inventoryTrashPendingInventory = inventory;
			_inventoryTrashPendingItem = item;
			_inventoryTrashPendingAmount = amount;
			_inventoryTrashConfirmDialog = Object.Instantiate<GameObject>(((Component)gui.m_splitPanel).gameObject, ((Component)gui).transform);
			((Object)_inventoryTrashConfirmDialog).name = "InventorySlots_TrashConfirmDialog";
			Button val = FindInventoryTrashConfirmButton(_inventoryTrashConfirmDialog, "win_bkg/Button_ok");
			Button val2 = FindInventoryTrashConfirmButton(_inventoryTrashConfirmDialog, "win_bkg/Button_cancel");
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				CloseInventoryTrashConfirmDialog();
				return;
			}
			((UnityEventBase)val.onClick).RemoveAllListeners();
			((UnityEvent)val.onClick).AddListener(new UnityAction(ConfirmInventoryTrashDelete));
			SetInventoryTrashConfirmButtonText(val, LocalizeUi("$inventoryslots_trash_delete", "Delete"), new Color(1f, 0.25f, 0.12f, 1f));
			((UnityEventBase)val2.onClick).RemoveAllListeners();
			((UnityEvent)val2.onClick).AddListener(new UnityAction(CloseInventoryTrashConfirmDialog));
			SetInventoryTrashConfirmButtonText(val2, LocalizeUi("$menu_cancel", "Cancel"), Color.white);
			Transform val3 = _inventoryTrashConfirmDialog.transform.Find("win_bkg/Slider");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(false);
			}
			Transform obj = _inventoryTrashConfirmDialog.transform.Find("win_bkg/Text");
			TMP_Text val4 = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val4 != (Object)null)
			{
				ApplyDefaultFontAsset(val4);
				string newValue = LocalizeUi(item.m_shared.m_name, item.m_shared.m_name);
				string text = LocalizeUi("$inventoryslots_trash_confirm_format", "Delete {item}?");
				val4.text = text.Replace("{item}", newValue);
			}
			Transform obj2 = _inventoryTrashConfirmDialog.transform.Find("win_bkg/amount");
			TMP_Text val5 = ((obj2 != null) ? ((Component)obj2).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val5 != (Object)null)
			{
				ApplyDefaultFontAsset(val5);
				val5.text = $"{amount}/{Mathf.Max(1, item.m_shared.m_maxStackSize)}";
			}
			Transform obj3 = _inventoryTrashConfirmDialog.transform.Find("win_bkg/Icon_bkg/Icon");
			Image val6 = ((obj3 != null) ? ((Component)obj3).GetComponent<Image>() : null);
			if ((Object)(object)val6 != (Object)null)
			{
				val6.sprite = item.GetIcon();
				val6.preserveAspect = true;
			}
			_inventoryTrashConfirmDialog.SetActive(true);
		}

		private static Button? FindInventoryTrashConfirmButton(GameObject dialog, string path)
		{
			Transform val = dialog.transform.Find(path);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).GetComponent<Button>();
		}

		private static void SetInventoryTrashConfirmButtonText(Button button, string label, Color color)
		{
			//IL_001c: 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)
			TMP_Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text obj in componentsInChildren)
			{
				ApplyDefaultFontAsset(obj);
				obj.text = label;
				((Graphic)obj).color = color;
			}
			Text[] componentsInChildren2 = ((Component)button).GetComponentsInChildren<Text>(true);
			foreach (Text obj2 in componentsInChildren2)
			{
				obj2.text = label;
				((Graphic)obj2).color = color;
			}
		}

		internal static void UpdateInventoryTrashConfirmDialogInput()
		{
			if (!((Object)(object)_inventoryTrashConfirmDialog == (Object)null) && !IsUnityNull((Object?)(object)_inventoryTrashConfirmDialog) && _inventoryTrashConfirmDialog.activeSelf)
			{
				if (ZInput.GetButtonDown("JoyButtonB") || ZInput.GetKeyDown((KeyCode)27, true))
				{
					CloseInventoryTrashConfirmDialog();
				}
				else if (ZInput.GetKeyDown((KeyCode)13, true) || ZInput.GetKeyDown((KeyCode)271, true))
				{
					ConfirmInventoryTrashDelete();
				}
			}
		}

		private static void ConfirmInventoryTrashDelete()
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			Player localPlayer = Player.m_localPlayer;
			Inventory inventoryTrashPendingInventory = _inventoryTrashPendingInventory;
			ItemData inventoryTrashPendingItem = _inventoryTrashPendingItem;
			int inventoryTrashPendingAmount = _inventoryTrashPendingAmount;
			CloseInventoryTrashConfirmDialog();
			if ((Object)(object)instance == (Object)null || (Object)(object)localPlayer == (Object)null || inventoryTrashPendingInventory == null || inventoryTrashPendingItem == null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventoryTrashPendingInventory != inventory || instance.m_dragInventory != inventoryTrashPendingInventory || instance.m_dragItem != inventoryTrashPendingItem || !CanTrashInventoryItem(localPlayer, inventoryTrashPendingInventory, inventoryTrashPendingItem, showMessage: true))
			{
				instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
				return;
			}
			inventoryTrashPendingAmount = Mathf.Clamp(inventoryTrashPendingAmount, 1, inventoryTrashPendingItem.m_stack);
			if (inventoryTrashPendingAmount >= inventoryTrashPendingItem.m_stack)
			{
				TryPrepareSlotItemForExternalRemoval(localPlayer, inventoryTrashPendingInventory, inventoryTrashPendingItem, out SlotDefinition _);
				if (((Humanoid)localPlayer).IsItemEquiped(inventoryTrashPendingItem))
				{
					((Humanoid)localPlayer).RemoveEquipAction(inventoryTrashPendingItem);
					((Humanoid)localPlayer).UnequipItem(inventoryTrashPendingItem, false);
				}
				ClearSlotActionState(inventoryTrashPendingItem);
				inventoryTrashPendingInventory.RemoveItem(inventoryTrashPendingItem);
			}
			else
			{
				inventoryTrashPendingInventory.RemoveItem(inventoryTrashPendingItem, inventoryTrashPendingAmount);
			}
			instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
			instance.UpdateCraftingPanel(false);
			inventoryTrashPendingInventory.Changed();
			ClearCraftingRequirementAvailabilityCache();
			instance.m_moveItemEffects.Create(((Component)instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
		}

		private static void ShowInventoryTrashMessage(Player player, string token, string fallback)
		{
			((Character)player).Message((MessageType)2, LocalizeUi(token, fallback), 0, (Sprite)null);
		}

		private static void CloseInventoryTrashConfirmDialog()
		{
			_inventoryTrashPendingInventory = null;
			_inventoryTrashPendingItem = null;
			_inventoryTrashPendingAmount = 0;
			if ((Object)(object)_inventoryTrashConfirmDialog != (Object)null && !IsUnityNull((Object?)(object)_inventoryTrashConfirmDialog))
			{
				Object.Destroy((Object)(object)_inventoryTrashConfirmDialog);
			}
			_inventoryTrashConfirmDialog = null;
		}

		internal static void UpdateInventoryGridUi(InventoryGrid playerGrid, Player player)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Expected O, but got Unknown
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: 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_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: 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_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: 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_038d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerGrid == (Object)null || (Object)(object)player == (Object)null || (Object)(object)playerGrid.m_gridRoot == (Object)null || playerGrid.m_elements == null)
			{
				return;
			}
			if (!InventoryGui.IsVisible())
			{
				UpdateQuickSlotInventoryPanelsWhileHidden();
				return;
			}
			int usableRegularRows = GetUsableRegularRows(player);
			int fixedRegularRows = GetFixedRegularRows();
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			int width = inventory.GetWidth();
			int num = usableRegularRows;
			int inventoryViewportRows = GetInventoryViewportRows(num);
			inventoryViewportRows = UpdatePlayerInventoryScroll(playerGrid, inventoryViewportRows, num);
			if (playerGrid.m_elements.Count == 0)
			{
				HideInventorySideHints();
				return;
			}
			Vector3 gridOrigin = GetGridOrigin(playerGrid);
			float num2 = inventoryViewportRows;
			playerGrid.m_gridRoot.SetSizeWithCurrentAnchors((Axis)1, num2 * playerGrid.m_elementSpace);
			if (UpdateInventoryPanelDragging() && TryUpdateDraggedInventoryPanelPositionOnly(playerGrid, gridOrigin, width))
			{
				return;
			}
			List<SlotDefinition> customPanelSlots = GetCustomPanelSlots(player, inventory);
			List<SlotDefinition> quickPanelSlots = GetQuickPanelSlots(player);
			UpdatePlayerInventoryPanelBackground(inventoryViewportRows);
			UpdateContainerPanelPosition(inventoryViewportRows, playerGrid.m_elementSpace);
			RectTransform val = ((customPanelSlots.Count > 0) ? EnsureSlotPanel(playerGrid, "InventorySlots_CustomSlotPanel", InventoryPanels.CustomSlotPanels) : DisableSlotPanel(playerGrid, "InventorySlots_CustomSlotPanel", InventoryPanels.CustomSlotPanels));
			RectTransform val2 = ((quickPanelSlots.Count > 0) ? EnsureSlotPanel(playerGrid, "InventorySlots_QuickSlotPanel", InventoryPanels.QuickSlotPanels) : DisableSlotPanel(playerGrid, "InventorySlots_QuickSlotPanel", InventoryPanels.QuickSlotPanels));
			Vector2i pos = default(Vector2i);
			for (int i = 0; i < playerGrid.m_elements.Count; i++)
			{
				Element val3 = playerGrid.m_elements[i];
				if (IsUnityNull((Object?)(object)val3?.m_go))
				{
					continue;
				}
				int num3 = i / width;
				int num4 = i - num3 * width;
				((Vector2i)(ref pos))..ctor(num4, num3);
				if (!IsExternalReservedCell(pos, includeRestockableSlots: true) && num3 >= usableRegularRows && num3 < fixedRegularRows && !ShouldShowLockedInventoryCellForRecovery(player, inventory, pos))
				{
					val3.m_go.SetActive(false);
					val3.m_used = true;
					SetFavoriteBorderActive(val3, active: false);
					SetInventoryPinnedTooltipBorderActive(val3, active: false);
				}
				else if (num3 >= fixedRegularRows)
				{
					int num5 = (num3 - fixedRegularRows) * width + num4;
					if (num5 >= SlotDefinitions.Count)
					{
						val3.m_go.SetActive(false);
						val3.m_used = true;
						UpdateSlotBindingLabel(val3, null);
						SetFavoriteBorderActive(val3, active: false);
						SetInventoryPinnedTooltipBorderActive(val3, active: false);
						continue;
					}
					SlotDefinition slotDefinition = SlotDefinitions[num5];
					bool flag = slotDefinition.Kind == SlotKind.Quick;
					RectTransform val4 = (flag ? val2 : val);
					int num6 = (flag ? quickPanelSlots : customPanelSlots).IndexOf(slotDefinition);
					if ((Object)(object)val4 == (Object)null || num6 < 0)
					{
						val3.m_go.SetActive(false);
						val3.m_used = true;
						UpdateSlotBindingLabel(val3, null);
						SetFavoriteBorderActive(val3, active: false);
						SetInventoryPinnedTooltipBorderActive(val3, active: false);
						continue;
					}
					RectTransform val5 = (RectTransform)val3.m_go.transform;
					((Transform)val5).SetParent((Transform)(object)val4, false);
					((Transform)val5).localScale = Vector3.one;
					((Transform)val5).localRotation = Quaternion.identity;
					((Transform)val5).localPosition = (flag ? GetQuickSlotPanelElementPosition(num6, playerGrid.m_elementSpace) : GetCustomSlotPanelElementPosition(num6, playerGrid.m_elementSpace));
					val3.m_go.SetActive(true);
					if (!val3.m_used && (Object)(object)val3.m_tooltip != (Object)null)
					{
						val3.m_tooltip.m_topic = "";
						val3.m_tooltip.m_text = "";
					}
					bool flag2 = UpdateEquipmentSlotElementState(val3, player, inventory, slotDefinition, new Vector2i(num4, num3));
					UpdateSlotBindingLabel(val3, slotDefinition, !flag && flag2);
					UpdateFavoriteBorder(val3, player, inventory, new Vector2i(num4, num3));
					UpdateInventoryPinnedTooltipBorder(playerGrid, val3, new Vector2i(num4, num3));
				}
				else
				{
					RectTransform val6 = (RectTransform)val3.m_go.transform;
					if ((Object)(object)((Transform)val6).parent != (Object)(object)playerGrid.m_gridRoot)
					{
						((Transform)val6).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
					}
					if (num3 >= inventoryViewportRows || num3 >= num)
					{
						val3.m_go.SetActive(false);
						val3.m_used = true;
						SetFavoriteBorderActive(val3, active: false);
						SetInventoryPinnedTooltipBorderActive(val3, active: false);
					}
					else
					{
						((Transform)val6).localPosition = gridOrigin + new Vector3((float)num4 * playerGrid.m_elementSpace, (float)(-num3) * playerGrid.m_elementSpace, 0f);
						val3.m_go.SetActive(true);
						UpdateFavoriteBorder(val3, player, inventory, new Vector2i(num4, num3));
						UpdateInventoryPinnedTooltipBorder(playerGrid, val3, new Vector2i(num4, num3));
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				int customPanelColumns = GetCustomPanelColumns(customPanelSlots.Count);
				Vector3 sidePanelBasePosition = GetSidePanelBasePosition(gridOrigin, width, playerGrid.m_elementSpace);
				((Transform)val).localPosition = sidePanelBasePosition + Vector2.op_Implicit(InventoryPanels.EquipmentSlotsPanelRuntimeOffset);
				UpdateVanillaPanelBackground(val, (float)customPanelColumns * playerGrid.m_elementSpace, 3f * playerGrid.m_elementSpace);
				((Component)val).gameObject.SetActive(customPanelSlots.Count > 0);
				UpdatePlayerStatPanels(val, customPanelColumns, playerGrid.m_elementSpace);
			}
			else
			{
				RestorePlayerStatPanels();
			}
			if ((Object)(object)val2 != (Object)null)
			{
				Vector3 sidePanelBasePosition2 = GetSidePanelBasePosition(gridOrigin, width, playerGrid.m_elementSpace);
				float num7 = (0f - (((customPanelSlots.Count > 0) ? 3f : 0f) + ((customPanelSlots.Count > 0) ? 0.35f : 0f))) * playerGrid.m_elementSpace;
				Vector3 targetGridLocalPosition = sidePanelBasePosition2 + new Vector3(0f, num7, 0f) + Vector2.op_Implicit(InventoryPanels.QuickSlotsPanelRuntimeOffset);
				PositionQuickSlotPanel(playerGrid, val2, targetGridLocalPosition, playerGrid.m_elementSpace);
				int quickPanelRows = GetQuickPanelRows(quickPanelSlots.Count);
				UpdateVanillaPanelBackground(val2, 3f * playerGrid.m_elementSpace, (float)quickPanelRows * playerGrid.m_elementSpace);
				((Component)val2).gameObject.SetActive(quickPanelSlots.Count > 0);
			}
			UpdateInventorySideHints(playerGrid, gridOrigin, playerGrid.m_elementSpace, num);
			UpdateInventoryActionPanels(playerGrid, player, gridOrigin, inventoryViewportRows);
			EnsureInventoryPinnedTooltipHandlers(InventoryGui.instance?.m_playerGrid);
			EnsureInventoryPinnedTooltipHandlers(InventoryGui.instance?.m_containerGrid);
			UpdateInventoryPinnedTooltipGridBorders(InventoryGui.instance?.m_containerGrid);
			UpdateContainerWeightPanelPosition();
		}

		private static string GetInventoryItemBigGroupId(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return "";
			}
			ItemClassification itemClassification = GetItemClassification(item);
			if (itemClassification.BigGroupResolved)
			{
				return itemClassification.BigGroupId;
			}
			for (int i = 0; i < CraftingRecipeGroupFilters.Count; i++)
			{
				CraftingRecipeGroupFilter craftingRecipeGroupFilter = CraftingRecipeGroupFilters[i];
				if (craftingRecipeGroupFilter.Id != "favorite" && craftingRecipeGroupFilter.Matches(item))
				{
					itemClassification.BigGroupId = craftingRecipeGroupFilter.Id;
					itemClassification.BigGroupResolved = true;
					return itemClassification.BigGroupId;
				}
			}
			itemClassification.BigGroupId = "";
			itemClassification.BigGroupResolved = true;
			return itemClassification.BigGroupId;
		}

		private static bool ItemMatchesBuiltInPredefinedGroup(ItemData item, string groupId)
		{
			string text = NormalizeGroupId(groupId);
			if (item?.m_shared == null || string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			ItemClassification itemClassification = GetItemClassification(item);
			if (itemClassification.BuiltInGroupMatches.TryGetValue(text, out var value))
			{
				return value;
			}
			bool flag = ItemMatchesBuiltInPredefinedGroupUncached(item, text);
			itemClassification.BuiltInGroupMatches[text] = flag;
			return flag;
		}

		private static bool ItemMatchesBuiltInPredefinedGroupUncached(ItemData item, string id)
		{
			if (BuiltInGroupMatchers.TryGetValue(id, out Func<ItemData, bool> value))
			{
				return value(item);
			}
			return false;
		}

		private static int GetItemClassifierCacheVersion()
		{
			EnsureFeastMaterialTokens();
			return ItemClassifierRuntime.Version;
		}

		private static string GetItemClassifierCacheKey(ItemData item)
		{
			return string.Join("|", GetItemPrefabName(item), GetSharedName(item), ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<SkillType, SkillType>(ref item.m_shared.m_skillType)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_attachOverride)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<AnimationState, AnimationState>(ref item.m_shared.m_animationState)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<AttackType, AttackType>(ref item.m_shared.m_attack.m_attackType)/*cast due to .constrained prefix*/).ToString(), GetAttackAnimation(item), GetAmmoType(item), ((Object)(object)item.m_shared.m_consumeStatusEffect != (Object)null) ? ((Object)item.m_shared.m_consumeStatusEffect).name : "", item.m_shared.m_maxStackSize.ToString(CultureInfo.InvariantCulture), item.m_shared.m_value.ToString(CultureInfo.InvariantCulture), FormatClassifierFloat(GetFoodHealth(item)), FormatClassifierFloat(GetFoodStamina(item)), FormatClassifierFloat(GetFoodEitr(item)), FormatClassifierFloat(GetTotalDamage(item)), ((Object)(object)item.m_shared.m_appendToolTip != (Object)null) ? "append" : "");
		}

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

		private static void ClearItemClassifierCaches()
		{
			ItemClassifierRuntime.Cache.Clear();
			ItemClassifierRuntime.AppliedVersion = ItemClassifierRuntime.Version;
		}

		private static ItemClassification GetItemClassification(ItemData item)
		{
			EnsureItemClassifierCacheFresh();
			string itemClassifierCacheKey = GetItemClassifierCacheKey(item);
			if (ItemClassifierRuntime.Cache.TryGetValue(itemClassifierCacheKey, out ItemClassification value))
			{
				return value;
			}
			if (ItemClassifierRuntime.Cache.Count >= 2048)
			{
				ItemClassifierRuntime.Cache.Clear();
			}
			ItemClassification itemClassification = new ItemClassification();
			ItemClassifierRuntime.Cache[itemClassifierCacheKey] = itemClassification;
			return itemClassification;
		}

		private static void EnsureItemClassifierCacheFresh()
		{
			int itemClassifierCacheVersion = GetItemClassifierCacheVersion();
			if (ItemClassifierRuntime.AppliedVersion != itemClassifierCacheVersion)
			{
				ItemClassifierRuntime.Cache.Clear();
				ItemClassifierRuntime.AppliedVersion = itemClassifierCacheVersion;
			}
		}

		private static bool MatchMeleeCategory(ItemData item)
		{
			if (!MatchNativeRangedCategory(item) && !MatchNativeMagicCategory(item))
			{
				if (!MatchNativeMeleeCategory(item) && !MatchToolCategory(item))
				{
					return MatchConfiguredCustomGroupInCraftingGroup(item, "melee");
				}
				return true;
			}
			return false;
		}

		private static bool MatchRangedCategory(ItemData item)
		{
			if (!MatchNativeRangedCategory(item))
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "ranged");
			}
			return true;
		}

		private static bool MatchMagicCategory(ItemData item)
		{
			if (!MatchNativeMagicCategory(item))
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "magic");
			}
			return true;
		}

		private static bool MatchNativeMeleeCategory(ItemData item)
		{
			if (!MatchSwordCategory(item) && !MatchKnifeCategory(item) && !MatchClubCategory(item) && !MatchPolearmCategory(item) && !MatchSpearCategory(item) && !MatchAxeCategory(item) && !MatchFistsCategory(item))
			{
				return MatchShieldCategory(item);
			}
			return true;
		}

		private static bool MatchNativeRangedCategory(ItemData item)
		{
			if (!MatchBowWeaponCategory(item) && !MatchCrossbowWeaponCategory(item) && !MatchArrowAmmo(item) && !MatchBoltAmmo(item) && !MatchRangedGenericAmmo(item))
			{
				return MatchBombCategory(item);
			}
			return true;
		}

		private static bool MatchNativeMagicCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_skillType != 9)
			{
				return (int)item.m_shared.m_skillType == 10;
			}
			return true;
		}

		private static bool MatchArmorCategory(ItemData item)
		{
			if (!MatchHelmetCategory(item) && !MatchChestCategory(item) && !MatchLegsCategory(item) && !MatchCapeCategory(item) && !MatchUtilityCategory(item) && !MatchTrinketCategory(item))
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "armor");
			}
			return true;
		}

		private static bool MatchFoodCategory(ItemData item)
		{
			if (!MatchPrimaryFoodCategory(item))
			{
				if (IsStationFoodInput(item))
				{
					return !MatchPrimaryNonFoodCategory(item);
				}
				return false;
			}
			return true;
		}

		private static bool MatchPrimaryFoodCategory(ItemData item)
		{
			if (!MatchFeastCategory(item) && !IsNativeFoodCategory(item))
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "food");
			}
			return true;
		}

		private static bool MatchPrimaryNonFoodCategory(ItemData item)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			if (!MatchMeleeCategory(item) && !MatchRangedCategory(item) && !MatchMagicCategory(item) && !MatchArmorCategory(item) && !MatchConsumableCategory(item) && !MatchMeadBaseCategory(item) && (int)item.m_shared.m_itemType != 13 && item.m_shared.m_value <= 0)
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "misc");
			}
			return true;
		}

		private static bool MatchHealthFoodCategory(ItemData item)
		{
			if (!MatchFeastCategory(item) && IsNativeFoodCategory(item) && TryGetDominantFoodStat(item, out var stat))
			{
				return stat == FoodStat.Health;
			}
			return false;
		}

		private static bool MatchStaminaFoodCategory(ItemData item)
		{
			if (!MatchFeastCategory(item) && IsNativeFoodCategory(item) && TryGetDominantFoodStat(item, out var stat))
			{
				return stat == FoodStat.Stamina;
			}
			return false;
		}

		private static bool MatchEitrFoodCategory(ItemData item)
		{
			if (!MatchFeastCategory(item) && IsNativeFoodCategory(item) && TryGetDominantFoodStat(item, out var stat))
			{
				return stat == FoodStat.Eitr;
			}
			return false;
		}

		private static bool IsNativeFoodCategory(ItemData item)
		{
			if (HasFoodCarrier(item))
			{
				if (!(GetFoodHealth(item) > 0f) && !(GetFoodStamina(item) > 0f))
				{
					return GetFoodEitr(item) > 0f;
				}
				return true;
			}
			return false;
		}

		private static bool IsStationFoodInput(ItemData item)
		{
			if (!ItemMatchesStationInput(CraftingRecipeFoodInputTokens, item) && !ItemMatchesStationInput(CookingStationFoodInputTokens, item))
			{
				return ItemMatchesStationInput(FermenterFoodInputTokens, item);
			}
			return true;
		}

		private static bool ItemMatchesStationInput(HashSet<string> stationInputTokens, ItemData item)
		{
			if (stationInputTokens.Count == 0 || item?.m_shared == null)
			{
				return false;
			}
			foreach (string itemIdentityToken in GetItemIdentityTokens(item))
			{
				if (stationInputTokens.Contains(itemIdentityToken))
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<string> GetItemIdentityTokens(ItemData item)
		{
			string itemPrefabName = GetItemPrefabName(item);
			string text = item.m_shared.m_name ?? "";
			string[] array = new string[3]
			{
				itemPrefabName,
				NormalizeResourceToken(itemPrefabName),
				text
			};
			foreach (string text2 in array)
			{
				if (!string.IsNullOrWhiteSpace(text2))
				{
					yield return text2;
				}
			}
		}

		private static bool MatchConsumableCategory(ItemData item)
		{
			if (!MatchMeadBaseCategory(item))
			{
				if (!MatchMeadCategory(item) && !MatchPotionCategory(item))
				{
					return MatchConfiguredCustomGroupInCraftingGroup(item, "consumable");
				}
				return true;
			}
			return false;
		}

		private static bool MatchMeadCategory(ItemData item)
		{
			if (!MatchMeadBaseCategory(item))
			{
				return ItemMatchesStationInput(FermenterOutputTokens, item);
			}
			return false;
		}

		private static bool MatchPotionCategory(ItemData item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if (!MatchPrimaryFoodCategory(item) && !MatchMeadCategory(item) && !MatchMeadBaseCategory(item) && ((int)item.m_shared.m_itemType == 1 || (int)item.m_shared.m_itemType == 2))
			{
				return (Object)(object)item.m_shared.m_consumeStatusEffect != (Object)null;
			}
			return false;
		}

		private static bool MatchMeadBaseCategory(ItemData item)
		{
			if (!ItemMatchesStationInput(FermenterInputTokens, item))
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "meadbase");
			}
			return true;
		}

		private static bool MatchToolCategory(ItemData item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			if (!MatchPrimaryFoodCategory(item) && !MatchConsumableCategory(item) && !MatchMeadBaseCategory(item))
			{
				if ((int)item.m_shared.m_itemType != 19 && !MatchTorchCategory(item) && (int)item.m_shared.m_skillType != 12 && (int)item.m_shared.m_skillType != 104 && (int)item.m_shared.m_skillType != 106)
				{
					return MatchConfiguredCustomGroupInCraftingGroup(item, "tool");
				}
				return true;
			}
			return false;
		}

		private static bool MatchMiscCategory(ItemData item)
		{
			if (!MatchMeleeCategory(item) && !MatchRangedCategory(item) && !MatchMagicCategory(item) && !MatchArmorCategory(item) && !MatchFoodCategory(item) && !MatchConsumableCategory(item) && !MatchMeadBaseCategory(item))
			{
				return !MatchToolCategory(item);
			}
			return false;
		}

		private static bool MatchArrowAmmo(ItemData item)
		{
			if (!HasAttackAnimation(item) && (string.Equals(GetAmmoType(item), "$ammo_arrows", StringComparison.Ordinal) || ItemIdentityStartsWith(item, "Arrow")))
			{
				return GetTotalDamage(item) > 0f;
			}
			return false;
		}

		private static bool MatchBoltAmmo(ItemData item)
		{
			if (!HasAttackAnimation(item) && (string.Equals(GetAmmoType(item), "$ammo_bolts", StringComparison.Ordinal) || ItemIdentityStartsWith(item, "Bolt")))
			{
				return GetTotalDamage(item) > 0f;
			}
			return false;
		}

		private static bool MatchRangedGenericAmmo(ItemData item)
		{
			if (MatchAmmoCategory(item) && !MatchArrowAmmo(item) && !MatchBoltAmmo(item))
			{
				return !IsNonCombatAmmo(item);
			}
			return false;
		}

		private static bool MatchAmmoCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_itemType != 9)
			{
				return (int)item.m_shared.m_itemType == 23;
			}
			return true;
		}

		private static bool MatchHelmetCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)6);
		}

		private static bool MatchChestCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)7);
		}

		private static bool MatchLegsCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)11);
		}

		private static bool MatchCapeCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)17);
		}

		private static bool MatchUtilityCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)18);
		}

		private static bool MatchTrinketCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)24);
		}

		private static bool MatchSwordCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)1);
		}

		private static bool MatchAxeCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)7);
		}

		private static bool MatchClubCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)3);
		}

		private static bool MatchKnifeCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)2);
		}

		private static bool MatchSpearCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)5);
		}

		private static bool MatchPolearmCategory(ItemData item)
		{
			if (!IsSkillAttack(item, (SkillType)4))
			{
				return IsItemTypeOrAttach(item, (ItemType)20);
			}
			return true;
		}

		private static bool MatchPickaxeCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			return (int)item.m_shared.m_skillType == 12;
		}

		private static bool MatchBowWeaponCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_skillType == 14 || (int)item.m_shared.m_skillType == 9 || (int)item.m_shared.m_skillType == 10 || (int)item.m_shared.m_itemType != 4)
			{
				return IsSkillAttack(item, (SkillType)8);
			}
			return true;
		}

		private static bool MatchCrossbowWeaponCategory(ItemData item)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			if (!MatchAmmoCategory(item) && (int)item.m_shared.m_skillType == 14)
			{
				if ((int)item.m_shared.m_itemType != 4)
				{
					return HasAttackAnimation(item);
				}
				return true;
			}
			return false;
		}

		private static bool MatchTorchCategory(ItemData item)
		{
			return IsItemTypeOrAttach(item, (ItemType)15);
		}

		private static bool IsNonCombatAmmo(ItemData item)
		{
			string ammoType = GetAmmoType(item);
			if (!string.Equals(ammoType, "$item_fishingbait", StringComparison.OrdinalIgnoreCase) && !string.Equals(ammoType, "mead", StringComparison.OrdinalIgnoreCase))
			{
				return ammoType.IndexOf("spell", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool ItemIdentityStartsWith(ItemData item, string prefix)
		{
			string[] array = new string[2]
			{
				GetItemPrefabName(item),
				StripLocalizationToken(GetSharedName(item))
			};
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool MatchFeastCategory(ItemData item)
		{
			if (!MatchFeastMaterialIdentity(item))
			{
				return ItemMatchesFeastMaterialToken(item);
			}
			return true;
		}

		private static bool MatchFeastMaterialIdentity(ItemData item)
		{
			string[] array = new string[2]
			{
				GetItemPrefabName(item),
				StripLocalizationToken(GetSharedName(item))
			};
			for (int i = 0; i < array.Length; i++)
			{
				string text = CleanPrefabName(array[i]);
				if (text.StartsWith("Feast", StringComparison.OrdinalIgnoreCase) && text.IndexOf("Material", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static bool ItemMatchesFeastMaterialToken(ItemData item)
		{
			EnsureFeastMaterialTokens();
			return ItemMatchesStationInput(ItemClassifierRuntime.FeastMaterialTokens, item);
		}

		private static void EnsureFeastMaterialTokens()
		{
			string feastMaterialTokenSignature = GetFeastMaterialTokenSignature();
			if (string.Equals(ItemClassifierRuntime.FeastMaterialSignature, feastMaterialTokenSignature, StringComparison.Ordinal))
			{
				return;
			}
			ItemClassifierRuntime.FeastMaterialSignature = feastMaterialTokenSignature;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (IsUnityNull((Object?)(object)ZNetScene.instance) || ZNetScene.instance.m_prefabs == null)
			{
				if (ItemClassifierRuntime.FeastMaterialTokens.Count > 0)
				{
					ItemClassifierRuntime.FeastMaterialTokens.Clear();
					ItemClassifierRuntime.Version++;
				}
				return;
			}
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				if (IsUnityNull((Object?)(object)prefab))
				{
					continue;
				}
				Feast[] componentsInChildren = prefab.GetComponentsInChildren<Feast>(true);
				foreach (Feast val in componentsInChildren)
				{
					if (IsUnityNull((Object?)(object)val))
					{
						continue;
					}
					AddItemIdentityTokens(hashSet, val.m_foodItem);
					Piece val2 = ((Component)val).GetComponent<Piece>() ?? ((Component)val).GetComponentInParent<Piece>();
					if (val2?.m_resources != null)
					{
						Requirement[] resources = val2.m_resources;
						foreach (Requirement val3 in resources)
						{
							AddItemIdentityTokens(hashSet, val3.m_resItem);
						}
					}
				}
			}
			if (!ItemClassifierRuntime.FeastMaterialTokens.SetEquals(hashSet))
			{
				ItemClassifierRuntime.FeastMaterialTokens.Clear();
				ItemClassifierRuntime.FeastMaterialTokens.UnionWith(hashSet);
				ItemClassifierRuntime.Version++;
			}
		}

		private static string GetFeastMaterialTokenSignature()
		{
			if (IsUnityNull((Object?)(object)ZNetScene.instance) || ZNetScene.instance.m_prefabs == null)
			{
				return "none";
			}
			return $"{((Object)ZNetScene.instance).GetInstanceID()}|{ZNetScene.instance.m_prefabs.Count}";
		}

		private static bool MatchBombCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: 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_002c: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_itemType == 3 && (int)item.m_shared.m_animationState == 0 && (int)item.m_shared.m_attack.m_attackType == 2)
			{
				return string.Equals(GetAttackAnimation(item), "throw_bomb", StringComparison.Ordinal);
			}
			return false;
		}

		private static bool MatchElementalMagicCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)9);
		}

		private static bool MatchBloodMagicCategory(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_skillType == 10)
			{
				return HasAttackAnimation(item);
			}
			return false;
		}

		private static bool MatchFistsCategory(ItemData item)
		{
			return IsSkillAttack(item, (SkillType)11);
		}

		private static bool MatchShieldCategory(ItemData item)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if (!IsItemTypeOrAttach(item, (ItemType)5))
			{
				return (int)item.m_shared.m_skillType == 6;
			}
			return true;
		}

		private static bool MatchConfiguredCustomGroupInCraftingGroup(ItemData item, string craftingGroupId)
		{
			if (item?.m_shared == null || !PredefinedGroupOrders.TryGetValue(NormalizeGroupId(craftingGroupId), out List<string> value))
			{
				return false;
			}
			foreach (string item2 in value)
			{
				if (PredefinedGroupDefinitions.ContainsKey(item2) && ItemMatchesPredefinedGroup(item, item2))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsSkillAttack(ItemData item, SkillType skillType)
		{
			//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)
			if (item.m_shared.m_skillType == skillType && HasAttackAnimation(item))
			{
				return GetTotalDamage(item) > 0f;
			}
			return false;
		}

		private static bool IsItemTypeOrAttach(ItemData item, ItemType itemType)
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (item.m_shared.m_itemType != itemType)
			{
				return item.m_shared.m_attachOverride == itemType;
			}
			return true;
		}

		private static bool HasFoodCarrier(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_itemType != 2)
			{
				if ((int)item.m_shared.m_itemType == 1)
				{
					return (Object)(object)item.m_shared.m_appendToolTip != (Object)null;
				}
				return false;
			}
			return true;
		}

		private static float GetFoodHealth(ItemData item)
		{
			return GetFoodSharedData(item).m_food;
		}

		private static float GetFoodStamina(ItemData item)
		{
			return GetFoodSharedData(item).m_foodStamina;
		}

		private static float GetFoodEitr(ItemData item)
		{
			return GetFoodSharedData(item).m_foodEitr;
		}

		private static SharedData GetFoodSharedData(ItemData item)
		{
			return item.m_shared.m_appendToolTip?.m_itemData?.m_shared ?? item.m_shared;
		}

		internal static bool TryGetDominantFoodStat(ItemData item, out FoodStat stat)
		{
			return FoodStatCore.TryGetDominant(GetFoodHealth(item), GetFoodStamina(item), GetFoodEitr(item), out stat);
		}

		private static string GetAttackAnimation(ItemData item)
		{
			return item.m_shared.m_attack.m_attackAnimation ?? "";
		}

		private static string GetAmmoType(ItemData item)
		{
			return item.m_shared.m_ammoType ?? "";
		}

		private static string GetSharedName(ItemData item)
		{
			return item.m_shared.m_name ?? "";
		}

		private static string GetItemPrefabName(ItemData item)
		{
			return CleanPrefabName(((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : "");
		}

		private static bool HasAttackAnimation(ItemData item)
		{
			return !string.IsNullOrEmpty(GetAttackAnimation(item));
		}

		private static float GetTotalDamage(ItemData item)
		{
			return ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage();
		}

		private static string AppendItemRequiresSkillLevelCraftingTooltip(RecipeDataPair pair, string tooltip)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string itemRequiresSkillLevelCraftingTooltipText = GetItemRequiresSkillLevelCraftingTooltipText(pair);
			return AppendDistinctTooltipLines(tooltip, itemRequiresSkillLevelCraftingTooltipText);
		}

		private static string GetItemRequiresSkillLevelCraftingTooltipSignature(RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetItemRequiresSkillLevelCraftingTooltipText(pair);
		}

		private static string GetItemRequiresSkillLevelCraftingTooltipText(RecipeDataPair pair)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetItemRequiresSkillLevelApi(out ItemRequiresSkillLevelApi api) || api == null)
			{
				return "";
			}
			ItemData item = ((RecipeDataPair)(ref pair)).ItemData ?? ((RecipeDataPair)(ref pair)).Recipe?.m_item?.m_itemData;
			string itemRequiresSkillLevelRecipePrefabName = GetItemRequiresSkillLevelRecipePrefabName(pair);
			return api.GetTooltipText(item, itemRequiresSkillLevelRecipePrefabName, includeEquip: true, (Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null);
		}

		private static string GetItemRequiresSkillLevelRecipePrefabName(RecipeDataPair pair)
		{
			if ((Object)(object)((RecipeDataPair)(ref pair)).Recipe?.m_item == (Object)null)
			{
				return "";
			}
			return CleanPrefabName(((Object)((Component)((RecipeDataPair)(ref pair)).Recipe.m_item).gameObject).name);
		}

		private static string AppendDistinctTooltipLines(string tooltip, string extra)
		{
			if (string.IsNullOrWhiteSpace(extra))
			{
				return tooltip;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array = SplitTooltipLines(tooltip);
			for (int i = 0; i < array.Length; i++)
			{
				string text = StripRichText(array[i]).Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					hashSet.Add(text);
				}
			}
			StringBuilder stringBuilder = new StringBuilder(tooltip ?? "");
			array = SplitTooltipLines(extra);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (string.IsNullOrWhiteSpace(text2))
				{
					continue;
				}
				string text3 = StripRichText(text2).Trim();
				if (!string.IsNullOrWhiteSpace(text3) && hashSet.Add(text3))
				{
					if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != '\n')
					{
						stringBuilder.Append('\n');
					}
					stringBuilder.Append(text2);
				}
			}
			return stringBuilder.ToString();
		}

		private static bool TryGetItemRequiresSkillLevelApi(out ItemRequiresSkillLevelApi? api)
		{
			return TryGetCompatApi("WackyMole.ItemRequiresSkillLevel", "ItemRequiresSkillLevel tooltip", CompatRuntime.ItemRequiresSkillLevel, ItemRequiresSkillLevelApi.TryCreate, "ItemRequiresSkillLevel tooltip compatibility disabled", out api);
		}

		private static int CompareItemsForSort(ItemData a, ItemData b)
		{
			return CompareItemsForSort(a, b, GetInventoryItemSortKey(a), GetInventoryItemSortKey(b), 0, 0);
		}

		private static int CompareItemsForSort(ItemData a, ItemData b, SortKey aKey, SortKey bKey, int aOriginalIndex, int bOriginalIndex)
		{
			CraftingRecipeSortMode mode = _inventorySortMode?.Value ?? CraftingRecipeSortMode.GroupThenTier;
			int num = SortKeyComparerCore.Compare(aKey, bKey, mode);
			if (num == 0)
			{
				num = -a.m_quality.CompareTo(b.m_quality);
			}
			if (num == 0)
			{
				num = -a.m_stack.CompareTo(b.m_stack);
			}
			if (num == 0)
			{
				num = aOriginalIndex.CompareTo(bOriginalIndex);
			}
			return num;
		}

		private static int GetInventoryItemResourceTier(ItemData item)
		{
			if (ResourceTierByToken.Count == 0)
			{
				return 0;
			}
			int num = int.MinValue;
			foreach (string itemIdentityToken in GetItemIdentityTokens(item))
			{
				string key = NormalizeResourceToken(itemIdentityToken);
				if (ResourceTierByToken.TryGetValue(key, out var value))
				{
					num = Mathf.Max(num, value);
				}
			}
			Recipe val = FindCraftingRecipeForItem(item);
			if ((Object)(object)val != (Object)null)
			{
				num = Mathf.Max(num, GetCraftingRecipeResourceTier(val));
			}
			return num;
		}

		private static Recipe? FindCraftingRecipeForItem(ItemData item)
		{
			if (item?.m_shared == null || ObjectDB.instance?.m_recipes == null)
			{
				return null;
			}
			EnsureRecipeOutputLookupCache();
			foreach (string itemRecipeLookupToken in GetItemRecipeLookupTokens(item))
			{
				if (InventorySort.RecipeOutputLookupCache.TryGetValue(itemRecipeLookupToken, out Recipe value))
				{
					return value;
				}
			}
			return null;
		}

		private static string GetRecipeOutputLookupSignature()
		{
			ObjectDB instance = ObjectDB.instance;
			if (IsUnityNull((Object?)(object)instance) || instance.m_recipes == null)
			{
				return "none";
			}
			int num = 17;
			num = num * 31 + ((Object)instance).GetInstanceID();
			num = num * 31 + instance.m_recipes.Count;
			foreach (Recipe recipe in instance.m_recipes)
			{
				if (!((Object)(object)recipe == (Object)null))
				{
					num = num * 31 + ((Object)recipe).GetInstanceID();
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(((Object)recipe).name ?? "");
					num = num * 31 + (((Object)(object)recipe.m_item != (Object)null) ? ((Object)recipe.m_item).GetInstanceID() : 0);
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(((Object)(object)recipe.m_item != (Object)null) ? (((Object)recipe.m_item).name ?? "") : "");
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(recipe.m_item?.m_itemData?.m_shared?.m_name ?? "");
				}
			}
			return num.ToString();
		}

		private static void EnsureRecipeOutputLookupCache()
		{
			string recipeOutputLookupSignature = GetRecipeOutputLookupSignature();
			if (string.Equals(InventorySort.RecipeOutputLookupSignature, recipeOutputLookupSignature, StringComparison.Ordinal))
			{
				return;
			}
			InventorySort.RecipeOutputLookupCache.Clear();
			InventorySort.RecipeOutputLookupSignature = recipeOutputLookupSignature;
			if (ObjectDB.instance?.m_recipes == null)
			{
				return;
			}
			foreach (Recipe recipe in ObjectDB.instance.m_recipes)
			{
				AddRecipeOutputLookup(recipe);
			}
		}

		private static void AddRecipeOutputLookup(Recipe? recipe)
		{
			if (!((Object)(object)recipe?.m_item == (Object)null) && recipe.m_item.m_itemData?.m_shared != null)
			{
				ItemData itemData = recipe.m_item.m_itemData;
				AddRecipeOutputLookupToken("prefab", GetItemPrefabName(itemData), recipe);
				AddRecipeOutputLookupToken("prefab", CleanPrefabName(((Object)recipe.m_item).name), recipe);
				AddRecipeOutputLookupToken("name", itemData.m_shared.m_name, recipe);
			}
		}

		private static void AddRecipeOutputLookupToken(string kind, string? token, Recipe recipe)
		{
			if (!string.IsNullOrWhiteSpace(token))
			{
				string text = CleanPrefabName(token);
				string recipeOutputLookupKey = GetRecipeOutputLookupKey(kind, text);
				if (!string.IsNullOrWhiteSpace(text) && !InventorySort.RecipeOutputLookupCache.ContainsKey(recipeOutputLookupKey))
				{
					InventorySort.RecipeOutputLookupCache[recipeOutputLookupKey] = recipe;
				}
			}
		}

		private static IEnumerable<string> GetItemRecipeLookupTokens(ItemData item)
		{
			string itemPrefabName = GetItemPrefabName(item);
			string sharedName = item.m_shared.m_name ?? "";
			if (!string.IsNullOrWhiteSpace(itemPrefabName))
			{
				yield return GetRecipeOutputLookupKey("prefab", itemPrefabName);
			}
			if (!string.IsNullOrWhiteSpace(sharedName))
			{
				yield return GetRecipeOutputLookupKey("name", sharedName);
			}
		}

		private static string GetRecipeOutputLookupKey(string kind, string token)
		{
			return kind + ":" + CleanPrefabName(token);
		}

		private static void ClearInventorySortCaches()
		{
			InventorySort.RecipeOutputLookupCache.Clear();
			InventorySort.RecipeOutputLookupSignature = "";
		}

		private static string GetLocalizedItemName(ItemData item)
		{
			string text = item?.m_shared?.m_name ?? "";
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		private static void AddJewelcraftingSlot(YamlSlot? yamlSlot, string slotId)
		{
			if (!HasJewelcraftingActive)
			{
				return;
			}
			string a = NormalizeSlotId(slotId);
			if (string.Equals(a, "jewelcrafting.necklace", StringComparison.OrdinalIgnoreCase))
			{
				if (IsJewelcraftingNecklaceSlotEnabled() && SlotDefinitions.All((SlotDefinition slot) => slot.Id != "jewelcrafting.necklace"))
				{
					string name = ((yamlSlot == null || string.IsNullOrWhiteSpace(yamlSlot.Name)) ? "Necklace" : yamlSlot.Name.Trim());
					SlotDefinitions.Add(new SlotDefinition("jewelcrafting.necklace", name, SlotKind.CustomEquipment, IsJewelcraftingNecklaceItem));
				}
			}
			else if (string.Equals(a, "jewelcrafting.ring", StringComparison.OrdinalIgnoreCase) && IsJewelcraftingRingSlotEnabled() && SlotDefinitions.All((SlotDefinition slot) => slot.Id != "jewelcrafting.ring"))
			{
				string name2 = ((yamlSlot == null || string.IsNullOrWhiteSpace(yamlSlot.Name)) ? "Ring" : yamlSlot.Name.Trim());
				SlotDefinitions.Add(new SlotDefinition("jewelcrafting.ring", name2, SlotKind.CustomEquipment, IsJewelcraftingRingItem));
			}
		}

		private static bool IsJewelcraftingRingSlotEnabled()
		{
			if (TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi api) && api != null)
			{
				return api.IsRingEnabled();
			}
			return false;
		}

		private static bool IsJewelcraftingNecklaceSlotEnabled()
		{
			if (TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi api) && api != null)
			{
				return api.IsNecklaceEnabled();
			}
			return false;
		}

		private static bool IsJewelcraftingWisplightGemEnabled()
		{
			if (TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi api) && api != null)
			{
				return api.IsWisplightGemEnabled();
			}
			return false;
		}

		private static bool IsJewelcraftingWishboneGemEnabled()
		{
			if (TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi api) && api != null)
			{
				return api.IsWishboneGemEnabled();
			}
			return false;
		}

		private static bool ShouldSuppressYamlSlotForJewelcraftingGem(string slotId)
		{
			if (!HasJewelcraftingActive || string.IsNullOrWhiteSpace(slotId))
			{
				return false;
			}
			if (!string.Equals(slotId, "demister", StringComparison.OrdinalIgnoreCase))
			{
				if (string.Equals(slotId, "wishbone", StringComparison.OrdinalIgnoreCase))
				{
					return IsJewelcraftingWishboneGemEnabled();
				}
				return false;
			}
			return IsJewelcraftingWisplightGemEnabled();
		}

		private static bool IsJewelcraftingRingItem(ItemData? item)
		{
			return IsJewelcraftingJewelryItem(item, "JC_Ring_", "$jc_ring_", "jewelcrafting.ring");
		}

		private static bool IsJewelcraftingNecklaceItem(ItemData? item)
		{
			return IsJewelcraftingJewelryItem(item, "JC_Necklace_", "$jc_necklace_", "jewelcrafting.necklace");
		}

		private static bool IsJewelcraftingDedicatedJewelryItem(ItemData? item)
		{
			if (!IsJewelcraftingRingSlotEnabled() || !IsJewelcraftingRingItem(item))
			{
				if (IsJewelcraftingNecklaceSlotEnabled())
				{
					return IsJewelcraftingNecklaceItem(item);
				}
				return false;
			}
			return true;
		}

		private static bool IsJewelcraftingUtilityGemBlocked(ItemData? item)
		{
			if (!HasJewelcraftingActive || item?.m_shared == null)
			{
				return false;
			}
			if (!IsJewelcraftingWisplightGemEnabled() || !ItemMatchesExactPrefabOrName(item, "Demister"))
			{
				if (IsJewelcraftingWishboneGemEnabled())
				{
					return ItemMatchesExactPrefabOrName(item, "Wishbone");
				}
				return false;
			}
			return true;
		}

		private static bool IsJewelcraftingUtilityGemBlockedForSlot(ItemData? item, SlotDefinition? slot)
		{
			if (slot != null && slot.Kind != SlotKind.Quick)
			{
				return IsJewelcraftingUtilityGemBlocked(item);
			}
			return false;
		}

		private static bool TryBlockJewelcraftingUtilityGemEquip(Humanoid humanoid, ItemData item, ref bool result)
		{
			if ((Object)(object)humanoid != (Object)(object)Player.m_localPlayer || !IsJewelcraftingUtilityGemBlocked(item))
			{
				return false;
			}
			result = false;
			ShowJewelcraftingCannotEquipGemMessage(humanoid);
			return true;
		}

		private static void ShowJewelcraftingCannotEquipGemMessage(Humanoid humanoid)
		{
			if (humanoid != null)
			{
				((Character)humanoid).Message((MessageType)2, "$jc_cannot_equip_gem", 0, (Sprite)null);
			}
		}

		internal static bool TryOpenJewelcraftingSocketContainerFromInventorySlotsSlot(InventoryGui gui)
		{
			if (!HasJewelcraftingActive || (Object)(object)gui == (Object)null || (Object)(object)gui.m_playerGrid == (Object)null || !InventoryGui.IsVisible() || !IsJewelcraftingSocketInteractPressed() || !TryGetJewelcraftingGemApi(out JewelcraftingGemApi api) || api == null || !TryGetJewelcraftingSpecialSlotItemUnderMouse(gui.m_playerGrid, out ItemData item) || item == null || !api.CanOpenSocketContainerFromInventory(item, IsJewelcraftingGemcutterStationActive()))
			{
				return false;
			}
			return api.TryOpenSocketContainer(gui, item);
		}

		private static bool IsJewelcraftingSocketInteractPressed()
		{
			if (!ZInput.GetButtonDown("Use"))
			{
				return ZInput.GetButtonDown("JoyUse");
			}
			return true;
		}

		private static bool TryGetJewelcraftingSpecialSlotItemUnderMouse(InventoryGrid grid, out ItemData? item)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			item = null;
			Inventory inventory = grid.m_inventory;
			if (inventory == null || grid.m_elements == null)
			{
				return false;
			}
			int width = inventory.GetWidth();
			if (width <= 0)
			{
				return false;
			}
			int num = Math.Min(grid.m_elements.Count, width * Math.Max(0, inventory.GetHeight()));
			Vector2i pos = default(Vector2i);
			for (int i = 0; i < num; i++)
			{
				Element val = grid.m_elements[i];
				if (IsUnityNull((Object?)(object)val?.m_go) || !val.m_go.activeInHierarchy)
				{
					continue;
				}
				int num2 = i / width;
				int num3 = i - num2 * width;
				((Vector2i)(ref pos))..ctor(num3, num2);
				if (!TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot) || slot == null || slot.Kind == SlotKind.Quick)
				{
					continue;
				}
				Transform transform = val.m_go.transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val2 != null && RectContainsScreenMouse(val2))
				{
					item = inventory.GetItemAt(num3, num2);
					if (item?.m_shared != null)
					{
						return true;
					}
				}
			}
			item = null;
			return false;
		}

		private static bool RectContainsScreenMouse(RectTransform rect)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = ((Component)rect).GetComponentInParent<Canvas>();
			Camera val = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
			return RectTransformUtility.RectangleContainsScreenPoint(rect, Vector2.op_Implicit(Input.mousePosition), val);
		}

		private static bool IsJewelcraftingJewelryItem(ItemData? item, string prefabPrefix, string sharedNamePrefix, string slotId)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			if ((item.m_shared.m_name ?? "").StartsWith(sharedNamePrefix, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (GetItemPrefabName(item).StartsWith(prefabPrefix, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			List<string> slotItems = GetSlotItems(GetYamlSlot(slotId));
			if (slotItems.Count > 0)
			{
				return ItemMatchesSlotItems(item, slotItems);
			}
			return false;
		}

		private static void InitializeJewelcraftingSlotCompatibility()
		{
			if (TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi _))
			{
				CaptureJewelcraftingSlotConfigState();
			}
		}

		private static bool TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting slots", CompatRuntime.JewelcraftingSlot, JewelcraftingSlotApi.TryCreate, "Jewelcrafting slot compatibility disabled", out api);
		}

		private static void CaptureJewelcraftingSlotConfigState()
		{
			_lastJewelcraftingRingSlotEnabled = IsJewelcraftingRingSlotEnabled();
			_lastJewelcraftingNecklaceSlotEnabled = IsJewelcraftingNecklaceSlotEnabled();
			_lastJewelcraftingWisplightGemEnabled = IsJewelcraftingWisplightGemEnabled();
			_lastJewelcraftingWishboneGemEnabled = IsJewelcraftingWishboneGemEnabled();
			_jewelcraftingSlotStateInitialized = true;
		}

		private static void RefreshJewelcraftingSlotDefinitionsIfNeeded(Player? player)
		{
			if (!HasJewelcraftingActive)
			{
				return;
			}
			bool flag = IsJewelcraftingRingSlotEnabled();
			bool flag2 = IsJewelcraftingNecklaceSlotEnabled();
			bool flag3 = IsJewelcraftingWisplightGemEnabled();
			bool flag4 = IsJewelcraftingWishboneGemEnabled();
			if (!_jewelcraftingSlotStateInitialized)
			{
				_lastJewelcraftingRingSlotEnabled = flag;
				_lastJewelcraftingNecklaceSlotEnabled = flag2;
				_lastJewelcraftingWisplightGemEnabled = flag3;
				_lastJewelcraftingWishboneGemEnabled = flag4;
				_jewelcraftingSlotStateInitialized = true;
			}
			else if (flag != _lastJewelcraftingRingSlotEnabled || flag2 != _lastJewelcraftingNecklaceSlotEnabled || flag3 != _lastJewelcraftingWisplightGemEnabled || flag4 != _lastJewelcraftingWishboneGemEnabled)
			{
				_lastJewelcraftingRingSlotEnabled = flag;
				_lastJewelcraftingNecklaceSlotEnabled = flag2;
				_lastJewelcraftingWisplightGemEnabled = flag3;
				_lastJewelcraftingWishboneGemEnabled = flag4;
				RebuildSlotDefinitions();
				if (!IsUnityNull((Object?)(object)player))
				{
					EnsureInventoryState(player, InventoryStateEnsureReason.JewelcraftingSlotRefresh);
					UpdateCustomEquipmentVisuals(player);
				}
			}
		}

		private static void SuppressJewelcraftingNativeVisualSlots(Player player, Inventory inventory)
		{
			if (!HasJewelcraftingActive || (Object)(object)player == (Object)null || inventory == null || IsUnityNull((Object?)(object)((Humanoid)player).m_visEquipment))
			{
				return;
			}
			bool flag = SlotDefinitions.Any((SlotDefinition slot) => slot.Id == "jewelcrafting.ring" && slot.Kind == SlotKind.CustomEquipment) && IsJewelcraftingRingSlotEnabled();
			bool flag2 = SlotDefinitions.Any((SlotDefinition slot) => slot.Id == "jewelcrafting.necklace" && slot.Kind == SlotKind.CustomEquipment) && IsJewelcraftingNecklaceSlotEnabled();
			if ((flag || flag2) && TryGetJewelcraftingVisual(player, out object visual))
			{
				if (flag)
				{
					ClearJewelcraftingVisualSlot(visual, isRing: true);
				}
				if (flag2)
				{
					ClearJewelcraftingVisualSlot(visual, isRing: false);
				}
			}
		}

		private static bool TryGetJewelcraftingVisual(Player player, out object? visual)
		{
			visual = null;
			if (!TryGetJewelcraftingVisualApi(out JewelcraftingVisualApi api) || api == null || IsUnityNull((Object?)(object)((Humanoid)(player?)).m_visEquipment))
			{
				return false;
			}
			return api.TryGetVisual(((Humanoid)player).m_visEquipment, out visual);
		}

		private static void ClearJewelcraftingVisualSlot(object visual, bool isRing)
		{
			try
			{
				CompatRuntime.JewelcraftingVisual.Api?.ClearSlot(visual, isRing);
			}
			catch (Exception)
			{
			}
		}

		private static bool TryGetJewelcraftingVisualApi(out JewelcraftingVisualApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting visuals", CompatRuntime.JewelcraftingVisual, JewelcraftingVisualApi.TryCreate, "Jewelcrafting visual slot suppression disabled", out api);
		}

		internal static bool IsJewelcraftingJewelryEquipped(Player? player, string? prefabName)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrWhiteSpace(prefabName) || !HasJewelcraftingActive)
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName);
			foreach (ItemData customEquippedItem in GetCustomEquippedItems(player))
			{
				if (customEquippedItem?.m_shared != null && customEquippedItem.m_customData.TryGetValue("InventorySlotsSlotId", out var value) && (value == "jewelcrafting.ring" || value == "jewelcrafting.necklace"))
				{
					string itemPrefabName = GetItemPrefabName(customEquippedItem);
					if (!string.IsNullOrWhiteSpace(itemPrefabName) && StringExtensionMethods.GetStableHashCode(itemPrefabName) == stableHashCode)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static void SuppressJewelcraftingCraftingSocketUiForRedesign(InventoryGui? gui, bool includeSocketTab = false)
		{
			if ((Object)(object)gui == (Object)null || !ShouldShowCraftingPanelRedesign(gui) || (!includeSocketTab && IsJewelcraftingSocketTabActive(gui)) || !TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi api) || api == null)
			{
				return;
			}
			Array socketIcons = api.GetSocketIcons();
			if (socketIcons != null)
			{
				foreach (object item in socketIcons)
				{
					GameObject val = (GameObject)((item is GameObject) ? item : null);
					if (val != null && !IsUnityNull((Object?)(object)val))
					{
						HideJewelcraftingCraftingSocketObject(val);
					}
				}
			}
			Button socketingButton = api.GetSocketingButton();
			if (socketingButton != null && !IsUnityNull((Object?)(object)socketingButton))
			{
				HideJewelcraftingCraftingSocketObject(((Component)socketingButton).gameObject);
			}
		}

		private static bool IsJewelcraftingGemcutterStationActive()
		{
			if (!HasJewelcraftingActive || IsDedicatedServer || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
			if ((Object)(object)currentCraftingStation == (Object)null || IsUnityNull((Object?)(object)currentCraftingStation) || (Object)(object)((Component)currentCraftingStation).gameObject == (Object)null)
			{
				return false;
			}
			if (!string.Equals(Utils.GetPrefabName(((Component)currentCraftingStation).gameObject), "op_transmution_table", StringComparison.OrdinalIgnoreCase))
			{
				return ((Object)currentCraftingStation).name.StartsWith("op_transmution_table", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsJewelcraftingGemCuttingRecipe(Recipe? recipe)
		{
			if ((Object)(object)recipe == (Object)null || recipe.m_resources == null || recipe.m_resources.Length == 0 || recipe.m_resources[0] == null || recipe.m_resources[0].m_amount != recipe.m_amount || !TryGetJewelcraftingGemCuttingApi(out JewelcraftingGemCuttingApi api) || api == null)
			{
				return false;
			}
			return api.IsGemCuttingRecipe(recipe);
		}

		private static bool ShouldHideJewelcraftingSocketRequirements(RecipeDataPair pair)
		{
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				return IsJewelcraftingSocketCostItemMayBreak();
			}
			return false;
		}

		private static bool IsJewelcraftingSocketCostItemMayBreak()
		{
			if (TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi api) && api != null)
			{
				return string.Equals(api.GetSocketCostMode(), "ItemMayBreak", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static bool TryGetJewelcraftingGemCuttingApi(out JewelcraftingGemCuttingApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting gem cutting", CompatRuntime.JewelcraftingGemCutting, JewelcraftingGemCuttingApi.TryCreate, "Jewelcrafting gem cutting compatibility disabled", out api);
		}

		private static void HideJewelcraftingCraftingSocketObject(GameObject go)
		{
			if (go.activeSelf)
			{
				go.SetActive(false);
				Graphic[] componentsInChildren = go.GetComponentsInChildren<Graphic>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].raycastTarget = false;
				}
			}
		}

		private static void RestoreJewelcraftingCraftingSocketUiForVanilla(InventoryGui? gui)
		{
			if (!((Object)(object)gui == (Object)null) && (IsJewelcraftingGemcutterStationActive() || IsJewelcraftingSocketTabActive(gui)) && TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi api) && api != null)
			{
				Button socketingButton = api.GetSocketingButton();
				if (socketingButton != null && !IsUnityNull((Object?)(object)socketingButton))
				{
					RestoreJewelcraftingCraftingSocketButton(socketingButton);
				}
			}
		}

		private static void RestoreJewelcraftingCraftingSocketButton(Button button)
		{
			if ((Object)(object)((Selectable)button).targetGraphic != (Object)null && !IsUnityNull((Object?)(object)((Selectable)button).targetGraphic))
			{
				((Selectable)button).targetGraphic.raycastTarget = true;
			}
			Graphic[] componentsInChildren = ((Component)button).gameObject.GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].raycastTarget = true;
			}
		}

		private static bool TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting crafting socket UI", CompatRuntime.JewelcraftingCraftingSocketUi, JewelcraftingCraftingSocketUiApi.TryCreate, "Jewelcrafting crafting socket UI compatibility disabled", out api);
		}

		internal static bool TryGetJewelcraftingApiIsJewelryEquippedMethod(out MethodBase? method)
		{
			method = null;
			if (!TryGetJewelcraftingSlotApi(out JewelcraftingSlotApi api) || api == null)
			{
				return false;
			}
			return api.TryGetIsJewelryEquippedMethod(out method);
		}

		private static bool IsJewelcraftingCraftingRedesignTab(InventoryGui gui)
		{
			return IsJewelcraftingSocketTabActive(gui);
		}

		private static void EnsureJewelcraftingCraftingPanelVisible(InventoryGui gui)
		{
			if (IsJewelcraftingSocketTabActive(gui) && (Object)(object)gui.m_crafting != (Object)null && !((Component)gui.m_crafting).gameObject.activeSelf)
			{
				((Component)gui.m_crafting).gameObject.SetActive(true);
			}
		}

		private static void ApplyJewelcraftingCraftingRedesignVisibility(InventoryGui gui)
		{
			SetCraftingVanillaDetailVisible(gui, visible: false);
			_craftingVanillaDetailHidden = true;
			EnsureCraftingVanillaPanelBackgroundsHidden(gui);
			SuppressJewelcraftingCraftingSocketUiForRedesign(gui, includeSocketTab: true);
		}

		private static bool ShouldFinalizeJewelcraftingCraftingSocketSuppression(bool jewelcraftingSocketTab, bool firstApply, CraftingPanelUpdateReason reason, bool viewChanged)
		{
			if (!jewelcraftingSocketTab)
			{
				return firstApply || reason != CraftingPanelUpdateReason.FrameTick || viewChanged;
			}
			return false;
		}

		private static bool ShouldPreserveJewelcraftingForeignCraftingControls(InventoryGui gui)
		{
			if (!IsVneiCraftingTabActive(gui))
			{
				if (!IsJewelcraftingGemcutterStationActive())
				{
					return IsJewelcraftingSocketTabActive(gui);
				}
				return true;
			}
			return false;
		}

		private static bool IsJewelcraftingSocketTabActive(InventoryGui? gui)
		{
			return GetJewelcraftingSocketTabState(gui) == JewelcraftingSocketTabState.Selected;
		}

		private static JewelcraftingSocketTabState GetJewelcraftingSocketTabState(InventoryGui? gui)
		{
			if (!HasJewelcraftingActive || IsDedicatedServer || (Object)(object)gui == (Object)null || !TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi api) || api == null)
			{
				return JewelcraftingSocketTabState.Unavailable;
			}
			if (IsCraftingPrimaryTabSelected(gui))
			{
				return JewelcraftingSocketTabState.PrimaryCraftingTab;
			}
			if (api.IsSocketTabOpen())
			{
				return JewelcraftingSocketTabState.Selected;
			}
			Button jewelcraftingSocketTabButton = GetJewelcraftingSocketTabButton(api);
			if ((Object)(object)jewelcraftingSocketTabButton == (Object)null || IsUnityNull((Object?)(object)jewelcraftingSocketTabButton) || !((Component)jewelcraftingSocketTabButton).gameObject.activeInHierarchy)
			{
				return JewelcraftingSocketTabState.Closed;
			}
			if (((Selectable)jewelcraftingSocketTabButton).interactable)
			{
				return JewelcraftingSocketTabState.Closed;
			}
			return JewelcraftingSocketTabState.Selected;
		}

		private static Button? GetJewelcraftingSocketTabButton(JewelcraftingCraftingSocketUiApi api)
		{
			Transform socketTab = api.GetSocketTab();
			if ((Object)(object)socketTab == (Object)null || IsUnityNull((Object?)(object)socketTab))
			{
				return null;
			}
			return ((Component)socketTab).GetComponent<Button>();
		}

		internal static void NormalizeJewelcraftingSocketTabForPrimaryCraftingTab(InventoryGui? gui)
		{
			if (HasJewelcraftingActive && !IsDedicatedServer && !((Object)(object)gui == (Object)null) && IsJewelcraftingGemcutterStationActive() && IsCraftingPrimaryTabSelected(gui) && TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi api) && api != null)
			{
				Button jewelcraftingSocketTabButton = GetJewelcraftingSocketTabButton(api);
				if ((Object)(object)jewelcraftingSocketTabButton != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSocketTabButton) && !((Selectable)jewelcraftingSocketTabButton).interactable)
				{
					((Selectable)jewelcraftingSocketTabButton).interactable = true;
				}
			}
		}

		private static bool IsCraftingPrimaryTabSelected(InventoryGui? gui)
		{
			if (!IsCraftingCraftTabSelected(gui))
			{
				return IsCraftingUpgradeTabSelected(gui);
			}
			return true;
		}

		private static bool IsCraftingCraftTabSelected(InventoryGui? gui)
		{
			if ((Object)(object)gui?.m_tabCraft != (Object)null && !IsUnityNull((Object?)(object)gui.m_tabCraft))
			{
				return !((Selectable)gui.m_tabCraft).interactable;
			}
			return false;
		}

		private static bool IsCraftingUpgradeTabSelected(InventoryGui? gui)
		{
			if ((Object)(object)gui?.m_tabUpgrade != (Object)null && !IsUnityNull((Object?)(object)gui.m_tabUpgrade))
			{
				return !((Selectable)gui.m_tabUpgrade).interactable;
			}
			return false;
		}

		private static bool IsJewelcraftingSocketTabButton(Button button)
		{
			if (!HasJewelcraftingActive || IsDedicatedServer || (Object)(object)button == (Object)null || IsUnityNull((Object?)(object)button) || !TryGetJewelcraftingCraftingSocketUiApi(out JewelcraftingCraftingSocketUiApi api) || api == null)
			{
				return false;
			}
			Button jewelcraftingSocketTabButton = GetJewelcraftingSocketTabButton(api);
			if ((Object)(object)jewelcraftingSocketTabButton != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSocketTabButton))
			{
				return (Object)(object)button == (Object)(object)jewelcraftingSocketTabButton;
			}
			return false;
		}

		private static void RefreshExternalEquipmentEffects(Player? player)
		{
			ResetEpicLootEquipmentEffectCache(player);
			RecalculateJewelcraftingEffects(player);
		}

		private static void RecalculateJewelcraftingEffects(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !IsUnityNull((Object?)(object)player) && !player.m_isLoading && HasJewelcraftingActive && TryGetJewelcraftingEffectApi(out JewelcraftingEffectApi api))
			{
				api?.Recalculate(player);
			}
		}

		private static bool TryGetJewelcraftingEffectApi(out JewelcraftingEffectApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting effects", CompatRuntime.JewelcraftingEffect, JewelcraftingEffectApi.TryCreate, "Jewelcrafting equipment effect refresh disabled", out api);
		}

		private static bool UpdateCraftingGemIconRow(RectTransform panel, RecipeDataPair pair, ref RectTransform? cachedRow, Vector2 bottomLeft, float iconSize, float gap)
		{
			//IL_0000: 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)
			ItemData craftingJewelcraftingTooltipItem = GetCraftingJewelcraftingTooltipItem(pair);
			List<JewelcraftingGemIconData> gems = ((craftingJewelcraftingTooltipItem?.m_shared != null) ? GetJewelcraftingGemIconData(craftingJewelcraftingTooltipItem) : new List<JewelcraftingGemIconData>());
			return UpdateCraftingGemIconRow(panel, gems, ref cachedRow, bottomLeft, iconSize, gap);
		}

		private static bool UpdateCraftingGemIconRow(RectTransform panel, List<JewelcraftingGemIconData> gems, ref RectTransform? cachedRow, Vector2 bottomLeft, float iconSize, float gap, bool enableIconTooltips = true)
		{
			//IL_0023: 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_004d: 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_007e: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_012e: 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)
			if (gems.Count == 0)
			{
				HideCraftingGemIconRow(ref cachedRow);
				return false;
			}
			RectTransform val = EnsureCraftingGemIconRow(panel, ref cachedRow);
			val.anchorMin = new Vector2(0f, 0f);
			val.anchorMax = new Vector2(0f, 0f);
			val.pivot = new Vector2(0f, 0f);
			val.anchoredPosition = bottomLeft;
			val.sizeDelta = new Vector2((float)gems.Count * iconSize + (float)Mathf.Max(0, gems.Count - 1) * gap, iconSize);
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			((Component)val).gameObject.SetActive(true);
			for (int i = 0; i < gems.Count; i++)
			{
				RectTransform val2 = EnsureCraftingGemIcon(val, i);
				val2.anchorMin = new Vector2(0f, 0.5f);
				val2.anchorMax = new Vector2(0f, 0.5f);
				val2.pivot = new Vector2(0f, 0.5f);
				val2.anchoredPosition = new Vector2((float)i * (iconSize + gap), iconSize * 0.5f);
				val2.sizeDelta = new Vector2(iconSize, iconSize);
				((Transform)val2).localScale = Vector3.one;
				((Transform)val2).localRotation = Quaternion.identity;
				((Component)val2).gameObject.SetActive(true);
				Image component = ((Component)val2).GetComponent<Image>();
				component.sprite = gems[i].Sprite;
				((Graphic)component).color = Color.white;
				component.preserveAspect = true;
				string displayName = (enableIconTooltips ? gems[i].DisplayName : "");
				if (enableIconTooltips && IsPinnedTooltipTransform((Transform?)(object)panel))
				{
					ConfigurePinnedGemIconTooltip(val2, displayName);
					continue;
				}
				((Graphic)component).raycastTarget = enableIconTooltips;
				ConfigureCraftingGemIconTooltip(val2, displayName);
			}
			for (int j = gems.Count; j < ((Transform)val).childCount; j++)
			{
				((Component)((Transform)val).GetChild(j)).gameObject.SetActive(false);
			}
			return true;
		}

		private static void HideCraftingGemIconRow(ref RectTransform? row)
		{
			if ((Object)(object)row != (Object)null && !IsUnityNull((Object?)(object)row))
			{
				((Component)row).gameObject.SetActive(false);
			}
		}

		private static RectTransform EnsureCraftingGemIconRow(RectTransform panel, ref RectTransform? cachedRow)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cachedRow != (Object)null && !IsUnityNull((Object?)(object)cachedRow) && (Object)(object)((Transform)cachedRow).parent == (Object)(object)panel)
			{
				return cachedRow;
			}
			if ((Object)(object)cachedRow != (Object)null && !IsUnityNull((Object?)(object)cachedRow))
			{
				((Component)cachedRow).gameObject.SetActive(false);
			}
			Transform val = ((Transform)panel).Find("InventorySlots_CraftingGemIconRow");
			cachedRow = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)cachedRow == (Object)null)
			{
				cachedRow = new GameObject("InventorySlots_CraftingGemIconRow", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)cachedRow).SetParent((Transform)(object)panel, false);
			}
			return cachedRow;
		}

		private static RectTransform EnsureCraftingGemIcon(RectTransform row, int index)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			string text = "GemIcon" + index;
			Transform val = ((Transform)row).Find(text);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = new GameObject(text, new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(UITooltip)
				}).GetComponent<RectTransform>();
				((Transform)val2).SetParent((Transform)(object)row, false);
			}
			else if ((Object)(object)((Component)val2).GetComponent<UITooltip>() == (Object)null)
			{
				((Component)val2).gameObject.AddComponent<UITooltip>();
			}
			return val2;
		}

		private static void ConfigureCraftingGemIconTooltip(RectTransform iconRect, string displayName)
		{
			//IL_0038: 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_0079: 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)
			ClearPinnedGemIconTooltip(iconRect);
			UITooltip val = ((Component)iconRect).GetComponent<UITooltip>() ?? ((Component)iconRect).gameObject.AddComponent<UITooltip>();
			EnsureTooltipPrefab(val);
			if (string.IsNullOrWhiteSpace(displayName))
			{
				val.Set("", "", (RectTransform)null, default(Vector2));
			}
			else
			{
				val.Set(displayName, "", ((Object)(object)InventoryGui.instance?.m_playerGrid != (Object)null) ? InventoryGui.instance.m_playerGrid.m_tooltipAnchor : null, default(Vector2));
			}
		}

		private static void ConfigurePinnedGemIconTooltip(RectTransform iconRect, string displayName)
		{
			Image component = ((Component)iconRect).GetComponent<Image>();
			if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
			{
				((Graphic)component).raycastTarget = false;
			}
			UITooltip component2 = ((Component)iconRect).GetComponent<UITooltip>();
			if ((Object)(object)component2 != (Object)null && !IsUnityNull((Object?)(object)component2))
			{
				component2.m_topic = "";
				component2.m_text = "";
				((Behaviour)component2).enabled = false;
			}
			(((Component)iconRect).GetComponent<PinnedGemIconTooltipTarget>() ?? ((Component)iconRect).gameObject.AddComponent<PinnedGemIconTooltipTarget>()).SetDisplayName(displayName);
			EnsurePinnedGemIconPanelHitTester(iconRect);
		}

		private static void ClearPinnedGemIconTooltip(RectTransform iconRect)
		{
			PinnedGemIconTooltipTarget component = ((Component)iconRect).GetComponent<PinnedGemIconTooltipTarget>();
			if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
			{
				component.SetDisplayName("");
			}
		}

		private static void EnsurePinnedGemIconPanelHitTester(RectTransform iconRect)
		{
			RectTransform val = FindPinnedTooltipRoot((Transform?)(object)iconRect);
			if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
			{
				(((Component)val).GetComponent<PinnedGemIconTooltipPanelHitTester>() ?? ((Component)val).gameObject.AddComponent<PinnedGemIconTooltipPanelHitTester>()).InvalidateTargets();
			}
		}

		private static RectTransform? FindPinnedTooltipRoot(Transform? transform)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				if (name.StartsWith("InventorySlots_InventoryPinnedTooltip_", StringComparison.Ordinal) || name.StartsWith("InventorySlots_CraftingPinnedTooltip_", StringComparison.Ordinal))
				{
					return (RectTransform?)(object)((val is RectTransform) ? val : null);
				}
				val = val.parent;
			}
			return null;
		}

		private static bool IsPinnedTooltipTransform(Transform? transform)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				if (name.StartsWith("InventorySlots_InventoryPinnedTooltip_", StringComparison.Ordinal) || name.StartsWith("InventorySlots_CraftingPinnedTooltip_", StringComparison.Ordinal))
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static List<JewelcraftingGemIconData> GetJewelcraftingGemIconData(ItemData item)
		{
			List<JewelcraftingGemIconData> list = new List<JewelcraftingGemIconData>();
			if (item?.m_shared == null || !TryGetJewelcraftingGemApi(out JewelcraftingGemApi api) || api == null)
			{
				return list;
			}
			try
			{
				if (!(api.GetGems(item) is IEnumerable enumerable))
				{
					return list;
				}
				foreach (object item2 in enumerable)
				{
					if (item2 != null)
					{
						api.TryGetGemIconData(item2, out Sprite sprite, out string prefabName);
						if (sprite == null)
						{
							sprite = GetJewelcraftingGemSprite(prefabName);
						}
						if ((Object)(object)sprite != (Object)null && !IsUnityNull((Object?)(object)sprite))
						{
							list.Add(new JewelcraftingGemIconData(sprite, GetJewelcraftingGemDisplayName(prefabName)));
						}
					}
				}
			}
			catch (Exception)
			{
			}
			if (list.Count == 0)
			{
				List<string> jewelcraftingSocketPrefabNamesFromCustomData = GetJewelcraftingSocketPrefabNamesFromCustomData(item);
				if (jewelcraftingSocketPrefabNamesFromCustomData.Count == 0 && TryGetJewelcraftingGemApi(out JewelcraftingGemApi api2) && api2 != null)
				{
					foreach (JewelcraftingSocketGemData openSocketGemDatum in api2.GetOpenSocketGemData(item))
					{
						if (openSocketGemDatum.HasGem)
						{
							jewelcraftingSocketPrefabNamesFromCustomData.Add(openSocketGemDatum.PrefabName);
						}
					}
					foreach (JewelcraftingSocketGemData socketGemDatum in api2.GetSocketGemData(item))
					{
						if (socketGemDatum.HasGem)
						{
							jewelcraftingSocketPrefabNamesFromCustomData.Add(socketGemDatum.PrefabName);
						}
					}
				}
				foreach (string item3 in jewelcraftingSocketPrefabNamesFromCustomData)
				{
					Sprite jewelcraftingGemSprite = GetJewelcraftingGemSprite(item3);
					if ((Object)(object)jewelcraftingGemSprite != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingGemSprite))
					{
						list.Add(new JewelcraftingGemIconData(jewelcraftingGemSprite, GetJewelcraftingGemDisplayName(item3)));
					}
				}
			}
			return list;
		}

		private static bool TryGetJewelcraftingOpenSocketContainer(ItemData item, out ItemData? openItem, out Inventory? openInventory)
		{
			openItem = null;
			openInventory = null;
			if (item?.m_shared == null || !TryGetJewelcraftingGemApi(out JewelcraftingGemApi api) || api == null)
			{
				return false;
			}
			openItem = api.GetOpenSocketContainerItem();
			openInventory = api.GetOpenSocketContainerInventory();
			if (openItem?.m_shared == null || openInventory == null)
			{
				openItem = null;
				openInventory = null;
				return false;
			}
			if (!CanUseJewelcraftingOpenSocketContainerItem(item, openItem))
			{
				openItem = null;
				openInventory = null;
				return false;
			}
			return true;
		}

		private static bool CanUseJewelcraftingOpenSocketContainerItem(ItemData item, ItemData openItem)
		{
			if (item == openItem)
			{
				return true;
			}
			if (item.m_shared == null || openItem.m_shared == null || !string.Equals(GetItemPrefabName(item), GetItemPrefabName(openItem), StringComparison.Ordinal) || !string.Equals(item.m_shared.m_name, openItem.m_shared.m_name, StringComparison.Ordinal) || item.m_variant != openItem.m_variant || item.m_quality != openItem.m_quality)
			{
				return false;
			}
			if (item.m_gridPos.x == openItem.m_gridPos.x)
			{
				return item.m_gridPos.y == openItem.m_gridPos.y;
			}
			return false;
		}

		private static string GetJewelcraftingOpenSocketInventorySignature(ItemData item)
		{
			if (!TryGetJewelcraftingOpenSocketContainer(item, out ItemData _, out Inventory openInventory) || openInventory == null)
			{
				return "";
			}
			List<string> list = new List<string> { openInventory.m_width + "x" + openInventory.m_height };
			foreach (ItemData item2 in openInventory.m_inventory)
			{
				if (item2?.m_shared != null)
				{
					list.Add(string.Join(":", item2.m_gridPos.x, item2.m_gridPos.y, GetItemPrefabName(item2), item2.m_stack, GetEquipmentSlotTooltipSignature(item2)));
				}
			}
			list.Sort(StringComparer.Ordinal);
			return string.Join(";", list);
		}

		private static Sprite? GetJewelcraftingGemSprite(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName);
			ItemDrop obj = (((Object)(object)itemPrefab != (Object)null && !IsUnityNull((Object?)(object)itemPrefab)) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if (obj == null)
			{
				return null;
			}
			ItemData itemData = obj.m_itemData;
			if (itemData == null)
			{
				return null;
			}
			return itemData.GetIcon();
		}

		private static List<string> GetJewelcraftingSocketPrefabNamesFromCustomData(ItemData item)
		{
			List<string> list = new List<string>();
			if (item.m_customData == null || item.m_customData.Count == 0)
			{
				return list;
			}
			foreach (KeyValuePair<string, string> customDatum in item.m_customData)
			{
				if (!IsJewelcraftingSocketDataKey(customDatum.Key) || string.IsNullOrWhiteSpace(customDatum.Value))
				{
					continue;
				}
				string[] array = customDatum.Value.Split(new char[1] { '|' })[0].Split(new char[1] { ',' });
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Split(new char[1] { ':' })[0].Trim();
					if (!string.IsNullOrWhiteSpace(text))
					{
						list.Add(text);
					}
				}
			}
			return list;
		}

		private static bool HasJewelcraftingPotentialCustomData(ItemData item)
		{
			if (item.m_customData == null || item.m_customData.Count == 0)
			{
				return false;
			}
			foreach (string key in item.m_customData.Keys)
			{
				if (key.IndexOf("Jewelcrafting.SocketSeed", StringComparison.OrdinalIgnoreCase) < 0 && IsJewelcraftingTooltipDataKey(key))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsJewelcraftingSocketDataKey(string key)
		{
			if (key.IndexOf("Jewelcrafting.Sockets", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.Box", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.SocketBag", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return key.IndexOf("Jewelcrafting.Frame", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static string GetJewelcraftingGemDisplayName(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return "";
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(prefabName) : null);
			string text = (((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val)) ? val.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_name ?? prefabName;
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		private static int FindMatchingJewelcraftingGemIcon(IReadOnlyList<JewelcraftingGemIconData> gems, bool[] used, Sprite sprite)
		{
			for (int i = 0; i < gems.Count; i++)
			{
				if (!used[i])
				{
					Sprite sprite2 = gems[i].Sprite;
					if ((Object)(object)sprite2 == (Object)(object)sprite || (!IsUnityNull((Object?)(object)sprite2) && string.Equals(((Object)sprite2).name, ((Object)sprite).name, StringComparison.Ordinal)))
					{
						return i;
					}
				}
			}
			return -1;
		}

		private static bool UpdateInventoryPinnedJewelcraftingTooltip(RectTransform panel, ItemData item, InventoryGrid? grid)
		{
			int num = Array.IndexOf(PinnedTooltips.Inventory.Panels, panel);
			if (num < 0 || num >= PinnedTooltips.Inventory.JewelcraftingTooltipRoots.Length)
			{
				return false;
			}
			return UpdateJewelcraftingTooltip(panel, item, ref PinnedTooltips.Inventory.JewelcraftingTooltipRoots[num], ShouldShowJewelcraftingInventoryInteract(grid));
		}

		private static bool UpdateCraftingJewelcraftingTooltip(RectTransform panel, RecipeDataPair pair, ref RectTransform? cachedRoot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ItemData craftingJewelcraftingTooltipItem = GetCraftingJewelcraftingTooltipItem(pair);
			if (craftingJewelcraftingTooltipItem?.m_shared == null)
			{
				if ((Object)(object)cachedRoot != (Object)null && !IsUnityNull((Object?)(object)cachedRoot))
				{
					((Component)cachedRoot).gameObject.SetActive(false);
				}
				return false;
			}
			return UpdateJewelcraftingTooltip(panel, craftingJewelcraftingTooltipItem, ref cachedRoot);
		}

		private static ItemData? GetCraftingJewelcraftingTooltipItem(RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetCraftingRecipeItemData(pair);
		}

		private static void HideJewelcraftingTooltipRoot(ref RectTransform? root)
		{
			if ((Object)(object)root != (Object)null && !IsUnityNull((Object?)(object)root))
			{
				JewelcraftingTooltipLayoutCache component = ((Component)root).GetComponent<JewelcraftingTooltipLayoutCache>();
				if ((Object)(object)component != (Object)null)
				{
					component.Visible = false;
					component.HasResolvedSocketGems = false;
					component.RowlessRefreshAttempts = 0;
				}
				((Component)root).gameObject.SetActive(false);
			}
		}

		private static void SetInventoryPinnedTooltipTextReservedSpace(RectTransform panel, bool reserveJewelcraftingSpace)
		{
			//IL_0059: 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)
			TMP_Text val = FindPinnedTooltipText(panel);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? val.rectTransform : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				EnsurePinnedTooltipTextScrollContent(panel, val);
				val.overflowMode = (TextOverflowModes)0;
				int num = Array.IndexOf(PinnedTooltips.Inventory.Panels, panel);
				if (num >= 0)
				{
					ApplyPinnedTooltipDynamicTextLayout(panel, val, num, InventoryPinnedTooltipFixedOffset, 102f, 18f, 0f, resetScroll: false);
				}
			}
		}

		private static void SetCraftingPinnedTooltipTextReservedSpace(RectTransform panel, bool reserveGemRowSpace)
		{
			//IL_0069: 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)
			TMP_Text val = FindPinnedTooltipText(panel);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? val.rectTransform : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				EnsurePinnedTooltipTextScrollContent(panel, val);
				val.overflowMode = (TextOverflowModes)0;
				int num = Array.IndexOf(PinnedTooltips.Crafting.Panels, panel);
				if (num >= 0)
				{
					float bottomReserved = (reserveGemRowSpace ? 124f : 92f);
					ApplyPinnedTooltipDynamicTextLayout(panel, val, num, CraftingPinnedTooltipFixedOffset, 102f, bottomReserved, GetPinnedTooltipMaxTextViewportHeight(panel, 102f, bottomReserved), resetScroll: false);
				}
			}
		}

		private static void RefreshJewelcraftingPinnedTooltips()
		{
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			if (!HasJewelcraftingActive)
			{
				return;
			}
			bool flag = false;
			for (int i = 0; i < PinnedTooltips.Inventory.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeInHierarchy && PinnedTooltips.Inventory.Items[i]?.m_shared != null)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				for (int j = 0; j < PinnedTooltips.Crafting.Panels.Length; j++)
				{
					RectTransform val2 = PinnedTooltips.Crafting.Panels[j];
					if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2) && ((Component)val2).gameObject.activeInHierarchy && PinnedTooltips.Crafting.RecipeIndices[j] >= 0)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				return;
			}
			for (int k = 0; k < PinnedTooltips.Inventory.Panels.Length; k++)
			{
				RectTransform val3 = PinnedTooltips.Inventory.Panels[k];
				ItemData liveInventoryPinnedTooltipItem = GetLiveInventoryPinnedTooltipItem(k);
				if (!((Object)(object)val3 == (Object)null) && !IsUnityNull((Object?)(object)val3) && ((Component)val3).gameObject.activeInHierarchy && liveInventoryPinnedTooltipItem?.m_shared != null)
				{
					bool reserveJewelcraftingSpace = UpdateInventoryPinnedJewelcraftingTooltip(val3, liveInventoryPinnedTooltipItem, PinnedTooltips.Inventory.Grids[k]);
					SetInventoryPinnedTooltipTextReservedSpace(val3, reserveJewelcraftingSpace);
				}
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance))
			{
				return;
			}
			for (int l = 0; l < PinnedTooltips.Crafting.Panels.Length; l++)
			{
				RectTransform val4 = PinnedTooltips.Crafting.Panels[l];
				int num = PinnedTooltips.Crafting.RecipeIndices[l];
				if (!((Object)(object)val4 == (Object)null) && !IsUnityNull((Object?)(object)val4) && ((Component)val4).gameObject.activeInHierarchy && num >= 0 && TryGetCraftingRecipePair(instance, num, out var pair))
				{
					bool reserveGemRowSpace = !UpdateCraftingJewelcraftingTooltip(val4, pair, ref PinnedTooltips.Crafting.JewelcraftingTooltipRoots[l]) && (Object)(object)PinnedTooltips.Crafting.GemIconRows[l] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Crafting.GemIconRows[l]) && ((Component)PinnedTooltips.Crafting.GemIconRows[l]).gameObject.activeSelf;
					SetCraftingPinnedTooltipTextReservedSpace(val4, reserveGemRowSpace);
				}
			}
		}

		private static ItemData? GetLiveInventoryPinnedTooltipItem(int slot)
		{
			//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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			ItemData val = ((slot >= 0 && slot < PinnedTooltips.Inventory.Items.Length) ? PinnedTooltips.Inventory.Items[slot] : null);
			if (slot < 0 || slot >= PinnedTooltips.Inventory.Grids.Length)
			{
				return val;
			}
			InventoryGrid val2 = PinnedTooltips.Inventory.Grids[slot];
			if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2) || val2.m_inventory == null)
			{
				return val;
			}
			Vector2i val3 = PinnedTooltips.Inventory.Positions[slot];
			ItemData itemAt = val2.m_inventory.GetItemAt(val3.x, val3.y);
			if (itemAt?.m_shared == null)
			{
				return val;
			}
			if (!CanUseLiveInventoryPinnedTooltipItem(val, itemAt))
			{
				return val;
			}
			if (val != itemAt)
			{
				PinnedTooltips.Inventory.Items[slot] = itemAt;
			}
			return itemAt;
		}

		private static bool CanUseLiveInventoryPinnedTooltipItem(ItemData? pinnedItem, ItemData liveItem)
		{
			if (pinnedItem?.m_shared == null)
			{
				return liveItem.m_shared != null;
			}
			if (pinnedItem == liveItem)
			{
				return true;
			}
			if (liveItem.m_shared == null || !string.Equals(GetItemPrefabName(pinnedItem), GetItemPrefabName(liveItem), StringComparison.Ordinal) || !string.Equals(pinnedItem.m_shared.m_name, liveItem.m_shared.m_name, StringComparison.Ordinal) || pinnedItem.m_variant != liveItem.m_variant)
			{
				return false;
			}
			if (HasJewelcraftingPinnedTooltipPotential(pinnedItem))
			{
				return HasJewelcraftingPinnedTooltipPotential(liveItem);
			}
			return true;
		}

		private static bool HasJewelcraftingPinnedTooltipPotential(ItemData item)
		{
			if (TryGetJewelcraftingGemSlotCount(item, out var slotCount) && slotCount > 0)
			{
				return true;
			}
			if (GetJewelcraftingSocketPrefabNamesFromCustomData(item).Count <= 0)
			{
				return HasJewelcraftingPotentialCustomData(item);
			}
			return true;
		}

		private static bool IsJewelcraftingAdvancedTooltipPressed()
		{
			if (TryGetJewelcraftingTooltipApi(out JewelcraftingTooltipApi api) && api != null && api.TryIsAdvancedTooltipPressed(out var pressed))
			{
				return pressed;
			}
			return IsAnyAltHeld();
		}

		private static bool IsJewelcraftingProphecyTooltipPressed()
		{
			try
			{
				return ZInput.GetButton("Run");
			}
			catch
			{
				return Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
			}
		}

		private static bool ShouldShowJewelcraftingInventoryInteract(InventoryGrid? grid)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)grid != (Object)null && !IsUnityNull((Object?)(object)grid) && (Object)(object)instance?.m_playerGrid != (Object)null && !IsUnityNull((Object?)(object)instance.m_playerGrid))
			{
				return (Object)(object)grid == (Object)(object)instance.m_playerGrid;
			}
			return false;
		}

		private static bool TryGetJewelcraftingTooltipApi(out JewelcraftingTooltipApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting tooltip", CompatRuntime.JewelcraftingTooltip, JewelcraftingTooltipApi.TryCreate, "Jewelcrafting tooltip compatibility disabled", out api);
		}

		private static bool TryGetJewelcraftingGemApi(out JewelcraftingGemApi? api)
		{
			return TryGetCompatApi("org.bepinex.plugins.jewelcrafting", "Jewelcrafting gem row", CompatRuntime.JewelcraftingGem, JewelcraftingGemApi.TryCreate, "Jewelcrafting gem row compatibility disabled", out api);
		}

		private static bool UpdateJewelcraftingTooltip(RectTransform panel, ItemData item, ref RectTransform? cachedRoot, bool showInteract = false, string? precomputedSignature = null)
		{
			if (item?.m_shared == null)
			{
				HideJewelcraftingTooltipRoot(ref cachedRoot);
				return false;
			}
			string signature = precomputedSignature ?? GetJewelcraftingTooltipUpdateSignature(item, showInteract);
			if ((Object)(object)cachedRoot != (Object)null && !IsUnityNull((Object?)(object)cachedRoot) && ((Transform)cachedRoot).IsChildOf((Transform)(object)panel))
			{
				JewelcraftingTooltipLayoutCache jewelcraftingTooltipLayoutCache = GetJewelcraftingTooltipLayoutCache(cachedRoot);
				if (TryReuseJewelcraftingNativeTooltipCache(cachedRoot, jewelcraftingTooltipLayoutCache, item, signature, out var visible))
				{
					return visible;
				}
			}
			if (!ShouldAttemptJewelcraftingPinnedTooltip(item))
			{
				HideJewelcraftingTooltipRoot(ref cachedRoot);
				return false;
			}
			RectTransform val = EnsureJewelcraftingTooltipRoot(panel, ref cachedRoot);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			JewelcraftingTooltipLayoutCache jewelcraftingTooltipLayoutCache2 = GetJewelcraftingTooltipLayoutCache(val);
			((Component)val).gameObject.SetActive(true);
			if (TryReuseJewelcraftingNativeTooltipCache(val, jewelcraftingTooltipLayoutCache2, item, signature, out var visible2))
			{
				return visible2;
			}
			return RebuildJewelcraftingNativeTooltip(val, item, item, showInteract, signature, jewelcraftingTooltipLayoutCache2);
		}

		private static void UpdateJewelcraftingTooltipCacheItemIdentity(JewelcraftingTooltipLayoutCache cache, ItemData item)
		{
			cache.ItemPrefabName = GetItemPrefabName(item);
			cache.ItemSharedName = item.m_shared?.m_name ?? "";
			cache.ItemVariant = item.m_variant;
		}

		private static JewelcraftingTooltipLayoutCache GetJewelcraftingTooltipLayoutCache(RectTransform root)
		{
			return ((Component)root).GetComponent<JewelcraftingTooltipLayoutCache>() ?? ((Component)root).gameObject.AddComponent<JewelcraftingTooltipLayoutCache>();
		}

		private static void RestoreCachedJewelcraftingNativeTooltip(RectTransform root, JewelcraftingTooltipLayoutCache cache)
		{
			if (cache.Visible)
			{
				RestoreJewelcraftingSourceTooltipForNativeUpdate(root);
			}
		}

		private static bool HasVisibleNativeJewelcraftingTooltipContent(RectTransform root)
		{
			if (!HasVisibleNativeJewelcraftingSocketRows(root))
			{
				return HasVisibleNativeJewelcraftingInteract(root);
			}
			return true;
		}

		private static bool HasVisibleNativeJewelcraftingInteract(RectTransform root)
		{
			Transform jewelcraftingSourceInteract = GetJewelcraftingSourceInteract(root);
			if ((Object)(object)jewelcraftingSourceInteract == (Object)null || IsUnityNull((Object?)(object)jewelcraftingSourceInteract) || !((Component)jewelcraftingSourceInteract).gameObject.activeSelf)
			{
				return false;
			}
			TMP_Text component = ((Component)jewelcraftingSourceInteract).GetComponent<TMP_Text>();
			if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
			{
				return JewelcraftingTooltipCore.HasVisibleText(component.text ?? "");
			}
			return false;
		}

		private static bool HasVisibleNativeJewelcraftingSocketRows(RectTransform root)
		{
			Transform jewelcraftingSourceRowsRoot = GetJewelcraftingSourceRowsRoot(root);
			if ((Object)(object)jewelcraftingSourceRowsRoot == (Object)null || IsUnityNull((Object?)(object)jewelcraftingSourceRowsRoot) || !((Component)jewelcraftingSourceRowsRoot).gameObject.activeSelf)
			{
				return false;
			}
			for (int i = 0; i < jewelcraftingSourceRowsRoot.childCount; i++)
			{
				Transform child = jewelcraftingSourceRowsRoot.GetChild(i);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null && ((Component)val).gameObject.activeSelf)
				{
					JewelcraftingSourceRowUiCache jewelcraftingSourceRowUiCache = GetJewelcraftingSourceRowUiCache(val);
					TMP_Text text = jewelcraftingSourceRowUiCache.Text;
					Image gemImage = jewelcraftingSourceRowUiCache.GemImage;
					if ((Object)(object)text != (Object)null && !IsUnityNull((Object?)(object)text) && JewelcraftingTooltipCore.HasVisibleText(text.text ?? ""))
					{
						return true;
					}
					if ((Object)(object)gemImage != (Object)null && !IsUnityNull((Object?)(object)gemImage) && ((Component)gemImage).gameObject.activeSelf && (Object)(object)gemImage.sprite != (Object)null && !IsUnityNull((Object?)(object)gemImage.sprite))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool ShouldAttemptJewelcraftingPinnedTooltip(ItemData item)
		{
			if (TryGetJewelcraftingGemSlotCount(item, out var slotCount) && slotCount > 0)
			{
				return true;
			}
			if (GetJewelcraftingSocketPrefabNamesFromCustomData(item).Count > 0)
			{
				return true;
			}
			return HasJewelcraftingPotentialCustomData(item);
		}

		private static bool IsJewelcraftingTooltipDataKey(string key)
		{
			if (key.IndexOf("Jewelcrafting.Sockets", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.Box", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.SocketBag", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.InventoryBag", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.DropChest", StringComparison.OrdinalIgnoreCase) < 0 && key.IndexOf("Jewelcrafting.Frame", StringComparison.OrdinalIgnoreCase) < 0 && !string.Equals(key, "ProphecySeed", StringComparison.OrdinalIgnoreCase))
			{
				return key.EndsWith("#ProphecySeed", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool TryGetJewelcraftingGemSlotCount(ItemData item, out int slotCount)
		{
			slotCount = 0;
			if (!TryGetJewelcraftingGemApi(out JewelcraftingGemApi api) || api == null)
			{
				return false;
			}
			try
			{
				if (!(api.GetGems(item) is IEnumerable enumerable))
				{
					return false;
				}
				foreach (object item2 in enumerable)
				{
					_ = item2;
					slotCount++;
				}
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static string GetJewelcraftingTooltipUpdateSignature(ItemData item, bool showInteract)
		{
			return JewelcraftingTooltipCore.BuildNativeTooltipUpdateSignature(showInteract, IsJewelcraftingAdvancedTooltipPressed(), IsJewelcraftingProphecyTooltipPressed(), _uiLocalizationVersion, GetEquipmentSlotTooltipSignature(item), GetJewelcraftingOpenSocketInventorySignature(item));
		}

		private static RectTransform? EnsureJewelcraftingTooltipRoot(RectTransform panel, ref RectTransform? cachedRoot)
		{
			if (!TryGetJewelcraftingTooltipApi(out JewelcraftingTooltipApi api) || api == null)
			{
				return null;
			}
			if ((Object)(object)cachedRoot != (Object)null && !IsUnityNull((Object?)(object)cachedRoot) && ((Transform)cachedRoot).IsChildOf((Transform)(object)panel))
			{
				ConfigureJewelcraftingTooltipRoot(cachedRoot);
				return cachedRoot;
			}
			RectTransform val = FindJewelcraftingTooltipRoot(panel);
			if ((Object)(object)val == (Object)null)
			{
				GameObject socketTooltip = api.GetSocketTooltip();
				Transform val2 = (((Object)(object)socketTooltip != (Object)null && !IsUnityNull((Object?)(object)socketTooltip)) ? socketTooltip.transform.Find("Bkg (1)") : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return null;
				}
				GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, (Transform)(object)panel, false);
				((Object)val3).name = "InventorySlots_JewelcraftingTooltipRoot";
				val = val3.GetComponent<RectTransform>();
				if ((Object)(object)val == (Object)null)
				{
					Object.Destroy((Object)(object)val3);
					return null;
				}
			}
			if (!((Transform)val).IsChildOf((Transform)(object)panel))
			{
				((Transform)val).SetParent((Transform)(object)panel, false);
			}
			ConfigureJewelcraftingTooltipRoot(val);
			cachedRoot = val;
			return val;
		}

		private static void ConfigureJewelcraftingTooltipRoot(RectTransform root)
		{
			//IL_001f: 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_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_007e: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			StripJewelcraftingTooltipTemplate((Transform)(object)root);
			JewelcraftingTooltipLayoutCache jewelcraftingTooltipLayoutCache = GetJewelcraftingTooltipLayoutCache(root);
			RefreshJewelcraftingNativeComponentCache(root, jewelcraftingTooltipLayoutCache);
			root.anchorMin = new Vector2(0f, 0f);
			root.anchorMax = new Vector2(1f, 0f);
			root.pivot = new Vector2(0.5f, 1f);
			root.anchoredPosition = new Vector2(0f, 180f);
			root.sizeDelta = new Vector2(-36f, 162f);
			((Transform)root).localScale = Vector3.one;
			((Transform)root).localRotation = Quaternion.identity;
			Image component = ((Component)root).GetComponent<Image>();
			if (component != null)
			{
				((Graphic)component).color = new Color(0f, 0f, 0f, 0f);
				((Graphic)component).raycastTarget = false;
			}
			Graphic[] nativeGraphics = jewelcraftingTooltipLayoutCache.NativeGraphics;
			foreach (Graphic val in nativeGraphics)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					val.raycastTarget = false;
				}
			}
			TMP_Text[] nativeTexts = jewelcraftingTooltipLayoutCache.NativeTexts;
			foreach (TMP_Text val2 in nativeTexts)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					ApplyDefaultFontAsset(val2);
					ApplyTooltipSourceFont(val2, "Text");
					((Graphic)val2).raycastTarget = false;
				}
			}
		}

		private static void RefreshJewelcraftingNativeComponentCache(RectTransform root, JewelcraftingTooltipLayoutCache cache)
		{
			string jewelcraftingNativeComponentSignature = GetJewelcraftingNativeComponentSignature(root);
			if (!string.Equals(cache.NativeComponentSignature, jewelcraftingNativeComponentSignature, StringComparison.Ordinal) || HasInvalidJewelcraftingNativeComponentCache(cache))
			{
				cache.NativeGraphics = ((Component)root).GetComponentsInChildren<Graphic>(true);
				cache.NativeTexts = ((Component)root).GetComponentsInChildren<TMP_Text>(true);
				cache.NativeLayoutGroups = ((Component)root).GetComponentsInChildren<LayoutGroup>(true);
				cache.NativeContentSizeFitters = ((Component)root).GetComponentsInChildren<ContentSizeFitter>(true);
				cache.NativeComponentSignature = jewelcraftingNativeComponentSignature;
			}
		}

		private static bool HasInvalidJewelcraftingNativeComponentCache(JewelcraftingTooltipLayoutCache cache)
		{
			if (!cache.NativeGraphics.Any((Graphic graphic) => (Object)(object)graphic == (Object)null || IsUnityNull((Object?)(object)graphic)) && !cache.NativeTexts.Any((TMP_Text text) => (Object)(object)text == (Object)null || IsUnityNull((Object?)(object)text)) && !cache.NativeLayoutGroups.Any((LayoutGroup group) => (Object)(object)group == (Object)null || IsUnityNull((Object?)(object)group)))
			{
				return cache.NativeContentSizeFitters.Any((ContentSizeFitter fitter) => (Object)(object)fitter == (Object)null || IsUnityNull((Object?)(object)fitter));
			}
			return true;
		}

		private static string GetJewelcraftingNativeComponentSignature(RectTransform root)
		{
			Transform val = ((Transform)root).Find("TrannyHoles");
			Transform val2 = ((Transform)root).Find("Transmute_Press_Interact");
			return $"{((Transform)root).childCount}|rows={((val != null) ? val.childCount : (-1))}|interact={((val2 != null) ? val2.childCount : (-1))}";
		}

		private static void StripJewelcraftingTooltipTemplate(Transform root)
		{
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				string name = ((Object)child).name;
				if (!string.Equals(name, "TrannyHoles", StringComparison.Ordinal) && !string.Equals(name, "Transmute_Press_Interact", StringComparison.Ordinal))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		private static RectTransform? FindJewelcraftingTooltipRoot(RectTransform panel)
		{
			Transform val = ((Transform)panel).Find("InventorySlots_JewelcraftingTooltipRoot");
			if ((Object)(object)val != (Object)null)
			{
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				if (component != null)
				{
					return component;
				}
			}
			RectTransform[] componentsInChildren = ((Component)panel).GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform val2 in componentsInChildren)
			{
				if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2) && string.Equals(((Object)val2).name, "InventorySlots_JewelcraftingTooltipRoot", StringComparison.Ordinal))
				{
					return val2;
				}
			}
			return null;
		}

		private static Transform? GetJewelcraftingSourceRowsRoot(RectTransform root)
		{
			JewelcraftingTooltipLayoutCache jewelcraftingTooltipLayoutCache = GetJewelcraftingTooltipLayoutCache(root);
			if ((Object)(object)jewelcraftingTooltipLayoutCache.SourceRowsRoot != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingTooltipLayoutCache.SourceRowsRoot) && (Object)(object)jewelcraftingTooltipLayoutCache.SourceRowsRoot.parent == (Object)(object)root)
			{
				return jewelcraftingTooltipLayoutCache.SourceRowsRoot;
			}
			return jewelcraftingTooltipLayoutCache.SourceRowsRoot = ((Transform)root).Find("TrannyHoles");
		}

		private static Transform? GetJewelcraftingSourceInteract(RectTransform root)
		{
			JewelcraftingTooltipLayoutCache jewelcraftingTooltipLayoutCache = GetJewelcraftingTooltipLayoutCache(root);
			if ((Object)(object)jewelcraftingTooltipLayoutCache.SourceInteract != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingTooltipLayoutCache.SourceInteract) && (Object)(object)jewelcraftingTooltipLayoutCache.SourceInteract.parent == (Object)(object)root)
			{
				return jewelcraftingTooltipLayoutCache.SourceInteract;
			}
			return jewelcraftingTooltipLayoutCache.SourceInteract = ((Transform)root).Find("Transmute_Press_Interact");
		}

		private static float LayoutPinnedTooltipExtraScrollContent(RectTransform panel, float textWidth, float textHeight)
		{
			//IL_0085: 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_00af: 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_00d9: 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_00f3: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = FindJewelcraftingTooltipRoot(panel);
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Component)val).gameObject.activeSelf)
			{
				return 0f;
			}
			PinnedTooltipPanelUiCache component = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>();
			RectTransform val2 = (((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component)) ? component.TextContent : null);
			if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2))
			{
				return 0f;
			}
			if ((Object)(object)((Transform)val).parent != (Object)(object)val2)
			{
				((Transform)val).SetParent((Transform)(object)val2, false);
			}
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(0f, 0f - textHeight - 12f);
			val.sizeDelta = new Vector2(textWidth, Mathf.Max(1f, val.sizeDelta.y));
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			((Transform)val).SetAsLastSibling();
			float num = LayoutJewelcraftingNativeTooltip(val, textWidth);
			val.sizeDelta = new Vector2(textWidth, num);
			return num + 12f;
		}

		private static bool HasNativeJewelcraftingTooltipRows(RectTransform root)
		{
			return HasVisibleNativeJewelcraftingSocketRows(root);
		}

		private static string GetJewelcraftingNativeTooltipLayoutSignature(RectTransform root)
		{
			int num = 17;
			int num2 = 0;
			Transform jewelcraftingSourceInteract = GetJewelcraftingSourceInteract(root);
			TMP_Text val = (((Object)(object)jewelcraftingSourceInteract != (Object)null) ? ((Component)jewelcraftingSourceInteract).GetComponent<TMP_Text>() : null);
			if ((Object)(object)jewelcraftingSourceInteract != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceInteract) && ((Component)jewelcraftingSourceInteract).gameObject.activeSelf && (Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
			{
				string text = val.text ?? "";
				num = num * 31 + text.Length;
				num = num * 31 + text.GetHashCode();
			}
			Transform jewelcraftingSourceRowsRoot = GetJewelcraftingSourceRowsRoot(root);
			if ((Object)(object)jewelcraftingSourceRowsRoot != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceRowsRoot))
			{
				num = num * 31 + jewelcraftingSourceRowsRoot.childCount;
				for (int i = 0; i < jewelcraftingSourceRowsRoot.childCount; i++)
				{
					Transform child = jewelcraftingSourceRowsRoot.GetChild(i);
					RectTransform val2 = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (val2 != null && ((Component)val2).gameObject.activeSelf)
					{
						num2++;
						JewelcraftingSourceRowUiCache jewelcraftingSourceRowUiCache = GetJewelcraftingSourceRowUiCache(val2);
						string text2 = (((Object)(object)jewelcraftingSourceRowUiCache.Text != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceRowUiCache.Text)) ? (jewelcraftingSourceRowUiCache.Text.text ?? "") : "");
						num = num * 31 + ((Object)val2).name.GetHashCode();
						num = num * 31 + text2.Length;
						num = num * 31 + text2.GetHashCode();
						num = num * 31 + (((Object)(object)jewelcraftingSourceRowUiCache.BorderImage != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceRowUiCache.BorderImage) && (Object)(object)jewelcraftingSourceRowUiCache.BorderImage.sprite != (Object)null) ? ((Object)jewelcraftingSourceRowUiCache.BorderImage.sprite).GetInstanceID() : 0);
						num = num * 31 + (((Object)(object)jewelcraftingSourceRowUiCache.GemImage != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceRowUiCache.GemImage) && (Object)(object)jewelcraftingSourceRowUiCache.GemImage.sprite != (Object)null) ? ((Object)jewelcraftingSourceRowUiCache.GemImage.sprite).GetInstanceID() : 0);
					}
				}
			}
			return $"{((Transform)root).childCount}:{num2}:{num}";
		}

		private static void ConfigureJewelcraftingNativeGemIconTooltips(RectTransform root, ItemData item)
		{
			Transform jewelcraftingSourceRowsRoot = GetJewelcraftingSourceRowsRoot(root);
			if ((Object)(object)jewelcraftingSourceRowsRoot == (Object)null || IsUnityNull((Object?)(object)jewelcraftingSourceRowsRoot))
			{
				return;
			}
			bool flag = IsPinnedTooltipTransform((Transform?)(object)root);
			List<JewelcraftingGemIconData> list = (flag ? GetJewelcraftingGemIconData(item) : new List<JewelcraftingGemIconData>());
			bool[] usedGems = new bool[list.Count];
			for (int i = 0; i < jewelcraftingSourceRowsRoot.childCount; i++)
			{
				Transform child = jewelcraftingSourceRowsRoot.GetChild(i);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null)
				{
					Image gemImage = GetJewelcraftingSourceRowUiCache(val).GemImage;
					if (!((Object)(object)gemImage == (Object)null) && !IsUnityNull((Object?)(object)gemImage))
					{
						RectTransform rectTransform = ((Graphic)gemImage).rectTransform;
						string displayName = ((flag && ((Component)gemImage).gameObject.activeSelf && (Object)(object)gemImage.sprite != (Object)null && !IsUnityNull((Object?)(object)gemImage.sprite)) ? GetJewelcraftingNativeGemDisplayName(list, usedGems, gemImage.sprite) : "");
						ConfigurePinnedGemIconTooltip(rectTransform, displayName);
					}
				}
			}
		}

		private static string GetJewelcraftingNativeGemDisplayName(IReadOnlyList<JewelcraftingGemIconData> gems, bool[] usedGems, Sprite sprite)
		{
			int num = FindMatchingJewelcraftingGemIcon(gems, usedGems, sprite);
			if (num < 0)
			{
				return "";
			}
			usedGems[num] = true;
			return gems[num].DisplayName;
		}

		private static JewelcraftingSourceRowUiCache GetJewelcraftingSourceRowUiCache(RectTransform row)
		{
			JewelcraftingSourceRowUiCache jewelcraftingSourceRowUiCache = ((Component)row).GetComponent<JewelcraftingSourceRowUiCache>() ?? ((Component)row).gameObject.AddComponent<JewelcraftingSourceRowUiCache>();
			if (string.Equals(jewelcraftingSourceRowUiCache.ChildSignature, GetJewelcraftingSourceRowChildSignature(row, jewelcraftingSourceRowUiCache.BorderImage), StringComparison.Ordinal) && (Object)(object)jewelcraftingSourceRowUiCache.Text != (Object)null && (Object)(object)jewelcraftingSourceRowUiCache.BorderImage != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceRowUiCache.Text) && !IsUnityNull((Object?)(object)jewelcraftingSourceRowUiCache.BorderImage) && ((Object)(object)jewelcraftingSourceRowUiCache.GemImage == (Object)null || !IsUnityNull((Object?)(object)jewelcraftingSourceRowUiCache.GemImage)))
			{
				return jewelcraftingSourceRowUiCache;
			}
			Transform val = ((Transform)row).Find("Border");
			jewelcraftingSourceRowUiCache.Text = FindJewelcraftingSourceRowText(row, val);
			jewelcraftingSourceRowUiCache.BorderImage = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Image>() : null);
			Transform val2 = (((Object)(object)val != (Object)null) ? val.Find("Transmute_1") : null);
			jewelcraftingSourceRowUiCache.GemImage = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<Image>() : null);
			jewelcraftingSourceRowUiCache.ChildSignature = GetJewelcraftingSourceRowChildSignature(row, jewelcraftingSourceRowUiCache.BorderImage);
			return jewelcraftingSourceRowUiCache;
		}

		private static TMP_Text? FindJewelcraftingSourceRowText(RectTransform row, Transform? border)
		{
			TMP_Text component = ((Component)row).GetComponent<TMP_Text>();
			if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
			{
				return component;
			}
			TMP_Text[] componentsInChildren = ((Component)row).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && (!((Object)(object)border != (Object)null) || IsUnityNull((Object?)(object)border) || !val.transform.IsChildOf(border)))
				{
					return val;
				}
			}
			return null;
		}

		private static string GetJewelcraftingSourceRowChildSignature(RectTransform row, Image? borderImage)
		{
			int num = (((Object)(object)borderImage != (Object)null && !IsUnityNull((Object?)(object)borderImage)) ? ((Component)borderImage).transform.childCount : (-1));
			return ((Transform)row).childCount + "|" + num;
		}

		private static void RestoreJewelcraftingSourceTooltipForNativeUpdate(RectTransform root)
		{
			SetJewelcraftingSourceBranchNativeActive(GetJewelcraftingSourceRowsRoot(root));
			SetJewelcraftingSourceBranchNativeActive(GetJewelcraftingSourceInteract(root));
		}

		private static void SetJewelcraftingSourceBranchNativeActive(Transform? branch)
		{
			if (!((Object)(object)branch == (Object)null) && !IsUnityNull((Object?)(object)branch))
			{
				((Component)branch).gameObject.SetActive(true);
				CanvasGroup component = ((Component)branch).GetComponent<CanvasGroup>();
				if (component != null)
				{
					component.alpha = 1f;
					component.blocksRaycasts = true;
					component.interactable = true;
				}
			}
		}

		private static float LayoutJewelcraftingNativeTooltip(RectTransform root, float width)
		{
			//IL_001a: 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_01ee: 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_010b: 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)
			//IL_0133: 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_014b: 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)
			RestoreJewelcraftingSourceTooltipForNativeUpdate(root);
			float num = Mathf.Max(80f, width);
			root.sizeDelta = new Vector2(num, Mathf.Max(1f, root.sizeDelta.y));
			float num2 = 0f;
			Transform jewelcraftingSourceInteract = GetJewelcraftingSourceInteract(root);
			TMP_Text val = (((Object)(object)jewelcraftingSourceInteract != (Object)null) ? ((Component)jewelcraftingSourceInteract).GetComponent<TMP_Text>() : null);
			if ((Object)(object)jewelcraftingSourceInteract != (Object)null && !IsUnityNull((Object?)(object)jewelcraftingSourceInteract) && ((Component)jewelcraftingSourceInteract).gameObject.activeSelf && (Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && JewelcraftingTooltipCore.HasVisibleText(val.text ?? ""))
			{
				float num3 = LayoutJewelcraftingNativeText(val, num, num2, (TextAlignmentOptions)514);
				num2 -= num3 + 8f;
			}
			Transform? jewelcraftingSourceRowsRoot = GetJewelcraftingSourceRowsRoot(root);
			RectTransform val2 = (RectTransform)(object)((jewelcraftingSourceRowsRoot is RectTransform) ? jewelcraftingSourceRowsRoot : null);
			if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2) && ((Component)val2).gameObject.activeSelf)
			{
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 1f);
				val2.anchoredPosition = new Vector2(0f, num2);
				((Transform)val2).localScale = Vector3.one;
				((Transform)val2).localRotation = Quaternion.identity;
				float num4 = 0f;
				for (int i = 0; i < ((Transform)val2).childCount; i++)
				{
					Transform child = ((Transform)val2).GetChild(i);
					RectTransform val3 = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (val3 != null && ((Component)val3).gameObject.activeSelf)
					{
						float num5 = LayoutJewelcraftingNativeSocketRow(val3, num, num4);
						num4 -= num5 + 10f;
					}
				}
				float num6 = Mathf.Max(0f, 0f - num4 - 10f);
				val2.sizeDelta = new Vector2(num, num6);
				num2 -= num6;
			}
			float num7 = Mathf.Max(1f, 0f - num2 + 32f);
			root.sizeDelta = new Vector2(num, num7);
			return num7;
		}

		private static void DisableJewelcraftingNativeLayoutDrivers(RectTransform root)
		{
			JewelcraftingTooltipLayoutCache jewelcraftingTooltipLayoutCache = GetJewelcraftingTooltipLayoutCache(root);
			RefreshJewelcraftingNativeComponentCache(root, jewelcraftingTooltipLayoutCache);
			LayoutGroup[] nativeLayoutGroups = jewelcraftingTooltipLayoutCache.NativeLayoutGroups;
			foreach (LayoutGroup val in nativeLayoutGroups)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
				{
					((Behaviour)val).enabled = false;
				}
			}
			ContentSizeFitter[] nativeContentSizeFitters = jewelcraftingTooltipLayoutCache.NativeContentSizeFitters;
			foreach (ContentSizeFitter val2 in nativeContentSizeFitters)
			{
				if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2))
				{
					((Behaviour)val2).enabled = false;
				}
			}
		}

		private static float LayoutJewelcraftingNativeText(TMP_Text text, float width, float y, TextAlignmentOptions alignment)
		{
			//IL_0007: 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_0042: 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_0068: 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_0084: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			RectTransform rectTransform = text.rectTransform;
			text.alignment = alignment;
			text.textWrappingMode = (TextWrappingModes)1;
			text.overflowMode = (TextOverflowModes)0;
			((Graphic)text).raycastTarget = false;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, y);
			rectTransform.sizeDelta = new Vector2(width, 1f);
			((Transform)rectTransform).localScale = Vector3.one;
			((Transform)rectTransform).localRotation = Quaternion.identity;
			float stableJewelcraftingTooltipTextHeight = GetStableJewelcraftingTooltipTextHeight(text, width, 1f);
			rectTransform.sizeDelta = new Vector2(width, stableJewelcraftingTooltipTextHeight);
			return stableJewelcraftingTooltipTextHeight;
		}

		private static float LayoutJewelcraftingNativeSocketRow(RectTransform row, float width, float y)
		{
			//IL_0149: 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_0173: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: 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_0092: 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_0283: 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_02a3: 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_02cd: 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_02e2: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: 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_030f: Unknown result type (might be due to invalid IL or missing references)
			float num = 50f;
			float num2 = Mathf.Max(80f, width - num - 12f);
			JewelcraftingSourceRowUiCache jewelcraftingSourceRowUiCache = GetJewelcraftingSourceRowUiCache(row);
			TMP_Text text = jewelcraftingSourceRowUiCache.Text;
			float num3 = 42f;
			if ((Object)(object)text != (Object)null && !IsUnityNull((Object?)(object)text))
			{
				text.alignment = (TextAlignmentOptions)257;
				text.textWrappingMode = (TextWrappingModes)1;
				text.overflowMode = (TextOverflowModes)0;
				((Graphic)text).raycastTarget = false;
				RectTransform rectTransform = text.rectTransform;
				bool flag = (Object)(object)rectTransform == (Object)(object)row;
				text.margin = (Vector4)(flag ? new Vector4(num, 0f, 12f, 0f) : Vector4.zero);
				if (!flag)
				{
					rectTransform.anchorMin = new Vector2(0f, 1f);
					rectTransform.anchorMax = new Vector2(0f, 1f);
					rectTransform.pivot = new Vector2(0f, 1f);
					rectTransform.anchoredPosition = new Vector2(num, 0f);
					rectTransform.sizeDelta = new Vector2(num2, 1f);
					((Transform)rectTransform).localScale = Vector3.one;
					((Transform)rectTransform).localRotation = Quaternion.identity;
				}
				num3 = GetStableJewelcraftingTooltipTextHeight(text, num2, 42f);
			}
			float num4 = Mathf.Max(42f, num3 + 4f);
			row.anchorMin = new Vector2(0f, 1f);
			row.anchorMax = new Vector2(0f, 1f);
			row.pivot = new Vector2(0f, 1f);
			row.anchoredPosition = new Vector2(0f, y);
			row.sizeDelta = new Vector2(width, num4);
			((Transform)row).localScale = Vector3.one;
			((Transform)row).localRotation = Quaternion.identity;
			Image borderImage = jewelcraftingSourceRowUiCache.BorderImage;
			if ((Object)(object)borderImage != (Object)null && !IsUnityNull((Object?)(object)borderImage))
			{
				((Graphic)borderImage).raycastTarget = false;
				RectTransform rectTransform2 = ((Graphic)borderImage).rectTransform;
				rectTransform2.anchorMin = new Vector2(0f, 1f);
				rectTransform2.anchorMax = new Vector2(0f, 1f);
				rectTransform2.pivot = new Vector2(0f, 1f);
				rectTransform2.anchoredPosition = Vector2.zero;
				rectTransform2.sizeDelta = new Vector2(42f, 42f);
				((Transform)rectTransform2).localScale = Vector3.one;
				((Transform)rectTransform2).localRotation = Quaternion.identity;
			}
			Image gemImage = jewelcraftingSourceRowUiCache.GemImage;
			if ((Object)(object)gemImage != (Object)null && !IsUnityNull((Object?)(object)gemImage))
			{
				((Graphic)gemImage).raycastTarget = false;
				RectTransform rectTransform3 = ((Graphic)gemImage).rectTransform;
				rectTransform3.anchorMin = Vector2.zero;
				rectTransform3.anchorMax = Vector2.one;
				rectTransform3.pivot = new Vector2(0.5f, 0.5f);
				rectTransform3.offsetMin = new Vector2(4f, 4f);
				rectTransform3.offsetMax = new Vector2(-4f, -4f);
				((Transform)rectTransform3).localScale = Vector3.one;
				((Transform)rectTransform3).localRotation = Quaternion.identity;
			}
			if ((Object)(object)text != (Object)null && !IsUnityNull((Object?)(object)text))
			{
				RectTransform rectTransform4 = text.rectTransform;
				rectTransform4.sizeDelta = (((Object)(object)rectTransform4 == (Object)(object)row) ? new Vector2(width, num4) : new Vector2(num2, num4));
			}
			return num4;
		}

		private static float GetStableJewelcraftingTooltipTextHeight(TMP_Text text, float width, float fallbackHeight)
		{
			//IL_0020: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			string text2 = text.text ?? "";
			text.ForceMeshUpdate(true, true);
			float num = text.GetPreferredValues(text2, width, 0f).y;
			if (!IsFinitePositive(num))
			{
				num = fallbackHeight;
			}
			Bounds textBounds = text.textBounds;
			float y = ((Bounds)(ref textBounds)).size.y;
			if (IsFinitePositive(y) && y > num)
			{
				float num2 = Mathf.Max(num * 2f, fallbackHeight * 2f);
				if (y <= num2)
				{
					num = y;
				}
			}
			return Mathf.Max(1f, num);
		}

		private static bool IsFinitePositive(float value)
		{
			if (value > 0f && !float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static bool TryReuseJewelcraftingNativeTooltipCache(RectTransform root, JewelcraftingTooltipLayoutCache cache, ItemData item, string signature, out bool visible)
		{
			visible = false;
			if (JewelcraftingTooltipCore.ShouldRefreshNativeTooltip(cache.Signature, signature, cache.Visible, cache.HasResolvedSocketGems, cache.RowlessRefreshAttempts))
			{
				return false;
			}
			UpdateJewelcraftingTooltipCacheItemIdentity(cache, item);
			RestoreCachedJewelcraftingNativeTooltip(root, cache);
			visible = cache.Visible;
			((Component)root).gameObject.SetActive(visible);
			return true;
		}

		private static bool RebuildJewelcraftingNativeTooltip(RectTransform root, ItemData tooltipItem, ItemData identityItem, bool showInteract, string signature, JewelcraftingTooltipLayoutCache cache)
		{
			try
			{
				if (!TryGetJewelcraftingTooltipApi(out JewelcraftingTooltipApi api) || api == null)
				{
					SetJewelcraftingNativeTooltipCacheState(root, cache, signature, identityItem, visible: false, hasSocketRows: false);
					return false;
				}
				RestoreJewelcraftingSourceTooltipForNativeUpdate(root);
				api.FillItemContainerTooltip(tooltipItem, root, showInteract);
				DisableJewelcraftingNativeLayoutDrivers(root);
				ConfigureJewelcraftingTooltipRoot(root);
				ConfigureJewelcraftingNativeGemIconTooltips(root, tooltipItem);
				bool flag = HasVisibleNativeJewelcraftingTooltipContent(root);
				bool hasSocketRows = HasVisibleNativeJewelcraftingSocketRows(root);
				SetJewelcraftingNativeTooltipCacheState(root, cache, signature, identityItem, flag, hasSocketRows);
				return flag;
			}
			catch (Exception)
			{
				SetJewelcraftingNativeTooltipCacheState(root, cache, signature, identityItem, visible: false, hasSocketRows: false);
				return false;
			}
		}

		private static void SetJewelcraftingNativeTooltipCacheState(RectTransform root, JewelcraftingTooltipLayoutCache cache, string signature, ItemData item, bool visible, bool hasSocketRows)
		{
			bool flag = string.Equals(cache.Signature, signature, StringComparison.Ordinal);
			cache.Signature = signature;
			cache.Visible = visible;
			cache.HasResolvedSocketGems = hasSocketRows;
			cache.RowlessRefreshAttempts = ((visible && !hasSocketRows) ? ((!flag) ? 1 : Math.Min(cache.RowlessRefreshAttempts + 1, 3)) : 0);
			UpdateJewelcraftingTooltipCacheItemIdentity(cache, item);
			((Component)root).gameObject.SetActive(visible);
		}

		private static void InitializeMagicSupremacyCompatibility()
		{
			TryGetMagicSupremacyApi(out MagicSupremacyApi _);
		}

		private static bool TryAddMagicSupremacyCompatSlot(YamlSlot slot, string id)
		{
			if (!string.Equals(NormalizeSlotId(id), "magicsupremacy.belt", StringComparison.Ordinal))
			{
				return false;
			}
			if (SlotDefinitions.Any((SlotDefinition existing) => existing.Id == "magicsupremacy.belt"))
			{
				return true;
			}
			List<string> items = GetSlotItems(slot);
			if ((!TryGetMagicSupremacyApi(out MagicSupremacyApi api) || api == null) && items.Count == 0)
			{
				return true;
			}
			string name = (string.IsNullOrWhiteSpace(slot.Name) ? "MagicBelt" : slot.Name.Trim());
			SlotDefinitions.Add(new SlotDefinition("magicsupremacy.belt", name, SlotKind.CustomEquipment, (ItemData? item) => IsMagicSupremacyBeltItem(item) || (items.Count > 0 && ItemMatchesSlotItems(item, items))));
			return true;
		}

		private static bool IsMagicSupremacyBeltItem(ItemData? item)
		{
			if (item != null && TryGetMagicSupremacyApi(out MagicSupremacyApi api) && api != null)
			{
				return api.IsBeltItem(item);
			}
			return false;
		}

		private static void SyncMagicSupremacyCompatState(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (!TryGetMagicSupremacyApi(out MagicSupremacyApi api) || api == null)
			{
				_lastMagicSupremacyBeltCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsMagicSupremacyBeltItem);
			if (val != _lastMagicSupremacyBeltCompatItem)
			{
				if (_lastMagicSupremacyBeltCompatItem != null)
				{
					api.ClearBeltIfCurrent(player, _lastMagicSupremacyBeltCompatItem);
				}
				_lastMagicSupremacyBeltCompatItem = val;
				if (val != null)
				{
					api.SyncBelt(player, val);
				}
			}
			else if (val != null && !api.IsBeltEquipped(player, val))
			{
				api.SyncBelt(player, val);
			}
		}

		private static void OnMagicSupremacyBeltEquipped(Player player, ItemData item)
		{
			if (!((Object)(object)player == (Object)null) && item != null && IsMagicSupremacyBeltItem(item) && TryGetMagicSupremacyApi(out MagicSupremacyApi api) && api != null)
			{
				api.SyncBelt(player, item);
				_lastMagicSupremacyBeltCompatItem = item;
			}
		}

		private static void OnMagicSupremacyBeltUnequipping(Player player, ItemData item)
		{
			if (!((Object)(object)player == (Object)null) && item != null && (_lastMagicSupremacyBeltCompatItem == item || IsMagicSupremacyBeltItem(item)) && TryGetMagicSupremacyApi(out MagicSupremacyApi api) && api != null)
			{
				api.ClearBeltIfCurrent(player, item);
				if (_lastMagicSupremacyBeltCompatItem == item)
				{
					_lastMagicSupremacyBeltCompatItem = null;
				}
			}
		}

		private static bool TryGetMagicSupremacyApi(out MagicSupremacyApi? api)
		{
			return TryGetCompatApi("Dreanegade.Magic_Supremacy", "Magic Supremacy", CompatRuntime.MagicSupremacy, MagicSupremacyApi.TryCreate, "Magic Supremacy compatibility disabled", out api);
		}

		internal static bool IsMultiUserContainerBatchInteractionBlocked(InventoryGui? gui)
		{
			MultiUserContainerBatchState multiUserContainerBatch = _multiUserContainerBatch;
			if (multiUserContainerBatch == null || (Object)(object)gui == (Object)null || IsUnityNull((Object?)(object)gui))
			{
				return false;
			}
			if ((Object)(object)gui.m_currentContainer == (Object)null)
			{
				return false;
			}
			return IsSameMultiUserContainerBatchContainer(multiUserContainerBatch, gui.m_currentContainer);
		}

		internal static bool TryStartMultiUserContainerTakeAllBatch(Container container)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetMultiUserContainerBatchContext(container, out Player _, out Inventory _, out Inventory containerInventory, out ZDOID containerId))
			{
				return false;
			}
			List<MultiUserContainerBatchItem> list = new List<MultiUserContainerBatchItem>();
			foreach (ItemData item in from item in containerInventory.m_inventory
				where item?.m_shared != null
				orderby item.m_gridPos.y, item.m_gridPos.x
				select item)
			{
				if (!TryCreateMultiUserContainerBatchItem(item, out MultiUserContainerBatchItem batchItem))
				{
					return false;
				}
				list.Add(batchItem);
			}
			if (list.Count == 0)
			{
				return true;
			}
			InventoryGui instance = InventoryGui.instance;
			if (instance != null)
			{
				instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
			}
			_multiUserContainerBatch = new MultiUserContainerBatchState
			{
				Kind = MultiUserContainerBatchKind.TakeAll,
				ContainerId = containerId
			};
			_multiUserContainerBatch.Items.AddRange(list);
			UpdateMultiUserContainerBatchRuntime();
			return true;
		}

		internal static bool TryHandleMultiUserContainerAreaQuickStack(Container anchorContainer)
		{
			return TryHandleMultiUserContainerAreaBatch(anchorContainer, MultiUserContainerBatchKind.AreaPlaceStacks);
		}

		internal static bool TryHandleMultiUserContainerAreaRestock(Container anchorContainer)
		{
			return TryHandleMultiUserContainerAreaBatch(anchorContainer, MultiUserContainerBatchKind.AreaFavoriteRestock);
		}

		private static bool TryHandleMultiUserContainerAreaBatch(Container anchorContainer, MultiUserContainerBatchKind kind)
		{
			//IL_0231: 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_0236: Unknown result type (might be due to invalid IL or missing references)
			bool flag = !IsBuiltInMultiUserChestEnabled;
			if (!flag)
			{
				bool flag2 = (uint)(kind - 2) <= 1u;
				flag = !flag2;
			}
			if (flag)
			{
				return false;
			}
			if (_multiUserContainerBatch != null || _pendingMultiUserContainerTransfer != null)
			{
				ShowMultiUserContainerNotReady();
				return true;
			}
			Player player = Player.m_localPlayer;
			Inventory playerInventory = (((Object)(object)player != (Object)null && !IsUnityNull((Object?)(object)player)) ? ((Humanoid)player).GetInventory() : null);
			if ((Object)(object)player == (Object)null || IsUnityNull((Object?)(object)player) || player.m_isLoading || playerInventory == null || (Object)(object)anchorContainer == (Object)null || IsUnityNull((Object?)(object)anchorContainer) || anchorContainer.m_inventory == null)
			{
				return false;
			}
			ContainerAccessMode containerAccessMode = GetContainerAccessMode(anchorContainer, (Object)(object)anchorContainer.m_nview == (Object)null);
			bool flag3 = containerAccessMode == ContainerAccessMode.DirectOwner;
			bool flag4 = containerAccessMode == ContainerAccessMode.MultiUserChestRemote && CanUseBuiltInRemoteAreaContainer(player, anchorContainer);
			if (!flag3 && !flag4)
			{
				return false;
			}
			if (!HasContainerPlayerAccess(player, anchorContainer, flashGuardStone: true))
			{
				ShowMultiUserContainerNotReady();
				return true;
			}
			bool areaForQuickStack = kind == MultiUserContainerBatchKind.AreaPlaceStacks;
			List<Container> actionContainers = GetActionContainers(player, anchorContainer, areaForQuickStack, includeBuiltInRemote: true);
			if (!actionContainers.Any((Container container) => GetContainerAccessMode(container) == ContainerAccessMode.MultiUserChestRemote && CanUseBuiltInRemoteAreaContainer(player, container)))
			{
				return false;
			}
			List<ItemData> list = playerInventory.m_inventory.Where((ItemData item) => (!areaForQuickStack) ? ShouldRestockItem(player, playerInventory, item) : ShouldQuickStackItem(player, playerInventory, item, includeHotbar: false)).ToList();
			list.Sort((ItemData left, ItemData right) => -CompareGridOrder(left.m_gridPos, right.m_gridPos));
			float num = Math.Max(0f, (!areaForQuickStack) ? (_areaRestockRange?.Value ?? 0f) : (_areaQuickStackRange?.Value ?? 0f));
			MultiUserContainerBatchState multiUserContainerBatchState = new MultiUserContainerBatchState
			{
				Kind = kind,
				AreaRangeSquared = num * num
			};
			foreach (Container item in actionContainers)
			{
				ZNetView nview = item.m_nview;
				ZDO val = ((nview != null) ? nview.GetZDO() : null);
				multiUserContainerBatchState.Containers.Add(new MultiUserContainerBatchTarget
				{
					Container = item,
					ContainerId = (val?.m_uid ?? ZDOID.None),
					HasContainerId = (val != null)
				});
			}
			foreach (ItemData item2 in list)
			{
				if (!TryCreateMultiUserContainerBatchItem(item2, out MultiUserContainerBatchItem batchItem))
				{
					ShowMultiUserContainerNotReady();
					return true;
				}
				batchItem.ExpectedStack = item2.m_stack;
				if (!areaForQuickStack)
				{
					batchItem.RemainingAmount = Math.Max(0, GetRestockTargetStack(item2) - item2.m_stack);
				}
				multiUserContainerBatchState.Items.Add(batchItem);
			}
			InventoryGui instance = InventoryGui.instance;
			if (instance != null)
			{
				instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
			}
			_multiUserContainerBatch = multiUserContainerBatchState;
			UpdateMultiUserContainerBatchRuntime();
			return true;
		}

		internal static bool TryStartMultiUserContainerPlaceStacksBatch(Container container)
		{
			//IL_00ee: 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)
			if (!TryGetMultiUserContainerBatchContext(container, out Player player, out Inventory playerInventory, out Inventory _, out ZDOID containerId))
			{
				return false;
			}
			List<ItemData> list = playerInventory.m_inventory.Where((ItemData item) => ShouldQuickStackItem(player, playerInventory, item, includeHotbar: false)).ToList();
			list.Sort((ItemData left, ItemData right) => -CompareGridOrder(left.m_gridPos, right.m_gridPos));
			List<MultiUserContainerBatchItem> list2 = new List<MultiUserContainerBatchItem>();
			foreach (ItemData item in list)
			{
				if (!TryCreateMultiUserContainerBatchItem(item, out MultiUserContainerBatchItem batchItem))
				{
					return false;
				}
				list2.Add(batchItem);
			}
			if (list2.Count == 0)
			{
				ShowContainerActionResult(player, "$inventoryslots_action_stack", "Stack", 0);
				return true;
			}
			InventoryGui instance = InventoryGui.instance;
			if (instance != null)
			{
				instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
			}
			_multiUserContainerBatch = new MultiUserContainerBatchState
			{
				Kind = MultiUserContainerBatchKind.PlaceStacks,
				ContainerId = containerId
			};
			_multiUserContainerBatch.Items.AddRange(list2);
			UpdateMultiUserContainerBatchRuntime();
			return true;
		}

		internal static void UpdateMultiUserContainerBatchRuntime()
		{
			//IL_015f: 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)
			MultiUserContainerBatchState multiUserContainerBatch = _multiUserContainerBatch;
			if (multiUserContainerBatch == null || multiUserContainerBatch.WaitingForTransfer || _pendingMultiUserContainerTransfer != null)
			{
				return;
			}
			if (IsAreaMultiUserContainerBatch(multiUserContainerBatch))
			{
				UpdateMultiUserContainerAreaBatchRuntime(multiUserContainerBatch);
				return;
			}
			if (!TryGetCurrentMultiUserContainerBatchContext(multiUserContainerBatch, out Container container, out Player player, out Inventory playerInventory, out Inventory containerInventory))
			{
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			while (multiUserContainerBatch.ItemIndex < multiUserContainerBatch.Items.Count)
			{
				MultiUserContainerBatchItem multiUserContainerBatchItem = multiUserContainerBatch.Items[multiUserContainerBatch.ItemIndex];
				ItemData itemAt = ((multiUserContainerBatch.Kind == MultiUserContainerBatchKind.TakeAll) ? containerInventory : playerInventory).GetItemAt(multiUserContainerBatchItem.SourcePosition.x, multiUserContainerBatchItem.SourcePosition.y);
				if (itemAt?.m_shared == null || itemAt.m_stack != multiUserContainerBatchItem.RemainingAmount || !IsExactMultiUserContainerItemMatch(multiUserContainerBatchItem.Identity, itemAt, 1))
				{
					FinishMultiUserContainerBatch(showResult: true);
					return;
				}
				bool flag;
				Vector2i target;
				int amount;
				if (multiUserContainerBatch.Kind == MultiUserContainerBatchKind.TakeAll)
				{
					flag = TryPlanNextMultiUserContainerTakeAllStep(player, playerInventory, itemAt, multiUserContainerBatchItem.RemainingAmount, out target, out amount);
				}
				else
				{
					if (!ShouldQuickStackItem(player, playerInventory, itemAt, includeHotbar: false) || !DoesMultiUserContainerAcceptPlaceStacksItem(containerInventory, itemAt))
					{
						multiUserContainerBatch.ItemIndex++;
						continue;
					}
					flag = TryPlanNextMultiUserContainerPlaceStacksStep(containerInventory, itemAt, multiUserContainerBatchItem.RemainingAmount, out target, out amount);
				}
				if (!flag)
				{
					multiUserContainerBatch.ItemIndex++;
					continue;
				}
				multiUserContainerBatch.PendingAmount = amount;
				multiUserContainerBatch.WaitingForTransfer = true;
				if (!((multiUserContainerBatch.Kind == MultiUserContainerBatchKind.TakeAll) ? TryStartMultiUserContainerRemove(container, playerInventory, itemAt, amount, target, MultiUserContainerRecoveryMode.BatchInventoryFirst) : TryStartMultiUserContainerAdd(container, playerInventory, itemAt, amount, target, MultiUserContainerRecoveryMode.BatchInventoryFirst)))
				{
					multiUserContainerBatch.WaitingForTransfer = false;
					multiUserContainerBatch.PendingAmount = 0;
					FinishMultiUserContainerBatch(showResult: true);
				}
				return;
			}
			FinishMultiUserContainerBatch(showResult: true);
		}

		private static void UpdateMultiUserContainerAreaBatchRuntime(MultiUserContainerBatchState batch)
		{
			//IL_0069: 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_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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetMultiUserContainerAreaBatchContext(batch, out Player player, out Inventory playerInventory))
			{
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			if (batch.Containers.Count == 0)
			{
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			Container val = TryResolveMultiUserContainerBatchTarget(batch.Containers[0]);
			float num = 10f;
			if (!((Object)(object)val == (Object)null) && val.m_inventory != null && CanHandleContainerAreaAction(player, val) && HasContainerPlayerAccess(player, val, flashGuardStone: false))
			{
				Vector3 val2 = ((Component)player).transform.position - ((Component)val).transform.position;
				if (!(((Vector3)(ref val2)).sqrMagnitude > num * num))
				{
					while (batch.ContainerIndex < batch.Containers.Count)
					{
						MultiUserContainerBatchTarget multiUserContainerBatchTarget = batch.Containers[batch.ContainerIndex];
						Container val3 = TryResolveMultiUserContainerBatchTarget(multiUserContainerBatchTarget);
						if (!((Object)(object)val3 == (Object)null) && val3.m_inventory != null)
						{
							if (batch.ContainerIndex > 0)
							{
								val2 = ((Component)val3).transform.position - ((Component)val).transform.position;
								if (((Vector3)(ref val2)).sqrMagnitude > batch.AreaRangeSquared)
								{
									goto IL_0106;
								}
							}
							if (HasContainerPlayerAccess(player, val3, flashGuardStone: false))
							{
								switch (GetContainerAccessMode(val3, !multiUserContainerBatchTarget.HasContainerId))
								{
								case ContainerAccessMode.DirectOwner:
									if (batch.ContainerIndex > 0 && !IsBuiltInMultiUserContainerEligible(val3) && IsContainerInUse(val3))
									{
										AdvanceMultiUserContainerAreaBatchContainer(batch);
										break;
									}
									if (!TryProcessDirectMultiUserContainerAreaBatchTarget(batch, multiUserContainerBatchTarget, player, playerInventory, val3))
									{
										FinishMultiUserContainerBatch(showResult: true);
										return;
									}
									AdvanceMultiUserContainerAreaBatchContainer(batch);
									break;
								case ContainerAccessMode.MultiUserChestRemote:
									if (CanUseBuiltInRemoteAreaContainer(player, val3))
									{
										if (!TryStartNextRemoteMultiUserContainerAreaBatchStep(batch, player, playerInventory, val3))
										{
											FinishMultiUserContainerBatch(showResult: true);
											return;
										}
										if (batch.WaitingForTransfer)
										{
											return;
										}
										AdvanceMultiUserContainerAreaBatchContainer(batch);
										break;
									}
									goto default;
								default:
									AdvanceMultiUserContainerAreaBatchContainer(batch);
									break;
								}
								continue;
							}
						}
						goto IL_0106;
						IL_0106:
						AdvanceMultiUserContainerAreaBatchContainer(batch);
					}
					FinishMultiUserContainerBatch(showResult: true);
					return;
				}
			}
			FinishMultiUserContainerBatch(showResult: true);
		}

		internal static void OnMultiUserContainerTransferCompleted(bool committedAndObserved)
		{
			MultiUserContainerBatchState multiUserContainerBatch = _multiUserContainerBatch;
			if (multiUserContainerBatch == null || !multiUserContainerBatch.WaitingForTransfer)
			{
				return;
			}
			multiUserContainerBatch.WaitingForTransfer = false;
			if (IsAreaMultiUserContainerBatch(multiUserContainerBatch))
			{
				CompleteMultiUserContainerAreaBatchStep(multiUserContainerBatch, committedAndObserved);
				return;
			}
			if (!committedAndObserved || multiUserContainerBatch.PendingAmount <= 0 || multiUserContainerBatch.ItemIndex < 0 || multiUserContainerBatch.ItemIndex >= multiUserContainerBatch.Items.Count)
			{
				multiUserContainerBatch.PendingAmount = 0;
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			MultiUserContainerBatchItem multiUserContainerBatchItem = multiUserContainerBatch.Items[multiUserContainerBatch.ItemIndex];
			if (multiUserContainerBatch.PendingAmount > multiUserContainerBatchItem.RemainingAmount)
			{
				multiUserContainerBatch.PendingAmount = 0;
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			multiUserContainerBatchItem.RemainingAmount -= multiUserContainerBatch.PendingAmount;
			multiUserContainerBatch.PendingAmount = 0;
			if (!multiUserContainerBatchItem.MovedAny)
			{
				multiUserContainerBatchItem.MovedAny = true;
				multiUserContainerBatch.MovedStacks++;
			}
			if (multiUserContainerBatchItem.RemainingAmount == 0)
			{
				multiUserContainerBatch.ItemIndex++;
			}
		}

		private static void CompleteMultiUserContainerAreaBatchStep(MultiUserContainerBatchState batch, bool committedAndObserved)
		{
			if (!committedAndObserved || batch.PendingAmount <= 0 || batch.ContainerIndex < 0 || batch.ContainerIndex >= batch.Containers.Count || batch.ItemIndex < 0 || batch.ItemIndex >= batch.Items.Count)
			{
				batch.PendingAmount = 0;
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			MultiUserContainerBatchItem multiUserContainerBatchItem = batch.Items[batch.ItemIndex];
			int pendingAmount = batch.PendingAmount;
			if (pendingAmount > multiUserContainerBatchItem.RemainingAmount)
			{
				batch.PendingAmount = 0;
				FinishMultiUserContainerBatch(showResult: true);
				return;
			}
			multiUserContainerBatchItem.RemainingAmount -= pendingAmount;
			if (batch.Kind == MultiUserContainerBatchKind.AreaPlaceStacks)
			{
				multiUserContainerBatchItem.ExpectedStack -= pendingAmount;
				if (multiUserContainerBatchItem.RemainingAmount == 0 && !multiUserContainerBatchItem.MovedAny)
				{
					multiUserContainerBatchItem.MovedAny = true;
					batch.MovedStacks++;
				}
			}
			else
			{
				multiUserContainerBatchItem.ExpectedStack += pendingAmount;
				batch.MovedAmount += pendingAmount;
			}
			batch.PendingAmount = 0;
			MarkMultiUserContainerAreaBatchTargetMoved(batch);
			if (multiUserContainerBatchItem.RemainingAmount == 0)
			{
				batch.ItemIndex++;
			}
		}

		internal static void CancelMultiUserContainerBatch(bool includeAreaBatch = true)
		{
			if (includeAreaBatch || !IsAreaMultiUserContainerBatch(_multiUserContainerBatch))
			{
				_multiUserContainerBatch = null;
			}
		}

		private static bool IsAreaMultiUserContainerBatch(MultiUserContainerBatchState? batch)
		{
			bool flag = batch != null;
			if (flag)
			{
				MultiUserContainerBatchKind kind = batch.Kind;
				bool flag2 = (uint)(kind - 2) <= 1u;
				flag = flag2;
			}
			return flag;
		}

		private static bool IsMultiUserContainerAreaBatchActive()
		{
			return IsAreaMultiUserContainerBatch(_multiUserContainerBatch);
		}

		private static bool TryGetMultiUserContainerAreaBatchContext(MultiUserContainerBatchState batch, out Player player, out Inventory playerInventory)
		{
			player = null;
			playerInventory = null;
			Player localPlayer = Player.m_localPlayer;
			Inventory val = (((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer)) ? ((Humanoid)localPlayer).GetInventory() : null);
			if (!IsAreaMultiUserContainerBatch(batch) || !IsBuiltInMultiUserChestEnabled || (Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || localPlayer.m_isLoading || val == null)
			{
				return false;
			}
			player = localPlayer;
			playerInventory = val;
			return true;
		}

		private static Container? TryResolveMultiUserContainerBatchTarget(MultiUserContainerBatchTarget target)
		{
			//IL_005b: 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)
			if (target == null)
			{
				return null;
			}
			Container container = target.Container;
			if ((Object)(object)container != (Object)null && !IsUnityNull((Object?)(object)container))
			{
				if (!target.HasContainerId)
				{
					return container;
				}
				ZDO val = (((Object)(object)container.m_nview != (Object)null && container.m_nview.IsValid()) ? container.m_nview.GetZDO() : null);
				if (val != null && ((ZDOID)(ref val.m_uid)).Equals(target.ContainerId))
				{
					return container;
				}
			}
			if (!target.HasContainerId)
			{
				return null;
			}
			for (int num = InventoryContainers.KnownContainers.Count - 1; num >= 0; num--)
			{
				Container val2 = InventoryContainers.KnownContainers[num];
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
				{
					ZDO val3 = (((Object)(object)val2.m_nview != (Object)null && val2.m_nview.IsValid()) ? val2.m_nview.GetZDO() : null);
					if (val3 != null && ((ZDOID)(ref val3.m_uid)).Equals(target.ContainerId))
					{
						target.Container = val2;
						return val2;
					}
				}
			}
			return null;
		}

		private static void AdvanceMultiUserContainerAreaBatchContainer(MultiUserContainerBatchState batch)
		{
			batch.ContainerIndex++;
			batch.ItemIndex = 0;
			batch.PendingAmount = 0;
		}

		private static bool TryProcessDirectMultiUserContainerAreaBatchTarget(MultiUserContainerBatchState batch, MultiUserContainerBatchTarget target, Player player, Inventory playerInventory, Container container)
		{
			Inventory inventory = container.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			while (batch.ItemIndex < batch.Items.Count)
			{
				MultiUserContainerBatchItem multiUserContainerBatchItem = batch.Items[batch.ItemIndex];
				if (multiUserContainerBatchItem.RemainingAmount <= 0)
				{
					batch.ItemIndex++;
					continue;
				}
				ItemData itemAt = playerInventory.GetItemAt(multiUserContainerBatchItem.SourcePosition.x, multiUserContainerBatchItem.SourcePosition.y);
				if (itemAt?.m_shared == null || itemAt.m_stack != multiUserContainerBatchItem.ExpectedStack || !IsExactMultiUserContainerItemMatch(multiUserContainerBatchItem.Identity, itemAt, 1))
				{
					return false;
				}
				int stack = itemAt.m_stack;
				int num2;
				if (batch.Kind == MultiUserContainerBatchKind.AreaPlaceStacks)
				{
					if (!ShouldQuickStackItem(player, playerInventory, itemAt, includeHotbar: false))
					{
						multiUserContainerBatchItem.RemainingAmount = 0;
						batch.ItemIndex++;
						continue;
					}
					QuickStackItemsIntoContainer(playerInventory, inventory, new List<ItemData> { itemAt });
					int num = (playerInventory.m_inventory.Contains(itemAt) ? itemAt.m_stack : 0);
					num2 = stack - num;
					if (num2 < 0 || num2 > multiUserContainerBatchItem.RemainingAmount)
					{
						return false;
					}
					if (num2 > 0)
					{
						multiUserContainerBatchItem.ExpectedStack = num;
						multiUserContainerBatchItem.RemainingAmount -= num2;
						if (multiUserContainerBatchItem.RemainingAmount == 0 && !multiUserContainerBatchItem.MovedAny)
						{
							multiUserContainerBatchItem.MovedAny = true;
							batch.MovedStacks++;
						}
					}
				}
				else
				{
					if (!ShouldRestockItem(player, playerInventory, itemAt))
					{
						multiUserContainerBatchItem.RemainingAmount = 0;
						batch.ItemIndex++;
						continue;
					}
					int num3 = multiUserContainerBatchItem.ExpectedStack + multiUserContainerBatchItem.RemainingAmount;
					if (GetRestockTargetStack(itemAt) != num3)
					{
						return false;
					}
					RestockTargetsFromContainer(playerInventory, inventory, new List<ItemData> { itemAt }, ContainerTakeStacksMode.AreaFavoriteRestock);
					if (!playerInventory.m_inventory.Contains(itemAt))
					{
						return false;
					}
					int stack2 = itemAt.m_stack;
					num2 = stack2 - stack;
					if (num2 < 0 || num2 > multiUserContainerBatchItem.RemainingAmount)
					{
						return false;
					}
					if (num2 > 0)
					{
						multiUserContainerBatchItem.ExpectedStack = stack2;
						multiUserContainerBatchItem.RemainingAmount -= num2;
						batch.MovedAmount += num2;
					}
				}
				if (num2 > 0)
				{
					MarkMultiUserContainerAreaBatchTargetMoved(batch, target);
					playerInventory.Changed();
				}
				batch.ItemIndex++;
			}
			return true;
		}

		private static bool TryStartNextRemoteMultiUserContainerAreaBatchStep(MultiUserContainerBatchState batch, Player player, Inventory playerInventory, Container container)
		{
			//IL_0140: 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_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = container.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			while (batch.ItemIndex < batch.Items.Count)
			{
				MultiUserContainerBatchItem multiUserContainerBatchItem = batch.Items[batch.ItemIndex];
				if (multiUserContainerBatchItem.RemainingAmount <= 0)
				{
					batch.ItemIndex++;
					continue;
				}
				ItemData itemAt = playerInventory.GetItemAt(multiUserContainerBatchItem.SourcePosition.x, multiUserContainerBatchItem.SourcePosition.y);
				if (itemAt?.m_shared == null || itemAt.m_stack != multiUserContainerBatchItem.ExpectedStack || !IsExactMultiUserContainerItemMatch(multiUserContainerBatchItem.Identity, itemAt, 1))
				{
					return false;
				}
				Vector2i target;
				int amount;
				ItemData val;
				if (batch.Kind == MultiUserContainerBatchKind.AreaPlaceStacks)
				{
					if (multiUserContainerBatchItem.RemainingAmount != multiUserContainerBatchItem.ExpectedStack || !ShouldQuickStackItem(player, playerInventory, itemAt, includeHotbar: false))
					{
						multiUserContainerBatchItem.RemainingAmount = 0;
						batch.ItemIndex++;
						continue;
					}
					if (!DoesMultiUserContainerAcceptPlaceStacksItem(inventory, itemAt) || !TryPlanNextMultiUserContainerPlaceStacksStep(inventory, itemAt, multiUserContainerBatchItem.RemainingAmount, out target, out amount))
					{
						batch.ItemIndex++;
						continue;
					}
					val = itemAt;
				}
				else
				{
					if (!ShouldRestockItem(player, playerInventory, itemAt))
					{
						multiUserContainerBatchItem.RemainingAmount = 0;
						batch.ItemIndex++;
						continue;
					}
					int num = multiUserContainerBatchItem.ExpectedStack + multiUserContainerBatchItem.RemainingAmount;
					if (GetRestockTargetStack(itemAt) != num)
					{
						return false;
					}
					val = null;
					amount = 0;
					target = itemAt.m_gridPos;
					int val2 = Math.Max(0, itemAt.m_shared.m_maxStackSize - itemAt.m_stack);
					for (int num2 = inventory.m_inventory.Count - 1; num2 >= 0; num2--)
					{
						ItemData val3 = inventory.m_inventory[num2];
						int num3 = Math.Min(Math.Min(multiUserContainerBatchItem.RemainingAmount, val3?.m_stack ?? 0), val2);
						if (num3 > 0 && val3?.m_shared != null && CanRestockFromContainerItem(itemAt, val3) && CanStackEntireMultiUserContainerItem(val3, itemAt, num3))
						{
							val = val3;
							amount = num3;
							break;
						}
					}
					if (val?.m_shared == null || amount <= 0)
					{
						batch.ItemIndex++;
						continue;
					}
				}
				batch.PendingAmount = amount;
				batch.WaitingForTransfer = true;
				if (!((batch.Kind == MultiUserContainerBatchKind.AreaPlaceStacks) ? TryStartMultiUserContainerAdd(container, playerInventory, val, amount, target, MultiUserContainerRecoveryMode.BatchInventoryFirst) : TryStartMultiUserContainerRemove(container, playerInventory, val, amount, target)))
				{
					batch.WaitingForTransfer = false;
					batch.PendingAmount = 0;
					return false;
				}
				return true;
			}
			return true;
		}

		private static void MarkMultiUserContainerAreaBatchTargetMoved(MultiUserContainerBatchState batch)
		{
			if (batch.ContainerIndex >= 0 && batch.ContainerIndex < batch.Containers.Count)
			{
				MarkMultiUserContainerAreaBatchTargetMoved(batch, batch.Containers[batch.ContainerIndex]);
			}
		}

		private static void MarkMultiUserContainerAreaBatchTargetMoved(MultiUserContainerBatchState batch, MultiUserContainerBatchTarget target)
		{
			if (!target.MovedAny)
			{
				target.MovedAny = true;
				int limit = (IsContainerActionSuccessFxEnabled() ? 10 : 0);
				Container val = TryResolveMultiUserContainerBatchTarget(target);
				if ((Object)(object)val != (Object)null)
				{
					batch.ChangedContainerVfxCount = TryPlayChangedContainerActionSuccessVfx(val, limit, batch.ChangedContainerVfxCount);
				}
			}
		}

		private static bool TryGetMultiUserContainerBatchContext(Container container, out Player player, out Inventory playerInventory, out Inventory containerInventory, out ZDOID containerId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			player = null;
			playerInventory = null;
			containerInventory = null;
			containerId = default(ZDOID);
			if (_multiUserContainerBatch != null || _pendingMultiUserContainerTransfer != null || !IsBuiltInMultiUserChestEnabled || (Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || GetContainerAccessMode(container, allowLocalWithoutZNetView: true) != ContainerAccessMode.MultiUserChestRemote || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid() || (Object)(object)InventoryGui.instance == (Object)null || IsUnityNull((Object?)(object)InventoryGui.instance) || (Object)(object)InventoryGui.instance.m_currentContainer != (Object)(object)container)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			ZDO zDO = container.m_nview.GetZDO();
			Inventory val = (((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer)) ? ((Humanoid)localPlayer).GetInventory() : null);
			Inventory inventory = container.GetInventory();
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || localPlayer.m_isLoading || zDO == null || val == null || inventory == null)
			{
				return false;
			}
			player = localPlayer;
			playerInventory = val;
			containerInventory = inventory;
			containerId = zDO.m_uid;
			return true;
		}

		private static bool TryGetCurrentMultiUserContainerBatchContext(MultiUserContainerBatchState batch, out Container container, out Player player, out Inventory playerInventory, out Inventory containerInventory)
		{
			container = null;
			player = null;
			playerInventory = null;
			containerInventory = null;
			InventoryGui instance = InventoryGui.instance;
			Player localPlayer = Player.m_localPlayer;
			if (batch == null || (Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance) || (Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || localPlayer.m_isLoading || (Object)(object)instance.m_currentContainer == (Object)null || !IsSameMultiUserContainerBatchContainer(batch, instance.m_currentContainer))
			{
				return false;
			}
			Container currentContainer = instance.m_currentContainer;
			if (GetContainerAccessMode(currentContainer, allowLocalWithoutZNetView: true) != ContainerAccessMode.MultiUserChestRemote)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			Inventory inventory2 = currentContainer.GetInventory();
			if (inventory == null || inventory2 == null)
			{
				return false;
			}
			container = currentContainer;
			player = localPlayer;
			playerInventory = inventory;
			containerInventory = inventory2;
			return true;
		}

		private static bool IsSameMultiUserContainerBatchContainer(MultiUserContainerBatchState batch, Container container)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (batch == null || (Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = container.m_nview.GetZDO();
			if (zDO != null)
			{
				return ((ZDOID)(ref zDO.m_uid)).Equals(batch.ContainerId);
			}
			return false;
		}

		private static bool TryCreateMultiUserContainerBatchItem(ItemData item, out MultiUserContainerBatchItem? batchItem)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			batchItem = null;
			if (item?.m_shared == null || item.m_stack <= 0)
			{
				return false;
			}
			ItemData identity;
			try
			{
				identity = item.Clone();
			}
			catch
			{
				return false;
			}
			batchItem = new MultiUserContainerBatchItem
			{
				SourcePosition = item.m_gridPos,
				Identity = identity,
				RemainingAmount = item.m_stack,
				ExpectedStack = item.m_stack
			};
			return true;
		}

		private static bool TryPlanNextMultiUserContainerTakeAllStep(Player player, Inventory playerInventory, ItemData source, int remainingAmount, out Vector2i target, out int amount)
		{
			//IL_0004: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			target = new Vector2i(-1, -1);
			amount = 0;
			List<Vector2i> playerActionSlots = GetPlayerActionSlots(player, playerInventory, includeHotbar: false, blockFavorites: true);
			HashSet<Vector2i> allowedSlots = new HashSet<Vector2i>(playerActionSlots);
			int maxAllowed;
			if (source.m_shared.m_maxStackSize > 1 && CanUseContainerActionStacking(source))
			{
				foreach (ItemData safeTakeAllStackTarget in GetSafeTakeAllStackTargets(playerInventory, source, allowedSlots))
				{
					int val = Math.Max(0, safeTakeAllStackTarget.m_shared.m_maxStackSize - safeTakeAllStackTarget.m_stack);
					int num = Math.Min(Math.Min(source.m_stack, remainingAmount), val);
					if (num > 0 && CanAddWithinInventoryLimits(playerInventory, source, num, out maxAllowed))
					{
						target = safeTakeAllStackTarget.m_gridPos;
						amount = num;
						return true;
					}
				}
			}
			foreach (Vector2i safeTakeAllEmptySlot in GetSafeTakeAllEmptySlots(playerInventory, playerActionSlots))
			{
				int num2 = Math.Min(Math.Min(source.m_stack, remainingAmount), Math.Max(1, source.m_shared.m_maxStackSize));
				if (num2 > 0 && CanAddWithinInventoryLimits(playerInventory, source, num2, out maxAllowed))
				{
					target = safeTakeAllEmptySlot;
					amount = num2;
					return true;
				}
			}
			return false;
		}

		private static bool DoesMultiUserContainerAcceptPlaceStacksItem(Inventory containerInventory, ItemData source)
		{
			string sourceName = source.m_shared?.m_name ?? "";
			if (!string.IsNullOrEmpty(sourceName))
			{
				return containerInventory.m_inventory.Any((ItemData item) => item?.m_shared != null && string.Equals(item.m_shared.m_name, sourceName, StringComparison.OrdinalIgnoreCase));
			}
			return false;
		}

		private static bool TryPlanNextMultiUserContainerPlaceStacksStep(Inventory containerInventory, ItemData source, int remainingAmount, out Vector2i target, out int amount)
		{
			//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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			target = new Vector2i(-1, -1);
			amount = 0;
			foreach (ItemData item in from item in containerInventory.m_inventory
				where item?.m_shared != null
				orderby item.m_gridPos.y, item.m_gridPos.x
				select item)
			{
				int val = Math.Max(0, item.m_shared.m_maxStackSize - item.m_stack);
				int num = Math.Min(Math.Min(source.m_stack, remainingAmount), val);
				if (num > 0 && CanStackEntireMultiUserContainerItem(source, item, num))
				{
					target = item.m_gridPos;
					amount = num;
					return true;
				}
			}
			int width = containerInventory.GetWidth();
			int height = containerInventory.GetHeight();
			for (int num2 = 0; num2 < height; num2++)
			{
				for (int num3 = 0; num3 < width; num3++)
				{
					if (containerInventory.GetItemAt(num3, num2) == null)
					{
						target = new Vector2i(num3, num2);
						amount = Math.Min(Math.Min(source.m_stack, remainingAmount), Math.Max(1, source.m_shared.m_maxStackSize));
						return amount > 0;
					}
				}
			}
			return false;
		}

		private static void FinishMultiUserContainerBatch(bool showResult)
		{
			MultiUserContainerBatchState multiUserContainerBatch = _multiUserContainerBatch;
			_multiUserContainerBatch = null;
			if (multiUserContainerBatch == null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (IsAreaMultiUserContainerBatch(multiUserContainerBatch))
			{
				int num = ((multiUserContainerBatch.Kind == MultiUserContainerBatchKind.AreaPlaceStacks) ? multiUserContainerBatch.MovedStacks : multiUserContainerBatch.MovedAmount);
				if (num > 0)
				{
					Inventory obj = (((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer)) ? ((Humanoid)localPlayer).GetInventory() : null);
					if (obj != null)
					{
						obj.Changed();
					}
					ClearCraftingRequirementAvailabilityCache();
					if (IsContainerActionSuccessFxEnabled() && multiUserContainerBatch.Containers.Count > 0)
					{
						Container val = TryResolveMultiUserContainerBatchTarget(multiUserContainerBatch.Containers[0]);
						if ((Object)(object)val != (Object)null)
						{
							PlayContainerActionSuccessSfx(val);
						}
					}
				}
				if (showResult && (Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer))
				{
					bool flag = multiUserContainerBatch.Kind == MultiUserContainerBatchKind.AreaPlaceStacks;
					ShowContainerActionResult(localPlayer, flag ? "$inventoryslots_action_stack" : "$inventoryslots_action_take_stacks", flag ? "Stack" : "Take stacks", num);
				}
			}
			else if (showResult && multiUserContainerBatch.Kind == MultiUserContainerBatchKind.PlaceStacks && (Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer))
			{
				ShowContainerActionResult(localPlayer, "$inventoryslots_action_stack", "Stack", multiUserContainerBatch.MovedStacks);
			}
		}

		internal static bool TryFindMultiUserContainerDestination(Inventory inventory, ItemData incoming, int amount, out Vector2i destination)
		{
			//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_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_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)
			destination = new Vector2i(-1, -1);
			if (!IsValidMultiUserContainerInventory(inventory) || !IsValidMultiUserContainerMutationItem(incoming) || amount <= 0 || amount > incoming.m_stack || amount > incoming.m_shared.m_maxStackSize)
			{
				return false;
			}
			MultiUserContainerItemSnapshot multiUserContainerItemSnapshot = CreateMultiUserContainerItemSnapshot(incoming);
			if (multiUserContainerItemSnapshot == null)
			{
				return false;
			}
			int width = inventory.GetWidth();
			int height = inventory.GetHeight();
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					ItemData itemAt = inventory.GetItemAt(j, i);
					if (CanAcceptEntireMultiUserContainerStack(multiUserContainerItemSnapshot, incoming.m_shared.m_maxStackSize, itemAt, amount))
					{
						destination = new Vector2i(j, i);
						return true;
					}
				}
			}
			for (int k = 0; k < height; k++)
			{
				for (int l = 0; l < width; l++)
				{
					if (inventory.GetItemAt(l, k) == null)
					{
						destination = new Vector2i(l, k);
						return true;
					}
				}
			}
			return false;
		}

		internal static bool TryApplyMultiUserContainerAdd(Inventory inventory, ItemData incoming, int amount, Vector2i targetPosition, int expectedTargetStack)
		{
			//IL_0001: 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)
			//IL_0065: 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 (!IsValidMultiUserContainerCoordinate(inventory, targetPosition) || !IsValidMultiUserContainerMutationItem(incoming) || amount <= 0 || amount > incoming.m_stack || amount > incoming.m_shared.m_maxStackSize || expectedTargetStack < 0)
			{
				return false;
			}
			ItemData val;
			try
			{
				val = incoming.Clone();
			}
			catch
			{
				return false;
			}
			if (!IsValidMultiUserContainerMutationItem(val))
			{
				return false;
			}
			val.m_stack = amount;
			val.m_gridPos = targetPosition;
			val.m_equipped = false;
			ItemData itemAt = inventory.GetItemAt(targetPosition.x, targetPosition.y);
			if (itemAt == null)
			{
				if (!MultiUserContainerTransferCore.MatchesExpectedStackState(expectedTargetStack, null))
				{
					return false;
				}
				inventory.m_inventory.Add(val);
				NotifyMultiUserContainerInventoryChanged(inventory);
				return true;
			}
			MultiUserContainerItemSnapshot multiUserContainerItemSnapshot = CreateMultiUserContainerItemSnapshot(val);
			if (!MultiUserContainerTransferCore.MatchesExpectedStackState(expectedTargetStack, itemAt.m_stack) || multiUserContainerItemSnapshot == null || !CanAcceptEntireMultiUserContainerStack(multiUserContainerItemSnapshot, val.m_shared.m_maxStackSize, itemAt, amount))
			{
				return false;
			}
			itemAt.m_stack += amount;
			itemAt.m_equipped = false;
			NotifyMultiUserContainerInventoryChanged(inventory);
			return true;
		}

		internal static bool TryApplyMultiUserContainerRemove(Inventory inventory, ItemData expected, int amount, Vector2i sourcePosition, out ItemData removed)
		{
			//IL_0005: 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_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_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_0096: 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)
			removed = null;
			if (!IsValidMultiUserContainerCoordinate(inventory, sourcePosition) || !IsValidMultiUserContainerMutationItem(expected) || expected.m_gridPos != sourcePosition || amount <= 0 || amount > expected.m_stack)
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(sourcePosition.x, sourcePosition.y);
			if (!IsValidMultiUserContainerMutationItem(itemAt) || itemAt.m_gridPos != sourcePosition || !MultiUserContainerTransferCore.MatchesExpectedStackState(expected.m_stack, itemAt.m_stack) || !IsExactMultiUserContainerItemMatch(expected, itemAt, amount))
			{
				return false;
			}
			ItemData val;
			try
			{
				val = itemAt.Clone();
			}
			catch
			{
				return false;
			}
			val.m_stack = amount;
			val.m_gridPos = sourcePosition;
			val.m_equipped = false;
			if (amount == itemAt.m_stack)
			{
				if (!inventory.m_inventory.Remove(itemAt))
				{
					return false;
				}
			}
			else
			{
				itemAt.m_stack -= amount;
			}
			removed = val;
			NotifyMultiUserContainerInventoryChanged(inventory);
			return true;
		}

		internal static bool TryApplyMultiUserContainerMove(Inventory inventory, ItemData expected, int amount, Vector2i sourcePosition, Vector2i targetPosition, int expectedTargetStack)
		{
			//IL_0001: 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_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_003e: 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_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_008a: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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)
			if (!IsValidMultiUserContainerCoordinate(inventory, sourcePosition) || !IsValidMultiUserContainerCoordinate(inventory, targetPosition) || !IsValidMultiUserContainerMutationItem(expected) || expected.m_gridPos != sourcePosition || amount <= 0 || amount > expected.m_stack || expectedTargetStack < 0)
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(sourcePosition.x, sourcePosition.y);
			if (!IsValidMultiUserContainerMutationItem(itemAt) || itemAt.m_gridPos != sourcePosition || !MultiUserContainerTransferCore.MatchesExpectedStackState(expected.m_stack, itemAt.m_stack) || !IsExactMultiUserContainerItemMatch(expected, itemAt, amount))
			{
				return false;
			}
			if (sourcePosition == targetPosition)
			{
				return MultiUserContainerTransferCore.MatchesExpectedStackState(expectedTargetStack, itemAt.m_stack);
			}
			ItemData itemAt2 = inventory.GetItemAt(targetPosition.x, targetPosition.y);
			if (itemAt2 == null)
			{
				if (!MultiUserContainerTransferCore.MatchesExpectedStackState(expectedTargetStack, null))
				{
					return false;
				}
				if (amount == itemAt.m_stack)
				{
					itemAt.m_gridPos = targetPosition;
					itemAt.m_equipped = false;
					NotifyMultiUserContainerInventoryChanged(inventory);
					return true;
				}
				ItemData val;
				try
				{
					val = itemAt.Clone();
				}
				catch
				{
					return false;
				}
				val.m_stack = amount;
				val.m_gridPos = targetPosition;
				val.m_equipped = false;
				itemAt.m_stack -= amount;
				inventory.m_inventory.Add(val);
				NotifyMultiUserContainerInventoryChanged(inventory);
				return true;
			}
			MultiUserContainerItemSnapshot multiUserContainerItemSnapshot = CreateMultiUserContainerItemSnapshot(itemAt);
			if (!MultiUserContainerTransferCore.MatchesExpectedStackState(expectedTargetStack, itemAt2.m_stack) || multiUserContainerItemSnapshot == null || !CanAcceptEntireMultiUserContainerStack(multiUserContainerItemSnapshot, itemAt.m_shared.m_maxStackSize, itemAt2, amount))
			{
				return false;
			}
			itemAt2.m_stack += amount;
			itemAt2.m_equipped = false;
			itemAt.m_stack -= amount;
			if (itemAt.m_stack == 0)
			{
				inventory.m_inventory.Remove(itemAt);
			}
			NotifyMultiUserContainerInventoryChanged(inventory);
			return true;
		}

		internal static bool TryApplyMultiUserContainerExchange(Inventory inventory, ItemData expectedContainerItem, ItemData incoming, Vector2i containerPosition, out ItemData displaced)
		{
			//IL_0005: 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_0058: 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_0078: 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_00dd: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			displaced = null;
			if (!IsValidMultiUserContainerCoordinate(inventory, containerPosition) || !IsValidMultiUserContainerMutationItem(expectedContainerItem) || !IsValidMultiUserContainerMutationItem(incoming) || expectedContainerItem.m_gridPos != containerPosition || expectedContainerItem.m_equipped || incoming.m_equipped || expectedContainerItem.m_shared.m_questItem || incoming.m_shared.m_questItem)
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(containerPosition.x, containerPosition.y);
			if (!IsValidMultiUserContainerMutationItem(itemAt) || itemAt.m_gridPos != containerPosition || itemAt.m_equipped || !MultiUserContainerTransferCore.MatchesExpectedStackState(expectedContainerItem.m_stack, itemAt.m_stack) || !IsExactMultiUserContainerItemMatch(expectedContainerItem, itemAt, expectedContainerItem.m_stack))
			{
				return false;
			}
			int num = inventory.m_inventory.IndexOf(itemAt);
			if (num < 0)
			{
				return false;
			}
			ItemData val;
			ItemData val2;
			try
			{
				val = itemAt.Clone();
				val2 = incoming.Clone();
			}
			catch
			{
				return false;
			}
			val.m_gridPos = containerPosition;
			val.m_equipped = false;
			val2.m_gridPos = containerPosition;
			val2.m_equipped = false;
			if (!IsValidMultiUserContainerMutationItem(val) || !IsValidMultiUserContainerMutationItem(val2))
			{
				return false;
			}
			inventory.m_inventory[num] = val2;
			displaced = val;
			NotifyMultiUserContainerInventoryChanged(inventory);
			return true;
		}

		internal static bool TryApplyMultiUserContainerSwap(Inventory inventory, ItemData expectedSource, ItemData expectedTarget, Vector2i sourcePosition, Vector2i targetPosition)
		{
			//IL_0001: 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_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)
			//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_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_005d: 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: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_011d: 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)
			if (!IsValidMultiUserContainerCoordinate(inventory, sourcePosition) || !IsValidMultiUserContainerCoordinate(inventory, targetPosition) || sourcePosition == targetPosition || !IsValidMultiUserContainerMutationItem(expectedSource) || !IsValidMultiUserContainerMutationItem(expectedTarget) || expectedSource.m_gridPos != sourcePosition || expectedTarget.m_gridPos != targetPosition || expectedSource.m_equipped || expectedTarget.m_equipped)
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(sourcePosition.x, sourcePosition.y);
			ItemData itemAt2 = inventory.GetItemAt(targetPosition.x, targetPosition.y);
			if (!IsValidMultiUserContainerMutationItem(itemAt) || !IsValidMultiUserContainerMutationItem(itemAt2) || itemAt.m_gridPos != sourcePosition || itemAt2.m_gridPos != targetPosition || itemAt.m_equipped || itemAt2.m_equipped || !MultiUserContainerTransferCore.MatchesExpectedStackState(expectedSource.m_stack, itemAt.m_stack) || !MultiUserContainerTransferCore.MatchesExpectedStackState(expectedTarget.m_stack, itemAt2.m_stack) || !IsExactMultiUserContainerItemMatch(expectedSource, itemAt, expectedSource.m_stack) || !IsExactMultiUserContainerItemMatch(expectedTarget, itemAt2, expectedTarget.m_stack))
			{
				return false;
			}
			itemAt.m_gridPos = targetPosition;
			itemAt2.m_gridPos = sourcePosition;
			NotifyMultiUserContainerInventoryChanged(inventory);
			return true;
		}

		private static bool IsValidMultiUserContainerInventory(Inventory? inventory)
		{
			if (inventory != null && inventory.m_inventory != null && inventory.GetWidth() > 0)
			{
				return inventory.GetHeight() > 0;
			}
			return false;
		}

		private static bool IsValidMultiUserContainerCoordinate(Inventory? inventory, Vector2i position)
		{
			//IL_0008: 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_001a: 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 (IsValidMultiUserContainerInventory(inventory) && position.x >= 0 && position.y >= 0 && position.x < inventory.GetWidth())
			{
				return position.y < inventory.GetHeight();
			}
			return false;
		}

		private static bool IsValidMultiUserContainerMutationItem(ItemData? item)
		{
			if (item == null || item.m_shared == null || item.m_customData == null || item.m_crafterName == null || (Object)(object)item.m_dropPrefab == (Object)null || string.IsNullOrWhiteSpace(((Object)item.m_dropPrefab).name) || item.m_stack <= 0 || item.m_shared.m_maxStackSize <= 0 || item.m_stack > item.m_shared.m_maxStackSize || item.m_quality <= 0 || item.m_variant < 0 || item.m_worldLevel < 0 || float.IsNaN(item.m_durability) || float.IsInfinity(item.m_durability) || item.m_durability < 0f)
			{
				return false;
			}
			return CreateMultiUserContainerItemSnapshot(item) != null;
		}

		private static bool IsExactMultiUserContainerItemMatch(ItemData expected, ItemData actual, int requiredStack)
		{
			MultiUserContainerItemSnapshot? expected2 = CreateMultiUserContainerItemSnapshot(expected);
			MultiUserContainerItemSnapshot actual2 = CreateMultiUserContainerItemSnapshot(actual);
			return MultiUserContainerTransferCore.IsExactMatch(expected2, actual2, requiredStack);
		}

		private static bool CanAcceptEntireMultiUserContainerStack(MultiUserContainerItemSnapshot incomingSnapshot, int incomingMaxStack, ItemData? target, int amount)
		{
			if (!IsValidMultiUserContainerMutationItem(target) || target.m_equipped || incomingMaxStack <= 1 || target.m_shared.m_maxStackSize != incomingMaxStack || target.m_stack > incomingMaxStack - amount)
			{
				return false;
			}
			MultiUserContainerItemSnapshot actual = CreateMultiUserContainerItemSnapshot(target);
			return MultiUserContainerTransferCore.IsExactMatch(incomingSnapshot, actual, 1);
		}

		private static void NotifyMultiUserContainerInventoryChanged(Inventory inventory)
		{
			try
			{
				inventory.Changed();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest inventory change callback failed: " + ex.Message));
			}
		}

		internal static bool TryWriteMultiUserContainerItem(ZPackage? package, ItemData? item)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (package == null)
			{
				return false;
			}
			if (item == null)
			{
				package.Write(false);
				return true;
			}
			ItemData val;
			try
			{
				val = item.Clone();
			}
			catch
			{
				return false;
			}
			if (!TryGetMultiUserContainerPrefabName(val, out string prefabName) || !IsValidMultiUserContainerItem(val) || !TryGetUtf8ByteCount(prefabName, 1024, out var byteCount) || !TryGetUtf8ByteCount(val.m_crafterName, 4096, out byteCount) || !IsValidMultiUserContainerCustomData(val.m_customData))
			{
				return false;
			}
			package.Write(true);
			package.Write((byte)1);
			WriteMultiUserContainerString(package, prefabName);
			package.Write(val.m_stack);
			package.Write(val.m_durability);
			package.Write(val.m_gridPos);
			package.Write(val.m_equipped);
			package.Write(val.m_quality);
			package.Write(val.m_variant);
			package.Write(val.m_crafterID);
			WriteMultiUserContainerString(package, val.m_crafterName);
			package.Write(val.m_worldLevel);
			package.Write(val.m_pickedUp);
			package.Write(val.m_customData.Count);
			foreach (KeyValuePair<string, string> customDatum in val.m_customData)
			{
				WriteMultiUserContainerString(package, customDatum.Key);
				WriteMultiUserContainerString(package, customDatum.Value);
			}
			return true;
		}

		internal static bool TryReadMultiUserContainerItem(ZPackage? package, out ItemData? item)
		{
			item = null;
			if (package == null)
			{
				return false;
			}
			int pos = package.GetPos();
			try
			{
				if (TryReadMultiUserContainerItemCore(package, out item))
				{
					return true;
				}
			}
			catch (Exception ex) when (ex is ArgumentException || ex is InvalidOperationException || ex is EndOfStreamException || ex is IOException)
			{
			}
			package.SetPos(pos);
			item = null;
			return false;
		}

		internal static MultiUserContainerItemSnapshot? CreateMultiUserContainerItemSnapshot(ItemData? item)
		{
			if (item == null)
			{
				return null;
			}
			ItemData val;
			try
			{
				val = item.Clone();
			}
			catch
			{
				return null;
			}
			TryGetMultiUserContainerPrefabName(val, out string prefabName);
			return new MultiUserContainerItemSnapshot(prefabName, val.m_quality, val.m_variant, val.m_worldLevel, val.m_crafterID, val.m_crafterName, val.m_durability, val.m_pickedUp, val.m_stack, val.m_customData);
		}

		private static bool TryReadMultiUserContainerItemCore(ZPackage package, out ItemData? item)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			item = null;
			if (package.Size() - package.GetPos() < 1)
			{
				return false;
			}
			if (!package.ReadBool())
			{
				return true;
			}
			if (package.Size() - package.GetPos() < 1 || package.ReadByte() != 1 || !TryReadMultiUserContainerString(package, 1024, out string value, out int byteCount) || string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			int stack = package.ReadInt();
			float durability = package.ReadSingle();
			Vector2i val = package.ReadVector2i();
			bool flag = package.ReadBool();
			int quality = package.ReadInt();
			int num = package.ReadInt();
			long crafterID = package.ReadLong();
			if (!TryReadMultiUserContainerString(package, 4096, out string value2, out byteCount))
			{
				return false;
			}
			int worldLevel = package.ReadInt();
			bool pickedUp = package.ReadBool();
			int num2 = package.ReadInt();
			if (!IsValidMultiUserContainerPrimitiveData(stack, durability, val, quality, num, worldLevel) || num2 < 0 || num2 > 1024)
			{
				return false;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>(num2, StringComparer.Ordinal);
			long num3 = 0L;
			for (int i = 0; i < num2; i++)
			{
				if (!TryReadMultiUserContainerString(package, 4096, out string value3, out int byteCount2) || !TryReadMultiUserContainerString(package, 40960, out string value4, out int byteCount3) || dictionary.ContainsKey(value3))
				{
					return false;
				}
				num3 += (long)byteCount2 + (long)byteCount3;
				if (num3 > 40960)
				{
					return false;
				}
				dictionary.Add(value3, value4);
			}
			if (!TryCreateMultiUserContainerItem(value, out ItemData item2))
			{
				return false;
			}
			if (item2.m_shared?.m_icons == null || num >= item2.m_shared.m_icons.Length)
			{
				return false;
			}
			item2.m_stack = stack;
			item2.m_durability = durability;
			item2.m_gridPos = val;
			item2.m_equipped = flag && item2.IsEquipable();
			item2.m_quality = quality;
			item2.m_variant = num;
			item2.m_crafterID = crafterID;
			item2.m_crafterName = value2;
			item2.m_worldLevel = worldLevel;
			item2.m_pickedUp = pickedUp;
			item2.m_customData = dictionary;
			item = item2;
			return true;
		}

		private static bool TryCreateMultiUserContainerItem(string prefabName, out ItemData item)
		{
			item = null;
			try
			{
				GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(prefabName) : null);
				if (IsUnityNull((Object?)(object)val) && (Object)(object)ZNetScene.instance != (Object)null)
				{
					val = ZNetScene.instance.GetPrefab(prefabName);
				}
				if (IsUnityNull((Object?)(object)val))
				{
					return false;
				}
				ItemDrop component = val.GetComponent<ItemDrop>();
				if (IsUnityNull((Object?)(object)component) || component.m_itemData == null)
				{
					return false;
				}
				item = component.m_itemData.Clone();
				item.m_dropPrefab = val;
				return true;
			}
			catch
			{
				item = null;
				return false;
			}
		}

		private static bool TryGetMultiUserContainerPrefabName(ItemData item, out string prefabName)
		{
			prefabName = ((!IsUnityNull((Object?)(object)item.m_dropPrefab)) ? ((Object)item.m_dropPrefab).name : "");
			return !string.IsNullOrWhiteSpace(prefabName);
		}

		private static bool IsValidMultiUserContainerItem(ItemData item)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (item.m_shared?.m_icons != null && item.m_variant >= 0 && item.m_variant < item.m_shared.m_icons.Length && item.m_crafterName != null && item.m_customData != null)
			{
				return IsValidMultiUserContainerPrimitiveData(item.m_stack, item.m_durability, item.m_gridPos, item.m_quality, item.m_variant, item.m_worldLevel);
			}
			return false;
		}

		private static bool IsValidMultiUserContainerPrimitiveData(int stack, float durability, Vector2i gridPosition, int quality, int variant, int worldLevel)
		{
			//IL_004c: 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_005e: 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 (stack > 0 && stack <= 1000000 && !float.IsNaN(durability) && !float.IsInfinity(durability) && durability >= 0f && quality > 0 && quality <= 10000 && variant >= 0 && variant <= 10000 && worldLevel >= 0 && worldLevel <= 10000 && gridPosition.x >= -1 && gridPosition.y >= -1 && gridPosition.x <= 4096)
			{
				return gridPosition.y <= 4096;
			}
			return false;
		}

		private static bool IsValidMultiUserContainerCustomData(Dictionary<string, string> customData)
		{
			if (customData.Count > 1024)
			{
				return false;
			}
			long num = 0L;
			foreach (KeyValuePair<string, string> customDatum in customData)
			{
				if (!TryGetUtf8ByteCount(customDatum.Key, 4096, out var byteCount) || !TryGetUtf8ByteCount(customDatum.Value, 40960, out var byteCount2))
				{
					return false;
				}
				num += (long)byteCount + (long)byteCount2;
				if (num > 40960)
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryGetUtf8ByteCount(string? value, int maximumBytes, out int byteCount)
		{
			byteCount = 0;
			if (value == null)
			{
				return false;
			}
			try
			{
				byteCount = MultiUserContainerUtf8.GetByteCount(value);
				return byteCount <= maximumBytes;
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
		}

		private static void WriteMultiUserContainerString(ZPackage package, string value)
		{
			package.Write(MultiUserContainerUtf8.GetBytes(value));
		}

		private static bool TryReadMultiUserContainerString(ZPackage package, int maximumBytes, out string value, out int byteCount)
		{
			value = "";
			byteCount = 0;
			if (package.Size() - package.GetPos() < 4)
			{
				return false;
			}
			int num = package.ReadInt();
			int num2 = package.Size() - package.GetPos();
			if (num < 0 || num > maximumBytes || num > num2)
			{
				return false;
			}
			byte[] array = package.ReadByteArray(num);
			if (array.Length != num)
			{
				return false;
			}
			value = MultiUserContainerUtf8.GetString(array);
			byteCount = num;
			return true;
		}

		internal static bool IsMultiUserContainerInteractionPending(InventoryGui gui, InventoryGrid grid, ItemData item, Vector2i position)
		{
			//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)
			if (IsMultiUserContainerBatchInteractionBlocked(gui))
			{
				return true;
			}
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || (Object)(object)gui == (Object)null || (Object)(object)grid == (Object)null)
			{
				return false;
			}
			Inventory inventory = grid.GetInventory();
			Inventory val = (((Object)(object)pendingMultiUserContainerTransfer.Container != (Object)null && !IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container)) ? pendingMultiUserContainerTransfer.Container.GetInventory() : null);
			if (inventory != val && inventory != pendingMultiUserContainerTransfer.Projection && gui.m_dragInventory != val && gui.m_dragInventory != pendingMultiUserContainerTransfer.Projection)
			{
				if (inventory == pendingMultiUserContainerTransfer.LocalInventory)
				{
					if (!(position == pendingMultiUserContainerTransfer.PreferredLocalPosition))
					{
						if (item != null && pendingMultiUserContainerTransfer.LocalEscrow != null)
						{
							return IsExactMultiUserContainerItemMatch(pendingMultiUserContainerTransfer.LocalEscrow, item, 1);
						}
						return false;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		internal static bool TryRouteMultiUserContainerAutoMove(Inventory targetInventory, Inventory sourceInventory, ItemData item)
		{
			if (!TryGetMultiUserContainerTransferDirection(targetInventory, sourceInventory, out Container remoteContainer, out bool addingToContainer, out bool removingFromContainer, out bool movingInsideContainer))
			{
				return false;
			}
			if (item?.m_shared == null)
			{
				return true;
			}
			if (addingToContainer)
			{
				TryStartMultiUserContainerAdd(remoteContainer, sourceInventory, item, item.m_stack, null);
			}
			else if (removingFromContainer)
			{
				TryStartMultiUserContainerRemove(remoteContainer, targetInventory, item, item.m_stack, null);
			}
			else if (movingInsideContainer)
			{
				ShowMultiUserContainerNotReady();
			}
			return true;
		}

		internal static bool TryRouteMultiUserContainerPositionalMove(Inventory targetInventory, Inventory sourceInventory, ItemData item, int amount, int x, int y, out bool result)
		{
			//IL_002b: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			result = false;
			if (!TryGetMultiUserContainerTransferDirection(targetInventory, sourceInventory, out Container remoteContainer, out bool addingToContainer, out bool removingFromContainer, out bool movingInsideContainer))
			{
				return false;
			}
			Vector2i val = default(Vector2i);
			((Vector2i)(ref val))..ctor(x, y);
			if (addingToContainer)
			{
				result = TryStartMultiUserContainerAdd(remoteContainer, sourceInventory, item, amount, val);
			}
			else if (removingFromContainer)
			{
				result = TryStartMultiUserContainerRemove(remoteContainer, targetInventory, item, amount, val);
			}
			else if (movingInsideContainer)
			{
				result = TryStartMultiUserContainerMove(remoteContainer, item, amount, val);
			}
			return true;
		}

		internal static bool TryRouteMultiUserContainerDropItem(InventoryGrid targetGrid, Inventory sourceInventory, ItemData item, int amount, Vector2i targetPosition, out bool result)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			result = false;
			Inventory val = ((targetGrid != null) ? targetGrid.GetInventory() : null);
			if (val == null)
			{
				return false;
			}
			if (item?.m_shared != null && amount == item.m_stack && TryGetMultiUserContainerTransferDirection(val, sourceInventory, out Container remoteContainer, out bool addingToContainer, out bool removingFromContainer, out bool movingInsideContainer))
			{
				ItemData itemAt = val.GetItemAt(targetPosition.x, targetPosition.y);
				if (itemAt != null && itemAt != item && (item.m_shared.m_maxStackSize <= 1 || itemAt.m_shared.m_maxStackSize <= 1 || !IsExactMultiUserContainerItemMatch(item, itemAt, 1)))
				{
					if (addingToContainer)
					{
						result = TryStartMultiUserContainerExchange(remoteContainer, sourceInventory, itemAt, item);
						return true;
					}
					if (removingFromContainer)
					{
						result = TryStartMultiUserContainerExchange(remoteContainer, val, item, itemAt);
						return true;
					}
					if (movingInsideContainer)
					{
						result = TryStartMultiUserContainerSwap(remoteContainer, item, itemAt);
						return true;
					}
				}
			}
			return TryRouteMultiUserContainerPositionalMove(val, sourceInventory, item, amount, targetPosition.x, targetPosition.y, out result);
		}

		internal static bool TryHandleMultiUserContainerRightClick(InventoryGui gui, InventoryGrid grid, ItemData item, Vector2i position)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			if (!IsBuiltInMultiUserChestEnabled || (Object)(object)gui == (Object)null || (Object)(object)grid == (Object)null || item?.m_shared == null || !TryGetBuiltInRemoteContainer(grid.GetInventory(), out Container container) || (Object)(object)gui.m_currentContainer != (Object)(object)container)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if (item.m_shared.m_questItem)
			{
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$msg_cantconsume", 0, (Sprite)null);
				}
				return true;
			}
			if ((int)item.m_shared.m_itemType != 2)
			{
				ShowMultiUserContainerNotReady();
				return true;
			}
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || !((Humanoid)localPlayer).CanConsumeItem(item, true))
			{
				return true;
			}
			if (!TryStartMultiUserContainerRemove(container, ((Humanoid)localPlayer).GetInventory(), item, 1, null, MultiUserContainerRecoveryMode.ConsumeAfterInventory))
			{
				ShowMultiUserContainerNotReady();
			}
			return true;
		}

		internal static bool TryHandleMultiUserContainerDropOutside(InventoryGui gui)
		{
			if (!IsBuiltInMultiUserChestEnabled || (Object)(object)gui == (Object)null || (Object)(object)gui.m_dragGo == (Object)null || gui.m_dragItem?.m_shared == null || gui.m_dragInventory == null || !TryGetBuiltInRemoteContainer(gui.m_dragInventory, out Container container) || (Object)(object)gui.m_currentContainer != (Object)(object)container)
			{
				return false;
			}
			if (_pendingMultiUserContainerTransfer != null || gui.m_dragItem.m_shared.m_questItem)
			{
				if (gui.m_dragItem.m_shared.m_questItem)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, "$msg_cantdrop", 0, (Sprite)null);
					}
				}
				return true;
			}
			if (TryStartMultiUserContainerWorldDrop(container, gui.m_dragItem, gui.m_dragAmount))
			{
				gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
			}
			else
			{
				ShowMultiUserContainerNotReady();
			}
			return true;
		}

		internal static bool TryHandleMultiUserContainerDropSelectedItem(InventoryGui gui, InventoryGrid grid, ItemData item, Vector2i position)
		{
			if (!IsBuiltInMultiUserChestEnabled || (Object)(object)gui == (Object)null || (Object)(object)grid == (Object)null || (Object)(object)gui.m_dragGo != (Object)null || gui.m_dragItem != null || item?.m_shared == null || !TryGetBuiltInRemoteContainer(grid.GetInventory(), out Container container) || (Object)(object)gui.m_currentContainer != (Object)(object)container)
			{
				return false;
			}
			if (_pendingMultiUserContainerTransfer != null || item.m_shared.m_questItem)
			{
				if (item.m_shared.m_questItem)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, "$msg_cantdrop", 0, (Sprite)null);
					}
				}
				return true;
			}
			if (!TryStartMultiUserContainerWorldDrop(container, item, item.m_stack))
			{
				ShowMultiUserContainerNotReady();
			}
			return true;
		}

		private static bool TryStartMultiUserContainerAdd(Container container, Inventory sourceInventory, ItemData item, int amount, Vector2i? requestedTarget, MultiUserContainerRecoveryMode recoveryMode = MultiUserContainerRecoveryMode.InventoryFirst)
		{
			//IL_0027: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_008f: 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_00b1: 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)
			if (!CanStartMultiUserContainerTransfer(container, sourceInventory, item, amount) || !IsLocalPlayerInventory(sourceInventory))
			{
				return false;
			}
			Inventory inventory = container.GetInventory();
			Vector2i destination;
			if (requestedTarget.HasValue)
			{
				destination = requestedTarget.Value;
				if (!CanAddEntireMultiUserContainerItemAt(inventory, item, amount, destination))
				{
					ShowMultiUserContainerUnsupportedDestination();
					return false;
				}
			}
			else if (!TryFindMultiUserContainerDestination(inventory, item, amount, out destination))
			{
				ShowMultiUserContainerNotReady();
				return false;
			}
			ItemData val;
			ItemData val2;
			try
			{
				val = item.Clone();
				val2 = item.Clone();
			}
			catch
			{
				return false;
			}
			val.m_stack = amount;
			val.m_equipped = false;
			val2.m_stack = amount;
			val2.m_equipped = false;
			int expectedTargetStack = inventory.GetItemAt(destination.x, destination.y)?.m_stack ?? 0;
			MultiUserContainerRequest request = CreateMultiUserContainerRequest(MultiUserContainerOperation.Add, val, amount, item.m_gridPos, destination, expectedTargetStack);
			Vector2i gridPos = item.m_gridPos;
			int stack = item.m_stack;
			try
			{
				if (sourceInventory.ContainsItem(item))
				{
					sourceInventory.RemoveItem(item, amount);
				}
				else
					_ = 0;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest source removal callback failed: " + ex.Message));
			}
			int num = (sourceInventory.ContainsItem(item) ? item.m_stack : 0);
			int num2 = Math.Max(0, stack - num);
			if (num2 != amount)
			{
				if (num2 > 0)
				{
					val2.m_stack = num2;
					RestoreMultiUserContainerLocalEscrow(sourceInventory, val2, gridPos, GetMultiUserContainerLocalPlacementPolicy(recoveryMode));
				}
				return false;
			}
			return TryStartPreparedMultiUserContainerRequest(container, request, sourceInventory, val2, gridPos, recoveryMode);
		}

		private static bool TryStartMultiUserContainerRemove(Container container, Inventory destinationInventory, ItemData item, int amount, Vector2i? requestedTarget, MultiUserContainerRecoveryMode recoveryMode = MultiUserContainerRecoveryMode.InventoryFirst)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!CanStartMultiUserContainerTransfer(container, destinationInventory, item, amount) || !IsLocalPlayerInventory(destinationInventory))
			{
				return false;
			}
			bool result = false;
			if (!TryValidatePlayerInventoryLimit(destinationInventory, item, amount, ref result))
			{
				return false;
			}
			Vector2i destination;
			if (requestedTarget.HasValue)
			{
				destination = requestedTarget.Value;
				if (!CanReceiveEntireMultiUserContainerItemAt(destinationInventory, item, amount, destination))
				{
					ShowMultiUserContainerUnsupportedDestination();
					return false;
				}
			}
			else if (!TryFindLocalMultiUserContainerDestination(destinationInventory, item, amount, out destination))
			{
				ShowMultiUserContainerNotReady();
				return false;
			}
			return TryStartMultiUserContainerRequest(container, MultiUserContainerOperation.Remove, item, amount, item.m_gridPos, destination, destinationInventory, null, destination, -1, recoveryMode);
		}

		private static bool TryStartMultiUserContainerWorldDrop(Container container, ItemData item, int amount)
		{
			//IL_0049: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || item?.m_shared == null || item.m_shared.m_questItem || !CanStartMultiUserContainerTransfer(container, ((Humanoid)localPlayer).GetInventory(), item, amount))
			{
				return false;
			}
			return TryStartMultiUserContainerRequest(container, MultiUserContainerOperation.Remove, item, amount, item.m_gridPos, new Vector2i(-1, -1), ((Humanoid)localPlayer).GetInventory(), null, new Vector2i(-1, -1), -1, MultiUserContainerRecoveryMode.WorldFirst);
		}

		private static bool TryStartMultiUserContainerMove(Container container, ItemData item, int amount, Vector2i target)
		{
			//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_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)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!CanStartMultiUserContainerTransfer(container, container.GetInventory(), item, amount))
			{
				return false;
			}
			ItemData itemAt = container.GetInventory().GetItemAt(target.x, target.y);
			if (itemAt != null && itemAt != item && !CanStackEntireMultiUserContainerItem(item, itemAt, amount))
			{
				ShowMultiUserContainerUnsupportedDestination();
				return false;
			}
			return TryStartMultiUserContainerRequest(container, MultiUserContainerOperation.Move, item, amount, item.m_gridPos, target, null, null, new Vector2i(-1, -1), itemAt?.m_stack ?? 0);
		}

		private static bool TryStartMultiUserContainerExchange(Container container, Inventory localInventory, ItemData containerItem, ItemData localItem)
		{
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || !IsLocalPlayerInventory(localInventory) || !CanStartMultiUserContainerTransfer(container, localInventory, containerItem, containerItem.m_stack) || localItem?.m_shared == null || localItem.m_customData == null || localItem.m_equipped || localItem.m_shared.m_questItem || containerItem.m_equipped || containerItem.m_shared.m_questItem || !localInventory.ContainsItem(localItem) || !InventoryActionCellPolicyCore.CanUseContainerActionSource(GetInventoryCellKind(localPlayer, localInventory, localItem.m_gridPos), includeHotbar: true))
			{
				ShowMultiUserContainerUnsupportedDestination();
				return false;
			}
			ItemData itemAt = container.GetInventory().GetItemAt(containerItem.m_gridPos.x, containerItem.m_gridPos.y);
			if (itemAt == null || itemAt != containerItem || !IsExactMultiUserContainerItemMatch(containerItem, itemAt, containerItem.m_stack))
			{
				ShowMultiUserContainerNotReady();
				return false;
			}
			ItemData val;
			ItemData val2;
			ItemData val3;
			try
			{
				val = containerItem.Clone();
				val2 = localItem.Clone();
				val3 = localItem.Clone();
			}
			catch
			{
				return false;
			}
			val.m_equipped = false;
			val2.m_equipped = false;
			val3.m_equipped = false;
			Vector2i gridPos = localItem.m_gridPos;
			MultiUserContainerRequest request = CreateMultiUserContainerRequest(MultiUserContainerOperation.Exchange, val, val.m_stack, val.m_gridPos, gridPos, -1, val2);
			int stack = localItem.m_stack;
			try
			{
				if (localInventory.ContainsItem(localItem))
				{
					localInventory.RemoveItem(localItem, stack);
				}
				else
					_ = 0;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest exchange escrow callback failed: " + ex.Message));
			}
			int num = (localInventory.ContainsItem(localItem) ? localItem.m_stack : 0);
			int num2 = Math.Max(0, stack - num);
			if (num2 != stack)
			{
				if (num2 > 0)
				{
					val3.m_stack = num2;
					RestoreMultiUserContainerLocalEscrow(localInventory, val3, gridPos, MultiUserContainerLocalPlacementPolicy.RegularAndHotbar);
				}
				return false;
			}
			if (!CanAddWithinInventoryLimits(localInventory, val, val.m_stack, out var _))
			{
				RestoreMultiUserContainerLocalEscrow(localInventory, val3, gridPos, MultiUserContainerLocalPlacementPolicy.RegularAndHotbar);
				return false;
			}
			return TryStartPreparedMultiUserContainerRequest(container, request, localInventory, val3, gridPos, MultiUserContainerRecoveryMode.RegularInventoryFirst);
		}

		private static bool TryStartMultiUserContainerSwap(Container container, ItemData source, ItemData target)
		{
			//IL_00e0: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (source?.m_shared == null || target?.m_shared == null || source == target || source.m_equipped || target.m_equipped || source.m_shared.m_questItem || target.m_shared.m_questItem || !CanStartMultiUserContainerTransfer(container, container.GetInventory(), source, source.m_stack))
			{
				ShowMultiUserContainerUnsupportedDestination();
				return false;
			}
			Inventory inventory = container.GetInventory();
			if (inventory.GetItemAt(source.m_gridPos.x, source.m_gridPos.y) != source || inventory.GetItemAt(target.m_gridPos.x, target.m_gridPos.y) != target)
			{
				ShowMultiUserContainerNotReady();
				return false;
			}
			ItemData val;
			ItemData val2;
			try
			{
				val = source.Clone();
				val2 = target.Clone();
			}
			catch
			{
				return false;
			}
			val.m_equipped = false;
			val2.m_equipped = false;
			MultiUserContainerRequest request = CreateMultiUserContainerRequest(MultiUserContainerOperation.Swap, val, val.m_stack, val.m_gridPos, val2.m_gridPos, -1, val2);
			return TryStartPreparedMultiUserContainerRequest(container, request, null, null, new Vector2i(-1, -1));
		}

		private static bool TryStartMultiUserContainerRequest(Container container, MultiUserContainerOperation operation, ItemData item, int amount, Vector2i sourcePosition, Vector2i targetPosition, Inventory? localInventory, ItemData? localEscrow, Vector2i preferredLocalPosition, int expectedTargetStack, MultiUserContainerRecoveryMode recoveryMode = MultiUserContainerRecoveryMode.InventoryFirst)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!CanStartMultiUserContainerTransfer(container, localInventory, item, amount))
			{
				return false;
			}
			ItemData val;
			try
			{
				val = item.Clone();
			}
			catch
			{
				return false;
			}
			val.m_equipped = false;
			MultiUserContainerRequest request = CreateMultiUserContainerRequest(operation, val, amount, sourcePosition, targetPosition, expectedTargetStack);
			return TryStartPreparedMultiUserContainerRequest(container, request, localInventory, localEscrow, preferredLocalPosition, recoveryMode);
		}

		private static bool TryStartPreparedMultiUserContainerRequest(Container container, MultiUserContainerRequest request, Inventory? localInventory, ItemData? localEscrow, Vector2i preferredLocalPosition, MultiUserContainerRecoveryMode recoveryMode = MultiUserContainerRecoveryMode.InventoryFirst)
		{
			//IL_0023: 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_00cc: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			if (_pendingMultiUserContainerTransfer != null || !TryGetMultiUserContainerOwner(container, out var owner) || !TryWriteMultiUserContainerRequest(request, out ZPackage package))
			{
				if (localEscrow != null && localInventory != null)
				{
					RestoreMultiUserContainerLocalEscrow(localInventory, localEscrow, preferredLocalPosition, GetMultiUserContainerLocalPlacementPolicy(recoveryMode));
				}
				return false;
			}
			byte[] array = package.GetArray();
			if (!TryComputeMultiUserContainerDigest(array, out byte[] digest) || digest == null)
			{
				if (localEscrow != null && localInventory != null)
				{
					RestoreMultiUserContainerLocalEscrow(localInventory, localEscrow, preferredLocalPosition, GetMultiUserContainerLocalPlacementPolicy(recoveryMode));
				}
				return false;
			}
			_pendingMultiUserContainerTransfer = new PendingMultiUserContainerTransfer
			{
				Container = container,
				ContainerId = container.m_nview.GetZDO().m_uid,
				RequesterPeerId = ZNet.GetUID(),
				Owner = owner,
				RequestOwners = new HashSet<long> { owner },
				Request = request,
				RequestBytes = array,
				RequestDigest = digest,
				LocalInventory = localInventory,
				LocalEscrow = localEscrow,
				PreferredLocalPosition = preferredLocalPosition,
				RecoveryMode = recoveryMode,
				StartedAt = Time.unscaledTime,
				LastSentAt = Time.unscaledTime,
				SendAttempts = 1
			};
			container.m_nview.InvokeRPC("InventorySlots_MUC_Request_v3", new object[1] { package });
			return true;
		}

		private static MultiUserContainerRequest CreateMultiUserContainerRequest(MultiUserContainerOperation operation, ItemData item, int amount, Vector2i sourcePosition, Vector2i targetPosition, int expectedTargetStack, ItemData? counterpartItem = null)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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)
			Player localPlayer = Player.m_localPlayer;
			return new MultiUserContainerRequest
			{
				RequestId = GetNextMultiUserContainerRequestId(),
				Operation = operation,
				RequesterPlayerId = (((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer)) ? localPlayer.GetPlayerID() : 0),
				SourcePosition = sourcePosition,
				TargetPosition = targetPosition,
				ExpectedTargetStack = expectedTargetStack,
				Amount = amount,
				Item = item,
				CounterpartItem = counterpartItem
			};
		}

		private static int GetNextMultiUserContainerRequestId()
		{
			if (_nextMultiUserContainerRequestId <= 0)
			{
				_nextMultiUserContainerRequestId = 1;
			}
			return _nextMultiUserContainerRequestId++;
		}

		private static bool CanStartMultiUserContainerTransfer(Container container, Inventory? relatedInventory, ItemData item, int amount)
		{
			if (IsBuiltInMultiUserChestEnabled && _pendingMultiUserContainerTransfer == null && (Object)(object)container != (Object)null && !IsUnityNull((Object?)(object)container) && IsBuiltInMultiUserContainerEligible(container) && item?.m_shared != null && item.m_customData != null && amount > 0 && amount <= item.m_stack && amount <= Math.Max(1, item.m_shared.m_maxStackSize) && (Object)(object)Player.m_localPlayer != (Object)null && !IsUnityNull((Object?)(object)Player.m_localPlayer))
			{
				return !Player.m_localPlayer.m_isLoading;
			}
			return false;
		}

		private static bool TryGetMultiUserContainerTransferDirection(Inventory targetInventory, Inventory sourceInventory, out Container? remoteContainer, out bool addingToContainer, out bool removingFromContainer, out bool movingInsideContainer)
		{
			remoteContainer = null;
			addingToContainer = false;
			removingFromContainer = false;
			movingInsideContainer = false;
			if (!IsBuiltInMultiUserChestEnabled || targetInventory == null || sourceInventory == null)
			{
				return false;
			}
			Container container;
			bool flag = TryGetBuiltInRemoteContainer(targetInventory, out container);
			Container container2;
			bool flag2 = TryGetBuiltInRemoteContainer(sourceInventory, out container2);
			if (!flag && !flag2)
			{
				return false;
			}
			if (flag && flag2)
			{
				if ((Object)(object)container != (Object)(object)container2)
				{
					remoteContainer = container;
					return true;
				}
				remoteContainer = container;
				movingInsideContainer = true;
				return true;
			}
			if (flag)
			{
				remoteContainer = container;
				addingToContainer = true;
				return true;
			}
			remoteContainer = container2;
			removingFromContainer = true;
			return true;
		}

		private static bool TryGetBuiltInRemoteContainer(Inventory? inventory, out Container? container)
		{
			container = null;
			if (!IsBuiltInMultiUserChestEnabled || inventory == null)
			{
				return false;
			}
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer != null && pendingMultiUserContainerTransfer.Projection == inventory && (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)null && !IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container))
			{
				container = pendingMultiUserContainerTransfer.Container;
				return true;
			}
			InventoryGui instance = InventoryGui.instance;
			Container val = (((Object)(object)instance != (Object)null) ? instance.m_currentContainer : null);
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && val.GetInventory() == inventory && IsBuiltInMultiUserContainerEligible(val) && (Object)(object)val.m_nview != (Object)null && val.m_nview.IsValid() && !val.m_nview.IsOwner())
			{
				container = val;
				return true;
			}
			for (int num = InventoryContainers.KnownContainers.Count - 1; num >= 0; num--)
			{
				Container val2 = InventoryContainers.KnownContainers[num];
				if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2))
				{
					InventoryContainers.KnownContainers.RemoveAt(num);
				}
				else if (val2.GetInventory() == inventory && IsBuiltInMultiUserContainerEligible(val2) && !((Object)(object)val2.m_nview == (Object)null) && val2.m_nview.IsValid() && !val2.m_nview.IsOwner())
				{
					container = val2;
					return true;
				}
			}
			return false;
		}

		private static bool IsBuiltInMultiUserContainerEligible(Container container)
		{
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || container.m_inventory == null || ((object)container).GetType() != typeof(Container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid() || IsMultiUserChestIgnored(container) || (Object)(object)container.m_piece == (Object)null || !container.m_piece.IsPlacedByPlayer() || (Object)(object)container.m_wagon != (Object)null || (Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null || (Object)(object)((Component)container).GetComponentInParent<TombStone>() != (Object)null || (Object)(object)((Component)container.m_nview).GetComponent<Player>() != (Object)null || (Object)(object)((Component)((Component)container).transform.root).GetComponentInChildren<Ship>() != (Object)null)
			{
				return false;
			}
			Component[] components = ((Component)container).GetComponents<Component>();
			for (int i = 0; i < components.Length; i++)
			{
				string a = ((object)components[i])?.GetType().FullName ?? "";
				if (string.Equals(a, "DrawerContainer", StringComparison.Ordinal) || string.Equals(a, "OdinShip.ShipContainer", StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryGetMultiUserContainerOwner(Container container, out long owner)
		{
			owner = 0L;
			ZDO val = (((Object)(object)container?.m_nview != (Object)null) ? container.m_nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			owner = val.GetOwner();
			if (owner != 0L)
			{
				return owner != ZNet.GetUID();
			}
			return false;
		}

		private static bool IsLocalPlayerInventory(Inventory inventory)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer))
			{
				return ((Humanoid)localPlayer).GetInventory() == inventory;
			}
			return false;
		}

		private static bool CanAddEntireMultiUserContainerItemAt(Inventory inventory, ItemData incoming, int amount, Vector2i targetPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!IsMultiUserContainerPositionInBounds(inventory, targetPosition))
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(targetPosition.x, targetPosition.y);
			if (itemAt != null)
			{
				return CanStackEntireMultiUserContainerItem(incoming, itemAt, amount);
			}
			return true;
		}

		private static bool CanStackEntireMultiUserContainerItem(ItemData incoming, ItemData target, int amount)
		{
			if (incoming?.m_shared == null || target?.m_shared == null || incoming.m_shared.m_maxStackSize <= 1 || target.m_shared.m_maxStackSize != incoming.m_shared.m_maxStackSize || amount <= 0 || target.m_stack > incoming.m_shared.m_maxStackSize - amount)
			{
				return false;
			}
			return IsExactMultiUserContainerItemMatch(incoming, target, 1);
		}

		private static bool TryFindLocalMultiUserContainerDestination(Inventory inventory, ItemData incoming, int amount, out Vector2i destination)
		{
			//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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			destination = new Vector2i(-1, -1);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || inventory == null || incoming?.m_shared == null)
			{
				return false;
			}
			foreach (ItemData item in from target in inventory.m_inventory
				where target?.m_shared != null
				orderby target.m_gridPos.y, target.m_gridPos.x
				select target)
			{
				if (CanUseCell(localPlayer, inventory, incoming, item.m_gridPos) && CanStackEntireMultiUserContainerItem(incoming, item, amount))
				{
					destination = item.m_gridPos;
					return true;
				}
			}
			return TryFindFreeAutomaticPlacementCell(localPlayer, inventory, incoming, out destination);
		}

		private static bool CanReceiveEntireMultiUserContainerItemAt(Inventory inventory, ItemData incoming, int amount, Vector2i targetPosition)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || !IsMultiUserContainerPositionInBounds(inventory, targetPosition) || !CanUseCell(localPlayer, inventory, incoming, targetPosition))
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(targetPosition.x, targetPosition.y);
			if (itemAt != null)
			{
				return CanStackEntireMultiUserContainerItem(incoming, itemAt, amount);
			}
			return true;
		}

		private static void HandleMultiUserContainerResponse(Container? container, long sender, MultiUserContainerResponse response, bool fromDurableReceipt = false, ZDO? durableReceiptZdo = null)
		{
			//IL_002e: 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_0088: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			bool flag = (Object)(object)container != (Object)null && !IsUnityNull((Object?)(object)container);
			bool flag2 = fromDurableReceipt && durableReceiptZdo != null && pendingMultiUserContainerTransfer != null && ((ZDOID)(ref durableReceiptZdo.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId);
			if (pendingMultiUserContainerTransfer == null || (!flag && !flag2) || (flag && (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)(object)container) || pendingMultiUserContainerTransfer.Request.RequestId != response.RequestId || pendingMultiUserContainerTransfer.Request.Operation != response.Operation || pendingMultiUserContainerTransfer.Request.SourcePosition != response.SourcePosition || pendingMultiUserContainerTransfer.Request.TargetPosition != response.TargetPosition)
			{
				return;
			}
			object obj = durableReceiptZdo;
			if (obj == null)
			{
				if (container == null)
				{
					obj = null;
				}
				else
				{
					ZNetView nview = container.m_nview;
					obj = ((nview != null) ? nview.GetZDO() : null);
				}
			}
			ZDO val = (ZDO)obj;
			ObservePendingMultiUserContainerOwner(pendingMultiUserContainerTransfer, (val != null) ? val.GetOwner() : 0);
			if (!pendingMultiUserContainerTransfer.RequestOwners.Contains(sender) || pendingMultiUserContainerTransfer.ResponseApplied || pendingMultiUserContainerTransfer.TerminalFailureReceived)
			{
				return;
			}
			bool flag3 = response.Success && response.Failure == MultiUserContainerFailure.None && response.Amount == pendingMultiUserContainerTransfer.Request.Amount && IsValidMultiUserContainerSuccessPayload(pendingMultiUserContainerTransfer.Request, response);
			bool flag4 = !response.Success && response.Failure != MultiUserContainerFailure.None && response.Amount == 0 && response.Item == null;
			if ((!flag3 && !flag4) || (!flag3 && !fromDurableReceipt && (!flag || !IsCurrentMultiUserContainerOwnerResponse(container, sender))) || (!flag3 && pendingMultiUserContainerTransfer.AuthorityChangedOrReloaded))
			{
				return;
			}
			if (!flag3)
			{
				pendingMultiUserContainerTransfer.TerminalFailureReceived = true;
				pendingMultiUserContainerTransfer.ResponseAppliedAt = Time.unscaledTime;
				pendingMultiUserContainerTransfer.Projection = null;
				pendingMultiUserContainerTransfer.AcknowledgementPending = true;
				if (pendingMultiUserContainerTransfer.LocalEscrow != null)
				{
					pendingMultiUserContainerTransfer.PendingRecoveryItem = pendingMultiUserContainerTransfer.LocalEscrow;
					pendingMultiUserContainerTransfer.LocalRecoveryPending = true;
					TrySecurePendingMultiUserContainerLocalRecovery(pendingMultiUserContainerTransfer);
				}
				ShowMultiUserContainerNotReady();
				if (!pendingMultiUserContainerTransfer.LocalRecoveryPending && flag && TryAcknowledgePendingMultiUserContainerResponse(pendingMultiUserContainerTransfer, container))
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
				}
				return;
			}
			pendingMultiUserContainerTransfer.ResponseApplied = true;
			pendingMultiUserContainerTransfer.ResponseAppliedAt = Time.unscaledTime;
			pendingMultiUserContainerTransfer.AcknowledgementPending = true;
			bool flag5 = true;
			switch (response.Operation)
			{
			case MultiUserContainerOperation.Remove:
			case MultiUserContainerOperation.Exchange:
				if (response.Item != null)
				{
					pendingMultiUserContainerTransfer.LocalRecoveryPending = true;
					pendingMultiUserContainerTransfer.PendingRecoveryItem = response.Item;
					flag5 = TrySecurePendingMultiUserContainerLocalRecovery(pendingMultiUserContainerTransfer);
				}
				ClearCraftingRequirementAvailabilityCache();
				break;
			}
			if (flag5 && flag)
			{
				TryAcknowledgePendingMultiUserContainerResponse(pendingMultiUserContainerTransfer, container);
			}
			if (!pendingMultiUserContainerTransfer.LocalRecoveryPending && !pendingMultiUserContainerTransfer.AcknowledgementPending && pendingMultiUserContainerTransfer.AuthoritativeStateObserved && _pendingMultiUserContainerTransfer == pendingMultiUserContainerTransfer)
			{
				CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: true);
			}
			if ((Object)(object)InventoryGui.instance != (Object)null && !IsUnityNull((Object?)(object)InventoryGui.instance))
			{
				InventoryGui.instance.UpdateCraftingPanel(false);
			}
		}

		private static bool IsCurrentMultiUserContainerOwnerResponse(Container container, long sender)
		{
			if (sender == 0L || (Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = container.m_nview.GetZDO();
			if (zDO != null)
			{
				return zDO.GetOwner() == sender;
			}
			return false;
		}

		private static bool IsValidMultiUserContainerSuccessPayload(MultiUserContainerRequest request, MultiUserContainerResponse response)
		{
			MultiUserContainerOperation operation = request.Operation;
			if ((operation != MultiUserContainerOperation.Remove && operation != MultiUserContainerOperation.Exchange) || 1 == 0)
			{
				return response.Item == null;
			}
			if (response.Item == null || response.Item.m_stack != request.Amount || response.Item.m_equipped)
			{
				return false;
			}
			return IsExactMultiUserContainerItemMatch(request.Item, response.Item, request.Amount);
		}

		internal static void UpdateMultiUserContainerRuntime()
		{
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			ProcessPendingMultiUserContainerLocalRecoveries();
			PruneMultiUserContainerOwnerResponseCaches();
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			TrySecurePendingMultiUserContainerLocalRecovery(pendingMultiUserContainerTransfer);
			if (pendingMultiUserContainerTransfer.PermanentlyDestroyed)
			{
				if (!pendingMultiUserContainerTransfer.LocalRecoveryPending && (pendingMultiUserContainerTransfer.ResponseApplied || pendingMultiUserContainerTransfer.TerminalFailureReceived))
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
				}
				return;
			}
			Container container = pendingMultiUserContainerTransfer.Container;
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				if (!pendingMultiUserContainerTransfer.ResponseApplied && !pendingMultiUserContainerTransfer.TerminalFailureReceived && unscaledTime - pendingMultiUserContainerTransfer.LastReceiptCheckAt >= 0.25f)
				{
					pendingMultiUserContainerTransfer.LastReceiptCheckAt = unscaledTime;
					TryResolveDetachedPendingMultiUserContainerDurableReceipt(pendingMultiUserContainerTransfer);
				}
				return;
			}
			if (!pendingMultiUserContainerTransfer.ResponseApplied && !pendingMultiUserContainerTransfer.TerminalFailureReceived && unscaledTime - pendingMultiUserContainerTransfer.LastReceiptCheckAt >= 0.25f)
			{
				pendingMultiUserContainerTransfer.LastReceiptCheckAt = unscaledTime;
				TryResolvePendingMultiUserContainerDurableReceipt(container);
				if (_pendingMultiUserContainerTransfer != pendingMultiUserContainerTransfer)
				{
					return;
				}
			}
			if (pendingMultiUserContainerTransfer.TerminalFailureReceived)
			{
				if (!pendingMultiUserContainerTransfer.LocalRecoveryPending && TryAcknowledgePendingMultiUserContainerResponse(pendingMultiUserContainerTransfer, container))
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
				}
				else
				{
					CloseMultiUserContainerAfterRecoveryTimeout(pendingMultiUserContainerTransfer, container, unscaledTime);
				}
				return;
			}
			if (pendingMultiUserContainerTransfer.ResponseApplied)
			{
				if (pendingMultiUserContainerTransfer.LocalRecoveryPending || !TryAcknowledgePendingMultiUserContainerResponse(pendingMultiUserContainerTransfer, container))
				{
					CloseMultiUserContainerAfterRecoveryTimeout(pendingMultiUserContainerTransfer, container, unscaledTime);
					return;
				}
				try
				{
					container.CheckForChanges();
				}
				catch
				{
				}
				if (_pendingMultiUserContainerTransfer != pendingMultiUserContainerTransfer)
				{
					return;
				}
				if (pendingMultiUserContainerTransfer.AuthoritativeStateObserved)
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: true);
				}
				else if (unscaledTime - pendingMultiUserContainerTransfer.ResponseAppliedAt >= 5f)
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
					InventoryGui instance = InventoryGui.instance;
					if ((Object)(object)instance != (Object)null && !IsUnityNull((Object?)(object)instance) && (Object)(object)instance.m_currentContainer == (Object)(object)container)
					{
						instance.CloseContainer();
					}
				}
				return;
			}
			ZDO zDO = container.m_nview.GetZDO();
			long num = ((zDO != null) ? zDO.GetOwner() : 0);
			if (num != 0L)
			{
				if (num != pendingMultiUserContainerTransfer.Owner)
				{
					ObservePendingMultiUserContainerOwner(pendingMultiUserContainerTransfer, num);
				}
				if (unscaledTime - pendingMultiUserContainerTransfer.StartedAt >= 5f && !pendingMultiUserContainerTransfer.TimeoutNotified)
				{
					pendingMultiUserContainerTransfer.TimeoutNotified = true;
					ShowMultiUserContainerNotReady();
				}
				float num2 = ((pendingMultiUserContainerTransfer.SendAttempts < 5) ? 0.75f : 5f);
				if (!(unscaledTime - pendingMultiUserContainerTransfer.LastSentAt < num2))
				{
					pendingMultiUserContainerTransfer.LastSentAt = unscaledTime;
					pendingMultiUserContainerTransfer.SendAttempts = Math.Min(5, pendingMultiUserContainerTransfer.SendAttempts + 1);
					container.m_nview.InvokeRPC("InventorySlots_MUC_Request_v3", new object[1] { (object)new ZPackage(pendingMultiUserContainerTransfer.RequestBytes) });
				}
			}
		}

		internal static void ShutdownMultiUserContainerRuntime()
		{
			//IL_0082: 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)
			CancelMultiUserContainerBatch();
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer != null)
			{
				bool flag = false;
				if ((Object)(object)pendingMultiUserContainerTransfer.Container != (Object)null && !IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container))
				{
					flag = TryResolvePendingMultiUserContainerDurableReceipt(pendingMultiUserContainerTransfer.Container);
				}
				if (!flag && _pendingMultiUserContainerTransfer == pendingMultiUserContainerTransfer)
				{
					TryResolveDetachedPendingMultiUserContainerDurableReceipt(pendingMultiUserContainerTransfer);
				}
				pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			}
			if (pendingMultiUserContainerTransfer != null && pendingMultiUserContainerTransfer.LocalRecoveryPending && pendingMultiUserContainerTransfer.PendingRecoveryItem != null)
			{
				bool num = TrySecurePendingMultiUserContainerLocalRecovery(pendingMultiUserContainerTransfer);
				if (!num && pendingMultiUserContainerTransfer.WorldDeliveryResult != MultiUserContainerWorldDeliveryResult.Uncertain)
				{
					QueueMultiUserContainerLocalRecovery(pendingMultiUserContainerTransfer.LocalInventory, pendingMultiUserContainerTransfer.PendingRecoveryItem, pendingMultiUserContainerTransfer.PreferredLocalPosition, GetMultiUserContainerLocalPlacementPolicy(pendingMultiUserContainerTransfer.RecoveryMode));
				}
				if (num)
				{
					pendingMultiUserContainerTransfer.LocalRecoveryPending = false;
					pendingMultiUserContainerTransfer.PendingRecoveryItem = null;
					if (pendingMultiUserContainerTransfer.TerminalFailureReceived)
					{
						pendingMultiUserContainerTransfer.LocalEscrow = null;
					}
				}
			}
			if (pendingMultiUserContainerTransfer != null && !pendingMultiUserContainerTransfer.LocalRecoveryPending && (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)null && !IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container))
			{
				TryAcknowledgePendingMultiUserContainerResponse(pendingMultiUserContainerTransfer, pendingMultiUserContainerTransfer.Container);
			}
			bool flag2 = pendingMultiUserContainerTransfer != null;
			if (flag2)
			{
				MultiUserContainerOperation operation = pendingMultiUserContainerTransfer.Request.Operation;
				bool flag3 = ((operation == MultiUserContainerOperation.Add || operation == MultiUserContainerOperation.Exchange) ? true : false);
				flag2 = flag3;
			}
			bool flag4 = flag2 && pendingMultiUserContainerTransfer.ResponseApplied;
			if (pendingMultiUserContainerTransfer != null && !flag4 && !pendingMultiUserContainerTransfer.TerminalFailureReceived && !pendingMultiUserContainerTransfer.LocalRecoveryPending && !pendingMultiUserContainerTransfer.PermanentlyDestroyed && pendingMultiUserContainerTransfer.LocalEscrow != null && pendingMultiUserContainerTransfer.LocalInventory != null)
			{
				RestoreMultiUserContainerLocalEscrow(pendingMultiUserContainerTransfer.LocalInventory, pendingMultiUserContainerTransfer.LocalEscrow, pendingMultiUserContainerTransfer.PreferredLocalPosition, GetMultiUserContainerLocalPlacementPolicy(pendingMultiUserContainerTransfer.RecoveryMode));
			}
			if (pendingMultiUserContainerTransfer != null)
			{
				CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
			}
			MultiUserContainerOwnerStates.Clear();
			ProcessPendingMultiUserContainerLocalRecoveries();
			if (PendingMultiUserContainerLocalRecoveries.Count > 0)
			{
				Log.LogWarning((object)$"{PendingMultiUserContainerLocalRecoveries.Count} built-in multi-user chest item recovery operation(s) are still pending.");
			}
		}

		private static bool IsMultiUserContainerRequestVisibleInInventory(PendingMultiUserContainerTransfer pending, Inventory inventory)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			if (pending == null || inventory == null)
			{
				return false;
			}
			MultiUserContainerRequest request = pending.Request;
			if (request.Operation == MultiUserContainerOperation.Add)
			{
				Vector2i targetPosition = request.TargetPosition;
				if (!IsMultiUserContainerPositionInBounds(inventory, targetPosition))
				{
					return false;
				}
				ItemData itemAt = inventory.GetItemAt(targetPosition.x, targetPosition.y);
				int num = request.ExpectedTargetStack + request.Amount;
				if (itemAt != null && IsExactMultiUserContainerItemMatch(request.Item, itemAt, 1))
				{
					return itemAt.m_stack >= num;
				}
				return false;
			}
			if (request.Operation == MultiUserContainerOperation.Remove)
			{
				return IsMultiUserContainerSourceRemainderVisible(inventory, request);
			}
			if (request.Operation == MultiUserContainerOperation.Exchange)
			{
				ItemData itemAt2 = inventory.GetItemAt(request.SourcePosition.x, request.SourcePosition.y);
				if (request.CounterpartItem != null && itemAt2 != null && itemAt2.m_stack == request.CounterpartItem.m_stack)
				{
					return IsExactMultiUserContainerItemMatch(request.CounterpartItem, itemAt2, request.CounterpartItem.m_stack);
				}
				return false;
			}
			if (request.Operation == MultiUserContainerOperation.Swap)
			{
				ItemData itemAt3 = inventory.GetItemAt(request.TargetPosition.x, request.TargetPosition.y);
				ItemData itemAt4 = inventory.GetItemAt(request.SourcePosition.x, request.SourcePosition.y);
				if (request.CounterpartItem != null && itemAt3 != null && itemAt4 != null && itemAt3.m_stack == request.Item.m_stack && itemAt4.m_stack == request.CounterpartItem.m_stack && IsExactMultiUserContainerItemMatch(request.Item, itemAt3, request.Item.m_stack))
				{
					return IsExactMultiUserContainerItemMatch(request.CounterpartItem, itemAt4, request.CounterpartItem.m_stack);
				}
				return false;
			}
			if (request.Operation != MultiUserContainerOperation.Move)
			{
				return false;
			}
			if (request.SourcePosition == request.TargetPosition)
			{
				ItemData itemAt5 = inventory.GetItemAt(request.SourcePosition.x, request.SourcePosition.y);
				if (itemAt5 != null)
				{
					return IsExactMultiUserContainerItemMatch(request.Item, itemAt5, request.Amount);
				}
				return false;
			}
			if (!IsMultiUserContainerPositionInBounds(inventory, request.TargetPosition) || !IsMultiUserContainerSourceRemainderVisible(inventory, request))
			{
				return false;
			}
			ItemData itemAt6 = inventory.GetItemAt(request.TargetPosition.x, request.TargetPosition.y);
			int num2 = request.ExpectedTargetStack + request.Amount;
			if (itemAt6 != null && IsExactMultiUserContainerItemMatch(request.Item, itemAt6, 1))
			{
				return itemAt6.m_stack >= num2;
			}
			return false;
		}

		private static bool IsMultiUserContainerSourceRemainderVisible(Inventory inventory, MultiUserContainerRequest request)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (!IsMultiUserContainerPositionInBounds(inventory, request.SourcePosition))
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(request.SourcePosition.x, request.SourcePosition.y);
			int num = request.Item.m_stack - request.Amount;
			if (num <= 0)
			{
				if (itemAt != null)
				{
					return !IsExactMultiUserContainerItemMatch(request.Item, itemAt, 1);
				}
				return true;
			}
			if (itemAt != null && IsExactMultiUserContainerItemMatch(request.Item, itemAt, 1))
			{
				return itemAt.m_stack == num;
			}
			return false;
		}

		internal static void RebindPendingMultiUserContainer(Container container)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || (Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return;
			}
			ZDO zDO = container.m_nview.GetZDO();
			if (zDO != null && ((ZDOID)(ref zDO.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId))
			{
				bool num = (Object)(object)pendingMultiUserContainerTransfer.Container == (Object)null || IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container) || (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)(object)container;
				pendingMultiUserContainerTransfer.Container = container;
				if (num)
				{
					pendingMultiUserContainerTransfer.AuthorityChangedOrReloaded = true;
				}
				long owner = zDO.GetOwner();
				ObservePendingMultiUserContainerOwner(pendingMultiUserContainerTransfer, owner);
				pendingMultiUserContainerTransfer.Projection = null;
				pendingMultiUserContainerTransfer.LastSentAt = float.MinValue;
				TryResolvePendingMultiUserContainerDurableReceipt(container);
			}
		}

		private static void ObservePendingMultiUserContainerOwner(PendingMultiUserContainerTransfer pending, long currentOwner)
		{
			if (pending != null && currentOwner != 0L && currentOwner != pending.Owner)
			{
				pending.Owner = currentOwner;
				pending.RequestOwners.Add(currentOwner);
				pending.SendAttempts = 0;
				pending.LastSentAt = float.MinValue;
				pending.AuthorityChangedOrReloaded = true;
			}
		}

		internal static void SuspendPendingMultiUserContainer(Container container)
		{
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)(object)container)
			{
				return;
			}
			TryResolvePendingMultiUserContainerDurableReceipt(container);
			if (_pendingMultiUserContainerTransfer == pendingMultiUserContainerTransfer)
			{
				if (IsMultiUserContainerAreaBatchActive())
				{
					FinishMultiUserContainerBatch(showResult: true);
				}
				if (pendingMultiUserContainerTransfer.ResponseApplied && !pendingMultiUserContainerTransfer.LocalRecoveryPending && !pendingMultiUserContainerTransfer.AcknowledgementPending)
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
					return;
				}
				pendingMultiUserContainerTransfer.Container = null;
				pendingMultiUserContainerTransfer.Projection = null;
			}
		}

		internal static void OnMultiUserContainerPermanentlyDestroyed(Container container, ZDO zdo)
		{
			//IL_0024: 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)
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || (Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || zdo == null || !((ZDOID)(ref zdo.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId))
			{
				return;
			}
			pendingMultiUserContainerTransfer.Container = container;
			TryResolvePendingMultiUserContainerDurableReceipt(container);
			pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer != null && ((ZDOID)(ref zdo.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId))
			{
				TrySecurePendingMultiUserContainerLocalRecovery(pendingMultiUserContainerTransfer);
				pendingMultiUserContainerTransfer.PermanentlyDestroyed = true;
				pendingMultiUserContainerTransfer.Container = null;
				pendingMultiUserContainerTransfer.Projection = null;
				if (!pendingMultiUserContainerTransfer.LocalRecoveryPending && (pendingMultiUserContainerTransfer.ResponseApplied || pendingMultiUserContainerTransfer.TerminalFailureReceived))
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: false);
				}
				ShowMultiUserContainerNotReady();
			}
		}

		private static void CompletePendingMultiUserContainerTransfer(PendingMultiUserContainerTransfer pending, bool committedAndObserved)
		{
			if (pending != null && _pendingMultiUserContainerTransfer == pending)
			{
				_pendingMultiUserContainerTransfer = null;
				OnMultiUserContainerTransferCompleted(committedAndObserved);
			}
		}

		internal static void OnMultiUserContainerZdoDestroyed(ZDO zdo)
		{
			//IL_0013: 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)
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || zdo == null || !((ZDOID)(ref zdo.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId))
			{
				return;
			}
			TryResolvePendingMultiUserContainerDurableReceipt(zdo);
			pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer != null && ((ZDOID)(ref zdo.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId))
			{
				Container container = pendingMultiUserContainerTransfer.Container;
				if ((Object)(object)container != (Object)null && !IsUnityNull((Object?)(object)container))
				{
					OnMultiUserContainerPermanentlyDestroyed(container, zdo);
					return;
				}
				pendingMultiUserContainerTransfer.PermanentlyDestroyed = true;
				pendingMultiUserContainerTransfer.Projection = null;
				ShowMultiUserContainerNotReady();
			}
		}

		private static bool TryResolveDetachedPendingMultiUserContainerDurableReceipt(PendingMultiUserContainerTransfer pending)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (pending == null || _pendingMultiUserContainerTransfer != pending || ZDOMan.instance == null)
			{
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(pending.ContainerId);
			if (zDO != null)
			{
				return TryResolvePendingMultiUserContainerDurableReceipt(zDO);
			}
			return false;
		}

		private static bool RestoreMultiUserContainerLocalEscrow(Inventory inventory, ItemData escrow, Vector2i preferredPosition, MultiUserContainerLocalPlacementPolicy placementPolicy = MultiUserContainerLocalPlacementPolicy.AnyUsable)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			bool result = RecoverMultiUserContainerItemLocally(inventory, escrow, escrow.m_stack, preferredPosition, placementPolicy);
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance != (Object)null && !IsUnityNull((Object?)(object)instance) && instance.m_dragItem != null && instance.m_dragInventory == inventory && !inventory.ContainsItem(instance.m_dragItem))
			{
				instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
			}
			return result;
		}

		private static MultiUserContainerLocalPlacementPolicy GetMultiUserContainerLocalPlacementPolicy(MultiUserContainerRecoveryMode recoveryMode)
		{
			return recoveryMode switch
			{
				MultiUserContainerRecoveryMode.RegularInventoryFirst => MultiUserContainerLocalPlacementPolicy.RegularAndHotbar, 
				MultiUserContainerRecoveryMode.BatchInventoryFirst => MultiUserContainerLocalPlacementPolicy.ContainerBatch, 
				_ => MultiUserContainerLocalPlacementPolicy.AnyUsable, 
			};
		}

		private static bool RecoverMultiUserContainerItemLocally(Inventory? inventory, ItemData item, int amount, Vector2i preferredPosition, MultiUserContainerLocalPlacementPolicy placementPolicy = MultiUserContainerLocalPlacementPolicy.AnyUsable)
		{
			//IL_005c: 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)
			if (item?.m_shared == null || amount <= 0 || amount > item.m_stack)
			{
				return false;
			}
			try
			{
				if (inventory != null && TryInsertMultiUserContainerItemIntoLocalInventory(inventory, item, amount, preferredPosition, out ItemData _, placementPolicy))
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest local inventory recovery failed: " + ex.Message));
			}
			item.m_stack = amount;
			QueueMultiUserContainerLocalRecovery(inventory, item, preferredPosition, placementPolicy);
			return false;
		}

		private static void QueueMultiUserContainerLocalRecovery(Inventory? inventory, ItemData? item, Vector2i preferredPosition, MultiUserContainerLocalPlacementPolicy placementPolicy = MultiUserContainerLocalPlacementPolicy.AnyUsable)
		{
			//IL_0058: 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 (item?.m_shared != null && !PendingMultiUserContainerLocalRecoveries.Any((PendingMultiUserContainerLocalRecovery recovery) => recovery.Item == item))
			{
				PendingMultiUserContainerLocalRecoveries.Add(new PendingMultiUserContainerLocalRecovery
				{
					Inventory = inventory,
					Item = item,
					PreferredPosition = preferredPosition,
					NextAttemptAt = Time.unscaledTime + 1f,
					PlacementPolicy = placementPolicy
				});
			}
		}

		private static bool TrySecurePendingMultiUserContainerLocalRecovery(PendingMultiUserContainerTransfer pending)
		{
			//IL_0052: 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_00aa: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			if (!pending.LocalRecoveryPending)
			{
				return true;
			}
			ItemData pendingRecoveryItem = pending.PendingRecoveryItem;
			if (pendingRecoveryItem == null)
			{
				return false;
			}
			ItemData securedItem = null;
			bool flag;
			switch (pending.RecoveryMode)
			{
			case MultiUserContainerRecoveryMode.RegularInventoryFirst:
				flag = pending.LocalInventory != null && TryInsertMultiUserContainerItemIntoLocalInventory(pending.LocalInventory, pendingRecoveryItem, pendingRecoveryItem.m_stack, pending.PreferredLocalPosition, out securedItem, MultiUserContainerLocalPlacementPolicy.RegularAndHotbar);
				break;
			case MultiUserContainerRecoveryMode.BatchInventoryFirst:
				flag = pending.LocalInventory != null && TryInsertMultiUserContainerItemIntoLocalInventory(pending.LocalInventory, pendingRecoveryItem, pendingRecoveryItem.m_stack, pending.PreferredLocalPosition, out securedItem, MultiUserContainerLocalPlacementPolicy.ContainerBatch);
				break;
			case MultiUserContainerRecoveryMode.ConsumeAfterInventory:
				flag = pending.LocalInventory != null && TryInsertMultiUserContainerItemIntoLocalInventory(pending.LocalInventory, pendingRecoveryItem, pendingRecoveryItem.m_stack, pending.PreferredLocalPosition, out securedItem);
				break;
			case MultiUserContainerRecoveryMode.WorldFirst:
			{
				MultiUserContainerWorldDeliveryResult num = TryDeliverPendingMultiUserContainerRecoveryToWorld(pending, pendingRecoveryItem);
				flag = num == MultiUserContainerWorldDeliveryResult.Succeeded;
				if (num == MultiUserContainerWorldDeliveryResult.DefinitelyNotSpawned && pending.LocalInventory != null)
				{
					flag = TryInsertMultiUserContainerItemIntoLocalInventory(pending.LocalInventory, pendingRecoveryItem, pendingRecoveryItem.m_stack, pending.PreferredLocalPosition, out securedItem);
				}
				break;
			}
			default:
				flag = pending.LocalInventory != null && TryInsertMultiUserContainerItemIntoLocalInventory(pending.LocalInventory, pendingRecoveryItem, pendingRecoveryItem.m_stack, pending.PreferredLocalPosition, out securedItem);
				break;
			}
			if (!flag)
			{
				return false;
			}
			pending.LocalRecoveryPending = false;
			pending.PendingRecoveryItem = null;
			if (pending.TerminalFailureReceived)
			{
				pending.LocalEscrow = null;
			}
			if (pending.RecoveryMode == MultiUserContainerRecoveryMode.ConsumeAfterInventory && securedItem != null)
			{
				TryConsumeSecuredMultiUserContainerItem(pending, securedItem);
			}
			return true;
		}

		private static MultiUserContainerWorldDeliveryResult TryDeliverPendingMultiUserContainerRecoveryToWorld(PendingMultiUserContainerTransfer pending, ItemData recoveryItem)
		{
			if (pending.WorldDeliveryResult != MultiUserContainerWorldDeliveryResult.NotAttempted)
			{
				return pending.WorldDeliveryResult;
			}
			pending.WorldDeliveryResult = MultiUserContainerWorldDeliveryResult.Uncertain;
			MultiUserContainerWorldDeliveryResult worldDeliveryResult = DeliverMultiUserContainerItemToWorld(recoveryItem, recoveryItem.m_stack);
			pending.WorldDeliveryResult = worldDeliveryResult;
			if (pending.WorldDeliveryResult == MultiUserContainerWorldDeliveryResult.Uncertain)
			{
				Log.LogError((object)"Built-in multi-user chest world-drop result is uncertain; local fallback and acknowledgement are blocked to avoid duplication.");
			}
			return pending.WorldDeliveryResult;
		}

		private static void TryConsumeSecuredMultiUserContainerItem(PendingMultiUserContainerTransfer pending, ItemData securedItem)
		{
			if (pending.CompletionActionAttempted)
			{
				return;
			}
			pending.CompletionActionAttempted = true;
			Player localPlayer = Player.m_localPlayer;
			Inventory localInventory = pending.LocalInventory;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || localInventory == null || !IsLocalPlayerInventory(localInventory) || securedItem?.m_shared == null || !localInventory.ContainsItem(securedItem))
			{
				return;
			}
			try
			{
				((Humanoid)localPlayer).UseItem(localInventory, securedItem, true);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest consume callback failed: " + ex.Message));
			}
		}

		private static bool TryAcknowledgePendingMultiUserContainerResponse(PendingMultiUserContainerTransfer pending, Container container)
		{
			if (!pending.AcknowledgementPending)
			{
				return true;
			}
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return false;
			}
			try
			{
				AcknowledgeMultiUserContainerResponse(container, pending.Request.RequestId, pending.Request.RequesterPlayerId, pending.RequestDigest);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest acknowledgement failed: " + ex.Message));
				return false;
			}
			pending.AcknowledgementPending = false;
			return true;
		}

		private static void CloseMultiUserContainerAfterRecoveryTimeout(PendingMultiUserContainerTransfer pending, Container container, float now)
		{
			if (!(now - pending.ResponseAppliedAt < 5f))
			{
				InventoryGui instance = InventoryGui.instance;
				if ((Object)(object)instance != (Object)null && !IsUnityNull((Object?)(object)instance) && (Object)(object)instance.m_currentContainer == (Object)(object)container)
				{
					instance.CloseContainer();
				}
			}
		}

		private static void ProcessPendingMultiUserContainerLocalRecoveries()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			float unscaledTime = Time.unscaledTime;
			for (int num = PendingMultiUserContainerLocalRecoveries.Count - 1; num >= 0; num--)
			{
				PendingMultiUserContainerLocalRecovery pendingMultiUserContainerLocalRecovery = PendingMultiUserContainerLocalRecoveries[num];
				if (!(unscaledTime < pendingMultiUserContainerLocalRecovery.NextAttemptAt))
				{
					if (pendingMultiUserContainerLocalRecovery.Inventory != null && TryInsertMultiUserContainerItemIntoLocalInventory(pendingMultiUserContainerLocalRecovery.Inventory, pendingMultiUserContainerLocalRecovery.Item, pendingMultiUserContainerLocalRecovery.Item.m_stack, pendingMultiUserContainerLocalRecovery.PreferredPosition, out ItemData _, pendingMultiUserContainerLocalRecovery.PlacementPolicy))
					{
						PendingMultiUserContainerLocalRecoveries.RemoveAt(num);
					}
					else
					{
						pendingMultiUserContainerLocalRecovery.NextAttemptAt = unscaledTime + 1f;
					}
				}
			}
		}

		private static bool TryInsertMultiUserContainerItemIntoLocalInventory(Inventory inventory, ItemData item, int amount, Vector2i preferredPosition, out ItemData? securedItem, MultiUserContainerLocalPlacementPolicy placementPolicy = MultiUserContainerLocalPlacementPolicy.AnyUsable)
		{
			//IL_0035: 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_0049: 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_0075: 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_00c8: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			securedItem = null;
			if (!IsLocalPlayerInventory(inventory) || item?.m_shared == null || amount <= 0 || amount > item.m_stack || !CanAddWithinInventoryLimits(inventory, item, amount, out var _))
			{
				return false;
			}
			Vector2i destination = preferredPosition;
			if (((placementPolicy != MultiUserContainerLocalPlacementPolicy.AnyUsable && !IsMultiUserContainerLocalCellAllowed(inventory, destination, placementPolicy)) || !CanReceiveEntireMultiUserContainerItemAt(inventory, item, amount, destination)) && !((placementPolicy != MultiUserContainerLocalPlacementPolicy.AnyUsable) ? TryFindRestrictedMultiUserContainerDestination(inventory, item, amount, placementPolicy, out destination) : TryFindLocalMultiUserContainerDestination(inventory, item, amount, out destination)))
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(destination.x, destination.y);
			if (itemAt != null)
			{
				if (!CanStackEntireMultiUserContainerItem(item, itemAt, amount))
				{
					return false;
				}
				itemAt.m_stack += amount;
				NotifyMultiUserContainerInventoryChanged(inventory);
				securedItem = itemAt;
				return true;
			}
			ItemData val;
			try
			{
				val = item.Clone();
			}
			catch
			{
				return false;
			}
			val.m_stack = amount;
			val.m_gridPos = destination;
			val.m_equipped = false;
			inventory.m_inventory.Add(val);
			NotifyMultiUserContainerInventoryChanged(inventory);
			securedItem = val;
			try
			{
				OnPlayerInventoryItemPlaced(inventory, val, destination, result: true);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest placement callback failed: " + ex.Message));
				return inventory.ContainsItem(val);
			}
			return true;
		}

		private static bool IsMultiUserContainerLocalCellAllowed(Inventory inventory, Vector2i position, MultiUserContainerLocalPlacementPolicy placementPolicy)
		{
			//IL_0023: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || !IsLocalPlayerInventory(inventory))
			{
				return false;
			}
			InventoryCellKind inventoryCellKind = GetInventoryCellKind(localPlayer, inventory, position);
			return placementPolicy switch
			{
				MultiUserContainerLocalPlacementPolicy.RegularAndHotbar => InventoryActionCellPolicyCore.CanUseContainerActionSource(inventoryCellKind, includeHotbar: true), 
				MultiUserContainerLocalPlacementPolicy.ContainerBatch => GetPlayerActionSlots(localPlayer, inventory, includeHotbar: false, blockFavorites: true).Contains(position), 
				_ => true, 
			};
		}

		private static bool TryFindRestrictedMultiUserContainerDestination(Inventory inventory, ItemData incoming, int amount, MultiUserContainerLocalPlacementPolicy placementPolicy, out Vector2i destination)
		{
			//IL_0004: 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_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_0062: 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_0088: 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_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_00c0: 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_00d7: 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)
			destination = new Vector2i(-1, -1);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || !IsLocalPlayerInventory(inventory) || incoming?.m_shared == null)
			{
				return false;
			}
			bool flag = placementPolicy == MultiUserContainerLocalPlacementPolicy.ContainerBatch;
			List<Vector2i> playerActionSlots = GetPlayerActionSlots(localPlayer, inventory, !flag, flag);
			foreach (Vector2i item in playerActionSlots)
			{
				ItemData itemAt = inventory.GetItemAt(item.x, item.y);
				if (itemAt != null && CanStackEntireMultiUserContainerItem(incoming, itemAt, amount))
				{
					destination = item;
					return true;
				}
			}
			foreach (Vector2i item2 in playerActionSlots)
			{
				if (inventory.GetItemAt(item2.x, item2.y) == null)
				{
					destination = item2;
					return true;
				}
			}
			return false;
		}

		private static MultiUserContainerWorldDeliveryResult DeliverMultiUserContainerItemToWorld(ItemData? item, int amount)
		{
			//IL_0035: 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_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_0051: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || IsUnityNull((Object?)(object)localPlayer) || item?.m_shared == null || amount <= 0)
			{
				return MultiUserContainerWorldDeliveryResult.DefinitelyNotSpawned;
			}
			Transform transform = ((Component)localPlayer).transform;
			ItemDrop val;
			try
			{
				val = ItemDrop.DropItem(item, amount, transform.position + transform.forward + transform.up, transform.rotation);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest local item drop failed: " + ex.Message));
				return MultiUserContainerWorldDeliveryResult.Uncertain;
			}
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
			{
				return MultiUserContainerWorldDeliveryResult.Uncertain;
			}
			try
			{
				val.OnPlayerDrop();
				Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
				if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
				{
					component.linearVelocity = (transform.forward + Vector3.up) * 5f;
				}
				((Character)localPlayer).m_zanim.SetTrigger("interact");
				((Humanoid)localPlayer).m_dropEffects.Create(transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				ItemData itemData = val.m_itemData;
				((Character)localPlayer).Message((MessageType)1, "$msg_dropped " + itemData.m_shared.m_name, itemData.m_stack, itemData.GetIcon());
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Built-in multi-user chest local drop effects failed: " + ex2.Message));
			}
			return MultiUserContainerWorldDeliveryResult.Succeeded;
		}

		private static void ShowMultiUserContainerNotReady()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer))
			{
				((Character)localPlayer).Message((MessageType)2, LocalizeUi("$inventoryslots_container_not_ready", "Container is not ready."), 0, (Sprite)null);
			}
		}

		private static void ShowMultiUserContainerUnsupportedDestination()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && !IsUnityNull((Object?)(object)localPlayer))
			{
				((Character)localPlayer).Message((MessageType)2, LocalizeUi("$inventoryslots_multi_user_chest_use_empty_slot", "Use an empty slot or a matching stack."), 0, (Sprite)null);
			}
		}

		internal static bool TryHandleMultiUserContainerOpen(Container container, long sender, long playerId)
		{
			//IL_00b9: 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_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)
			if (!IsBuiltInMultiUserChestEnabled || (Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || !IsBuiltInMultiUserContainerEligible(container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsOwner())
			{
				return false;
			}
			int num;
			if (sender != 0L && playerId != 0L && TryGetRpcSenderPlayer(sender, playerId, out Player requester) && (Object)(object)requester != (Object)null && !IsUnityNull((Object?)(object)requester) && container.CheckAccess(playerId))
			{
				Vector3 val = ((Component)requester).transform.position - ((Component)container).transform.position;
				num = ((((Vector3)(ref val)).sqrMagnitude <= 100f) ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			bool flag = (byte)num != 0;
			if (flag)
			{
				ZDO zDO = container.m_nview.GetZDO();
				if (zDO != null && ZDOMan.instance != null)
				{
					try
					{
						ZDOMan.instance.ForceSendZDO(sender, zDO.m_uid);
					}
					catch (Exception ex)
					{
						Log.LogWarning((object)("Built-in multi-user chest open force-send failed: " + ex.Message));
					}
				}
			}
			container.m_nview.InvokeRPC(sender, "OpenRespons", new object[1] { flag });
			return true;
		}

		internal static bool TryUpdateMultiUserRemoteContainer(InventoryGui gui, Player player)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (!IsBuiltInMultiUserChestEnabled || (Object)(object)gui == (Object)null || (Object)(object)player == (Object)null || (Object)(object)gui.m_currentContainer == (Object)null || !TryGetBuiltInRemoteContainer(gui.m_currentContainer.GetInventory(), out Container container) || (Object)(object)container != (Object)(object)gui.m_currentContainer)
			{
				return false;
			}
			if (!gui.m_animator.GetBool("visible"))
			{
				return true;
			}
			container.CheckForChanges();
			((Component)gui.m_container).gameObject.SetActive(true);
			gui.m_containerGrid.UpdateInventory(container.GetInventory(), (Player)null, gui.m_dragItem);
			gui.m_containerName.text = Localization.instance.Localize(container.GetInventory().GetName());
			if (gui.m_firstContainerUpdate)
			{
				gui.m_containerGrid.ResetView();
				gui.m_firstContainerUpdate = false;
				gui.m_containerHoldTime = 0f;
				gui.m_containerHoldState = 0;
			}
			if (Vector3.Distance(((Component)container).transform.position, ((Component)player).transform.position) > gui.m_autoCloseDistance)
			{
				gui.CloseContainer();
				return true;
			}
			if (ZInput.GetButton("Use") || ZInput.GetButton("JoyUse"))
			{
				gui.m_containerHoldTime += Time.deltaTime;
				if (gui.m_containerHoldTime > gui.m_containerHoldPlaceStackDelay && gui.m_containerHoldState == 0)
				{
					gui.m_containerHoldState = 1;
					if (!TryHandleMultiUserContainerAreaQuickStack(container))
					{
						ShowMultiUserContainerNotReady();
					}
				}
				else if (gui.m_containerHoldTime > gui.m_containerHoldPlaceStackDelay + gui.m_containerHoldExitDelay && gui.m_containerHoldState == 1)
				{
					gui.Hide();
				}
			}
			else if (gui.m_containerHoldState >= 0)
			{
				gui.m_containerHoldState = -1;
			}
			return true;
		}

		internal static bool TryGetMultiUserContainerProjection(Inventory realInventory, out Inventory projection)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			projection = null;
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || pendingMultiUserContainerTransfer.TerminalFailureReceived || realInventory == null || (Object)(object)pendingMultiUserContainerTransfer.Container == (Object)null || IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container) || pendingMultiUserContainerTransfer.Container.GetInventory() != realInventory)
			{
				return false;
			}
			if (pendingMultiUserContainerTransfer.AuthoritativeStateObserved)
			{
				return false;
			}
			if (pendingMultiUserContainerTransfer.Projection != null)
			{
				projection = pendingMultiUserContainerTransfer.Projection;
				return true;
			}
			Inventory val;
			try
			{
				val = new Inventory(realInventory.GetName(), (Sprite)null, realInventory.GetWidth(), realInventory.GetHeight());
				foreach (ItemData allItem in realInventory.GetAllItems())
				{
					if (allItem?.m_shared == null)
					{
						return false;
					}
					val.m_inventory.Add(allItem.Clone());
				}
			}
			catch
			{
				return false;
			}
			if (pendingMultiUserContainerTransfer.Request.Operation switch
			{
				MultiUserContainerOperation.Add => TryApplyMultiUserContainerAdd(val, pendingMultiUserContainerTransfer.Request.Item, pendingMultiUserContainerTransfer.Request.Amount, pendingMultiUserContainerTransfer.Request.TargetPosition, pendingMultiUserContainerTransfer.Request.ExpectedTargetStack) ? 1 : 0, 
				MultiUserContainerOperation.Remove => TryApplyMultiUserContainerRemove(val, pendingMultiUserContainerTransfer.Request.Item, pendingMultiUserContainerTransfer.Request.Amount, pendingMultiUserContainerTransfer.Request.SourcePosition, out ItemData removed) ? 1 : 0, 
				MultiUserContainerOperation.Move => TryApplyMultiUserContainerMove(val, pendingMultiUserContainerTransfer.Request.Item, pendingMultiUserContainerTransfer.Request.Amount, pendingMultiUserContainerTransfer.Request.SourcePosition, pendingMultiUserContainerTransfer.Request.TargetPosition, pendingMultiUserContainerTransfer.Request.ExpectedTargetStack) ? 1 : 0, 
				MultiUserContainerOperation.Exchange => TryApplyMultiUserContainerExchange(val, pendingMultiUserContainerTransfer.Request.Item, pendingMultiUserContainerTransfer.Request.CounterpartItem, pendingMultiUserContainerTransfer.Request.SourcePosition, out removed) ? 1 : 0, 
				MultiUserContainerOperation.Swap => TryApplyMultiUserContainerSwap(val, pendingMultiUserContainerTransfer.Request.Item, pendingMultiUserContainerTransfer.Request.CounterpartItem, pendingMultiUserContainerTransfer.Request.SourcePosition, pendingMultiUserContainerTransfer.Request.TargetPosition) ? 1 : 0, 
				_ => 0, 
			} == 0)
			{
				return false;
			}
			pendingMultiUserContainerTransfer.Projection = val;
			projection = pendingMultiUserContainerTransfer.Projection;
			return true;
		}

		internal static void RestoreMultiUserContainerGridInventory(InventoryGrid grid, Inventory realInventory)
		{
			if ((Object)(object)grid != (Object)null && !IsUnityNull((Object?)(object)grid) && realInventory != null)
			{
				grid.m_inventory = realInventory;
			}
		}

		internal static bool ShouldBlockMultiUserContainerGamepadInput(InventoryGrid grid)
		{
			if (IsMultiUserContainerBatchInteractionBlocked(InventoryGui.instance))
			{
				return true;
			}
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer == null || (Object)(object)grid == (Object)null || IsUnityNull((Object?)(object)grid))
			{
				return false;
			}
			Inventory inventory = grid.GetInventory();
			if (inventory != pendingMultiUserContainerTransfer.Projection)
			{
				if ((Object)(object)pendingMultiUserContainerTransfer.Container != (Object)null && !IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container))
				{
					return inventory == pendingMultiUserContainerTransfer.Container.GetInventory();
				}
				return false;
			}
			return true;
		}

		internal static void OnMultiUserContainerInventoryLoaded(Inventory inventory)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (pendingMultiUserContainerTransfer != null && (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)null && !IsUnityNull((Object?)(object)pendingMultiUserContainerTransfer.Container) && pendingMultiUserContainerTransfer.Container.GetInventory() == inventory)
			{
				pendingMultiUserContainerTransfer.Projection = null;
				pendingMultiUserContainerTransfer.AuthoritativeStateObserved = !pendingMultiUserContainerTransfer.TerminalFailureReceived && IsMultiUserContainerRequestVisibleInInventory(pendingMultiUserContainerTransfer, inventory);
				if (pendingMultiUserContainerTransfer.ResponseApplied && !pendingMultiUserContainerTransfer.LocalRecoveryPending && !pendingMultiUserContainerTransfer.AcknowledgementPending && pendingMultiUserContainerTransfer.AuthoritativeStateObserved && _pendingMultiUserContainerTransfer == pendingMultiUserContainerTransfer)
				{
					CompletePendingMultiUserContainerTransfer(pendingMultiUserContainerTransfer, committedAndObserved: true);
				}
			}
			InventoryGui instance = InventoryGui.instance;
			if (inventory != null && !((Object)(object)instance == (Object)null) && !IsUnityNull((Object?)(object)instance) && instance.m_dragItem != null && instance.m_dragInventory == inventory && !((Object)(object)instance.m_currentContainer == (Object)null) && instance.m_currentContainer.GetInventory() == inventory)
			{
				ItemData dragItem = instance.m_dragItem;
				Vector2i gridPos = dragItem.m_gridPos;
				ItemData itemAt = inventory.GetItemAt(gridPos.x, gridPos.y);
				int requiredStack = Math.Min(Math.Max(1, instance.m_dragAmount), Math.Max(1, dragItem.m_stack));
				if (itemAt == null || !IsExactMultiUserContainerItemMatch(dragItem, itemAt, requiredStack))
				{
					instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
					return;
				}
				instance.m_dragItem = itemAt;
				instance.m_dragAmount = Math.Min(itemAt.m_stack, instance.m_dragAmount);
			}
		}

		internal static void RegisterMultiUserContainerRpcs(Container container)
		{
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container))
			{
				return;
			}
			if ((Object)(object)container.m_nview == (Object)null)
			{
				container.m_nview = (((Object)(object)container.m_rootObjectOverride != (Object)null) ? ((Component)container.m_rootObjectOverride).GetComponent<ZNetView>() : ((Component)container).GetComponent<ZNetView>());
			}
			if (!((Object)(object)container.m_nview == (Object)null) && !IsUnityNull((Object?)(object)container.m_nview))
			{
				container.m_nview.Unregister("InventorySlots_MUC_Request_v3");
				container.m_nview.Unregister("InventorySlots_MUC_Response_v3");
				container.m_nview.Unregister("InventorySlots_MUC_Ack_v3");
				container.m_nview.Register<ZPackage>("InventorySlots_MUC_Request_v3", (Action<long, ZPackage>)delegate(long sender, ZPackage package)
				{
					RPC_MultiUserContainerRequest(container, sender, package);
				});
				container.m_nview.Register<ZPackage>("InventorySlots_MUC_Response_v3", (Action<long, ZPackage>)delegate(long sender, ZPackage package)
				{
					RPC_MultiUserContainerResponse(container, sender, package);
				});
				container.m_nview.Register<ZPackage>("InventorySlots_MUC_Ack_v3", (Action<long, ZPackage>)delegate(long sender, ZPackage package)
				{
					RPC_MultiUserContainerAcknowledge(container, sender, package);
				});
				RebindPendingMultiUserContainer(container);
			}
		}

		internal static void UnregisterMultiUserContainerRpcs(Container container)
		{
			if (!((Object)(object)container == (Object)null) && !IsUnityNull((Object?)(object)container))
			{
				if ((Object)(object)container.m_nview != (Object)null && !IsUnityNull((Object?)(object)container.m_nview))
				{
					container.m_nview.Unregister("InventorySlots_MUC_Request_v3");
					container.m_nview.Unregister("InventorySlots_MUC_Response_v3");
					container.m_nview.Unregister("InventorySlots_MUC_Ack_v3");
				}
				SuspendPendingMultiUserContainer(container);
				MultiUserContainerOwnerStates.Remove(container);
			}
		}

		private static void RPC_MultiUserContainerRequest(Container container, long sender, ZPackage package)
		{
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || package == null || package.Size() <= 0 || package.Size() > 98304 || !TryReadMultiUserContainerRequestHeader(package, out MultiUserContainerRequest request) || request == null || !TryComputeMultiUserContainerDigest(package, out byte[] digest))
			{
				return;
			}
			MultiUserContainerOwnerState multiUserContainerOwnerState = GetMultiUserContainerOwnerState(container);
			MultiUserContainerOwnerRequestKey key = new MultiUserContainerOwnerRequestKey(sender, request.RequestId);
			if (multiUserContainerOwnerState.UncertainRequests.TryGetValue(key, out MultiUserContainerUncertainRequest value))
			{
				if (!AreMultiUserContainerDigestsEqual(value.RequestDigest, digest))
				{
					MultiUserContainerResponse multiUserContainerResponse = CreateMultiUserContainerResponse(request);
					multiUserContainerResponse.Failure = MultiUserContainerFailure.InvalidRequest;
					SendMultiUserContainerResponse(container, sender, multiUserContainerResponse);
				}
				return;
			}
			if (multiUserContainerOwnerState.Responses.TryGetValue(key, out MultiUserContainerOwnerResponse value2))
			{
				if (AreMultiUserContainerDigestsEqual(value2.RequestDigest, digest))
				{
					SendMultiUserContainerResponse(container, sender, value2.ResponseBytes);
					return;
				}
				MultiUserContainerResponse multiUserContainerResponse2 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse2.Failure = MultiUserContainerFailure.InvalidRequest;
				SendMultiUserContainerResponse(container, sender, multiUserContainerResponse2);
				return;
			}
			if (TryReadMultiUserContainerDurableReceipt(container, request.RequesterPlayerId, request.RequestId, out MultiUserContainerDurableReceipt receipt) && receipt != null && receipt.Sender == sender && receipt.RequestId == request.RequestId)
			{
				if (AreMultiUserContainerDigestsEqual(receipt.RequestDigest, digest))
				{
					if (!receipt.Acknowledged)
					{
						CacheMultiUserContainerOwnerResponse(multiUserContainerOwnerState, key, receipt.RequestDigest, receipt.ResponseBytes);
						SendMultiUserContainerResponse(container, sender, receipt.ResponseBytes);
					}
				}
				else
				{
					MultiUserContainerResponse multiUserContainerResponse3 = CreateMultiUserContainerResponse(request);
					multiUserContainerResponse3.Failure = MultiUserContainerFailure.InvalidRequest;
					SendMultiUserContainerResponse(container, sender, multiUserContainerResponse3);
				}
				return;
			}
			if (!CanIdentifyMultiUserContainerRequester(container, sender, request, out Player requester))
			{
				MultiUserContainerResponse multiUserContainerResponse4 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse4.Failure = MultiUserContainerFailure.AccessDenied;
				SendMultiUserContainerResponse(container, sender, multiUserContainerResponse4);
				return;
			}
			if (!CanProcessNewMultiUserContainerRequest(container, requester, request.RequesterPlayerId))
			{
				MultiUserContainerResponse multiUserContainerResponse5 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse5.Failure = ((!IsBuiltInMultiUserChestEnabled) ? MultiUserContainerFailure.Disabled : MultiUserContainerFailure.AccessDenied);
				SendMultiUserContainerResponse(container, sender, multiUserContainerResponse5);
				return;
			}
			if (multiUserContainerOwnerState.Responses.Count + multiUserContainerOwnerState.UncertainRequests.Count >= 128 || multiUserContainerOwnerState.TotalResponseBytes > 33554432 - package.Size())
			{
				MultiUserContainerResponse multiUserContainerResponse6 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse6.Failure = MultiUserContainerFailure.OwnerChanged;
				SendMultiUserContainerResponse(container, sender, multiUserContainerResponse6);
				return;
			}
			if (!TryReadMultiUserContainerRequestItem(package, request))
			{
				MultiUserContainerResponse multiUserContainerResponse7 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse7.Failure = MultiUserContainerFailure.InvalidRequest;
				SendMultiUserContainerResponse(container, sender, multiUserContainerResponse7);
				return;
			}
			if (!CanPersistMultiUserContainerDurableReceipt(container, sender, request, digest))
			{
				MultiUserContainerResponse multiUserContainerResponse8 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse8.Failure = MultiUserContainerFailure.OwnerChanged;
				SendMultiUserContainerResponse(container, sender, multiUserContainerResponse8);
				return;
			}
			List<ItemData> rollbackItems;
			bool outcomeUncertain;
			MultiUserContainerResponse multiUserContainerResponse9 = ProcessMultiUserContainerRequest(container, sender, request, out rollbackItems, out outcomeUncertain);
			if (outcomeUncertain)
			{
				QuarantineMultiUserContainerOwnerRequest(multiUserContainerOwnerState, key, digest);
				Log.LogError((object)"Built-in multi-user chest could not verify its transaction rollback; the request will remain pending.");
				return;
			}
			if (!TryWriteMultiUserContainerResponse(multiUserContainerResponse9, out ZPackage package2))
			{
				if (multiUserContainerResponse9.Success && rollbackItems != null && !RestoreMultiUserContainerInventory(container, container.GetInventory(), rollbackItems))
				{
					QuarantineMultiUserContainerOwnerRequest(multiUserContainerOwnerState, key, digest);
					Log.LogError((object)"Built-in multi-user chest could not verify rollback after response serialization failed.");
					return;
				}
				multiUserContainerResponse9 = CreateMultiUserContainerResponse(request);
				multiUserContainerResponse9.Failure = MultiUserContainerFailure.InvalidRequest;
				if (!TryWriteMultiUserContainerResponse(multiUserContainerResponse9, out package2))
				{
					return;
				}
			}
			byte[] array = package2.GetArray();
			if (!TryWriteMultiUserContainerDurableReceipt(container, sender, request.RequesterPlayerId, request.RequestId, digest, array, out var outcomeUncertain2))
			{
				if (outcomeUncertain2)
				{
					QuarantineMultiUserContainerOwnerRequest(multiUserContainerOwnerState, key, digest);
					Log.LogError((object)"Built-in multi-user chest could not verify its latest transaction receipt; the request will remain pending.");
					return;
				}
				if (multiUserContainerResponse9.Success && rollbackItems != null && !RestoreMultiUserContainerInventory(container, container.GetInventory(), rollbackItems))
				{
					QuarantineMultiUserContainerOwnerRequest(multiUserContainerOwnerState, key, digest);
					Log.LogError((object)"Built-in multi-user chest could not verify rollback after receipt persistence failed.");
				}
				Log.LogWarning((object)"Built-in multi-user chest could not persist its latest transaction receipt.");
			}
			else
			{
				CacheMultiUserContainerOwnerResponse(multiUserContainerOwnerState, key, digest, array);
				SendMultiUserContainerResponse(container, sender, array);
			}
		}

		private static void RPC_MultiUserContainerResponse(Container container, long sender, ZPackage package)
		{
			if (!((Object)(object)container == (Object)null) && !IsUnityNull((Object?)(object)container) && package != null && package.Size() > 0 && package.Size() <= 49152 && TryReadMultiUserContainerResponse(package, out MultiUserContainerResponse response) && response != null)
			{
				HandleMultiUserContainerResponse(container, sender, response);
			}
		}

		private static void RPC_MultiUserContainerAcknowledge(Container container, long sender, ZPackage package)
		{
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || sender == 0L || package == null || package.Size() <= 0 || package.Size() > 256 || !TryReadMultiUserContainerAcknowledge(package, out int requestId, out long requesterPlayerId, out byte[] requestDigest) || requestDigest == null)
			{
				return;
			}
			MultiUserContainerOwnerRequestKey key = new MultiUserContainerOwnerRequestKey(sender, requestId);
			if (TryReadMultiUserContainerDurableReceipt(container, requesterPlayerId, requestId, out MultiUserContainerDurableReceipt receipt) && receipt != null && receipt.Sender == sender && receipt.RequestId == requestId && AreMultiUserContainerDigestsEqual(receipt.RequestDigest, requestDigest) && AcknowledgeMultiUserContainerDurableReceipt(container, requesterPlayerId, requestId, sender) && MultiUserContainerOwnerStates.TryGetValue(container, out MultiUserContainerOwnerState value))
			{
				if (value.Responses.TryGetValue(key, out MultiUserContainerOwnerResponse value2) && AreMultiUserContainerDigestsEqual(value2.RequestDigest, requestDigest))
				{
					value.TotalResponseBytes = Math.Max(0, value.TotalResponseBytes - value2.ResponseBytes.Length);
					value.Responses.Remove(key);
				}
				if (value.UncertainRequests.TryGetValue(key, out MultiUserContainerUncertainRequest value3) && AreMultiUserContainerDigestsEqual(value3.RequestDigest, requestDigest))
				{
					value.UncertainRequests.Remove(key);
				}
			}
		}

		private static bool CanIdentifyMultiUserContainerRequester(Container container, long sender, MultiUserContainerRequest request, out Player? requester)
		{
			requester = null;
			if (sender == 0L || request.RequestId <= 0 || request.RequesterPlayerId == 0L || request.Amount <= 0 || !Enum.IsDefined(typeof(MultiUserContainerOperation), request.Operation) || !TryGetRpcSenderPlayer(sender, request.RequesterPlayerId, out requester) || (Object)(object)requester == (Object)null || IsUnityNull((Object?)(object)requester))
			{
				return false;
			}
			return true;
		}

		private static bool CanProcessNewMultiUserContainerRequest(Container container, Player requester, long requesterPlayerId)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			float num = 10f;
			if (IsBuiltInMultiUserChestEnabled && (Object)(object)container.m_nview != (Object)null && container.m_nview.IsValid() && container.m_nview.IsOwner() && IsBuiltInMultiUserContainerEligible(container) && (Object)(object)requester != (Object)null && !IsUnityNull((Object?)(object)requester) && container.CheckAccess(requesterPlayerId))
			{
				Vector3 val = ((Component)requester).transform.position - ((Component)container).transform.position;
				return ((Vector3)(ref val)).sqrMagnitude <= num * num;
			}
			return false;
		}

		private static bool TryComputeMultiUserContainerDigest(ZPackage package, out byte[]? digest)
		{
			digest = null;
			if (package == null)
			{
				return false;
			}
			try
			{
				return TryComputeMultiUserContainerDigest(package.GetArray(), out digest);
			}
			catch
			{
				digest = null;
				return false;
			}
		}

		private static bool TryComputeMultiUserContainerDigest(byte[] bytes, out byte[]? digest)
		{
			digest = null;
			if (bytes == null || bytes.Length == 0)
			{
				return false;
			}
			try
			{
				using SHA256 sHA = SHA256.Create();
				digest = sHA.ComputeHash(bytes);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool AreMultiUserContainerDigestsEqual(byte[] left, byte[] right)
		{
			if (left == null || right == null || left.Length != right.Length)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < left.Length; i++)
			{
				num |= left[i] ^ right[i];
			}
			return num == 0;
		}

		private static MultiUserContainerResponse ProcessMultiUserContainerRequest(Container container, long sender, MultiUserContainerRequest request, out List<ItemData>? rollbackItems, out bool outcomeUncertain)
		{
			//IL_00e5: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			rollbackItems = null;
			outcomeUncertain = false;
			MultiUserContainerResponse multiUserContainerResponse = CreateMultiUserContainerResponse(request);
			if (!IsBuiltInMultiUserChestEnabled)
			{
				multiUserContainerResponse.Failure = MultiUserContainerFailure.Disabled;
				return multiUserContainerResponse;
			}
			if ((Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid() || !container.m_nview.IsOwner())
			{
				multiUserContainerResponse.Failure = MultiUserContainerFailure.OwnerChanged;
				return multiUserContainerResponse;
			}
			if (IsMultiUserChestIgnored(container) || sender == 0L || request.RequesterPlayerId == 0L || !IsRpcSenderForPlayer(sender, request.RequesterPlayerId) || !container.CheckAccess(request.RequesterPlayerId))
			{
				multiUserContainerResponse.Failure = MultiUserContainerFailure.AccessDenied;
				return multiUserContainerResponse;
			}
			Inventory inventory = container.GetInventory();
			if (inventory == null || !IsValidMultiUserContainerRequest(inventory, request) || !TryCaptureMultiUserContainerInventory(inventory, out rollbackItems))
			{
				multiUserContainerResponse.Failure = MultiUserContainerFailure.InvalidRequest;
				return multiUserContainerResponse;
			}
			switch (request.Operation)
			{
			case MultiUserContainerOperation.Add:
				multiUserContainerResponse.Success = TryApplyMultiUserContainerAdd(inventory, request.Item, request.Amount, request.TargetPosition, request.ExpectedTargetStack);
				multiUserContainerResponse.Amount = (multiUserContainerResponse.Success ? request.Amount : 0);
				multiUserContainerResponse.Failure = ((!multiUserContainerResponse.Success) ? MultiUserContainerFailure.DestinationChanged : MultiUserContainerFailure.None);
				break;
			case MultiUserContainerOperation.Remove:
			{
				multiUserContainerResponse.Success = TryApplyMultiUserContainerRemove(inventory, request.Item, request.Amount, request.SourcePosition, out ItemData removed);
				multiUserContainerResponse.Amount = (multiUserContainerResponse.Success ? request.Amount : 0);
				multiUserContainerResponse.Item = (multiUserContainerResponse.Success ? removed : null);
				multiUserContainerResponse.Failure = ((!multiUserContainerResponse.Success) ? MultiUserContainerFailure.ItemChanged : MultiUserContainerFailure.None);
				break;
			}
			case MultiUserContainerOperation.Move:
				multiUserContainerResponse.Success = TryApplyMultiUserContainerMove(inventory, request.Item, request.Amount, request.SourcePosition, request.TargetPosition, request.ExpectedTargetStack);
				multiUserContainerResponse.Amount = (multiUserContainerResponse.Success ? request.Amount : 0);
				multiUserContainerResponse.Failure = ((!multiUserContainerResponse.Success) ? MultiUserContainerFailure.DestinationChanged : MultiUserContainerFailure.None);
				break;
			case MultiUserContainerOperation.Exchange:
			{
				multiUserContainerResponse.Success = TryApplyMultiUserContainerExchange(inventory, request.Item, request.CounterpartItem, request.SourcePosition, out ItemData displaced);
				multiUserContainerResponse.Amount = (multiUserContainerResponse.Success ? request.Amount : 0);
				multiUserContainerResponse.Item = (multiUserContainerResponse.Success ? displaced : null);
				multiUserContainerResponse.Failure = ((!multiUserContainerResponse.Success) ? MultiUserContainerFailure.ItemChanged : MultiUserContainerFailure.None);
				break;
			}
			case MultiUserContainerOperation.Swap:
				multiUserContainerResponse.Success = TryApplyMultiUserContainerSwap(inventory, request.Item, request.CounterpartItem, request.SourcePosition, request.TargetPosition);
				multiUserContainerResponse.Amount = (multiUserContainerResponse.Success ? request.Amount : 0);
				multiUserContainerResponse.Failure = ((!multiUserContainerResponse.Success) ? MultiUserContainerFailure.DestinationChanged : MultiUserContainerFailure.None);
				break;
			default:
				multiUserContainerResponse.Failure = MultiUserContainerFailure.InvalidRequest;
				break;
			}
			if (multiUserContainerResponse.Success && !TryPersistMultiUserContainerInventory(container))
			{
				outcomeUncertain = !RestoreMultiUserContainerInventory(container, inventory, rollbackItems);
				multiUserContainerResponse.Success = false;
				multiUserContainerResponse.Amount = 0;
				multiUserContainerResponse.Item = null;
				multiUserContainerResponse.Failure = MultiUserContainerFailure.OwnerChanged;
			}
			return multiUserContainerResponse;
		}

		private static bool TryCaptureMultiUserContainerInventory(Inventory inventory, out List<ItemData>? items)
		{
			items = null;
			try
			{
				items = inventory.m_inventory.ConvertAll((ItemData item) => item.Clone());
				return true;
			}
			catch
			{
				items = null;
				return false;
			}
		}

		private static bool RestoreMultiUserContainerInventory(Container container, Inventory inventory, List<ItemData> items)
		{
			try
			{
				inventory.m_inventory.Clear();
				inventory.m_inventory.AddRange(items);
				NotifyMultiUserContainerInventoryChanged(inventory);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest rollback callback failed: " + ex.Message));
			}
			return TryPersistMultiUserContainerInventory(container);
		}

		private static bool TryPersistMultiUserContainerInventory(Container container)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid() || !container.m_nview.IsOwner())
			{
				return false;
			}
			try
			{
				container.Save();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest save callback failed: " + ex.Message));
			}
			try
			{
				ZPackage val = new ZPackage();
				container.GetInventory().Save(val);
				ZDO zDO = container.m_nview.GetZDO();
				return zDO != null && string.Equals(zDO.GetString(ZDOVars.s_items, ""), val.GetBase64(), StringComparison.Ordinal);
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Built-in multi-user chest save verification failed: " + ex2.Message));
				return false;
			}
		}

		private static bool IsValidMultiUserContainerRequest(Inventory inventory, MultiUserContainerRequest request)
		{
			//IL_0156: 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_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: 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)
			if (request.RequestId <= 0 || !Enum.IsDefined(typeof(MultiUserContainerOperation), request.Operation) || request.Item?.m_shared == null || request.Amount <= 0 || request.Amount > request.Item.m_stack || request.Amount > Math.Max(1, request.Item.m_shared.m_maxStackSize))
			{
				return false;
			}
			bool flag = request.Operation != MultiUserContainerOperation.Add;
			bool flag2;
			switch (request.Operation)
			{
			case MultiUserContainerOperation.Add:
			case MultiUserContainerOperation.Move:
			case MultiUserContainerOperation.Swap:
				flag2 = true;
				break;
			default:
				flag2 = false;
				break;
			}
			bool flag3 = flag2;
			MultiUserContainerOperation operation = request.Operation;
			flag2 = ((operation == MultiUserContainerOperation.Remove || operation - 4 <= MultiUserContainerOperation.Add) ? true : false);
			bool flag4 = (flag2 ? (request.ExpectedTargetStack == -1) : (request.ExpectedTargetStack >= 0 && request.ExpectedTargetStack <= request.Item.m_shared.m_maxStackSize));
			operation = request.Operation;
			flag2 = operation - 4 <= MultiUserContainerOperation.Add;
			bool flag5 = ((!flag2) ? (request.CounterpartItem == null) : (IsValidMultiUserContainerMutationItem(request.CounterpartItem) && !request.CounterpartItem.m_equipped && request.CounterpartItem.m_gridPos == request.TargetPosition && request.Amount == request.Item.m_stack && request.TargetPosition.x >= 0 && request.TargetPosition.y >= 0 && (request.Operation != MultiUserContainerOperation.Swap || request.SourcePosition != request.TargetPosition) && !request.Item.m_shared.m_questItem && !request.CounterpartItem.m_shared.m_questItem));
			return (!flag || IsMultiUserContainerPositionInBounds(inventory, request.SourcePosition)) && (!flag3 || IsMultiUserContainerPositionInBounds(inventory, request.TargetPosition)) && flag4 && flag5;
		}

		private static bool IsMultiUserContainerPositionInBounds(Inventory inventory, Vector2i position)
		{
			//IL_0003: 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_0015: 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)
			if (inventory != null && position.x >= 0 && position.y >= 0 && position.x < inventory.GetWidth())
			{
				return position.y < inventory.GetHeight();
			}
			return false;
		}

		private static MultiUserContainerResponse CreateMultiUserContainerResponse(MultiUserContainerRequest request)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			return new MultiUserContainerResponse
			{
				RequestId = request.RequestId,
				Operation = request.Operation,
				Success = false,
				Failure = MultiUserContainerFailure.InvalidRequest,
				Amount = 0,
				SourcePosition = request.SourcePosition,
				TargetPosition = request.TargetPosition
			};
		}

		private static MultiUserContainerOwnerState GetMultiUserContainerOwnerState(Container container)
		{
			if (!MultiUserContainerOwnerStates.TryGetValue(container, out MultiUserContainerOwnerState value))
			{
				value = new MultiUserContainerOwnerState();
				MultiUserContainerOwnerStates.Add(container, value);
			}
			return value;
		}

		private static void CacheMultiUserContainerOwnerResponse(MultiUserContainerOwnerState ownerState, MultiUserContainerOwnerRequestKey key, byte[] requestDigest, byte[] responseBytes)
		{
			if (ownerState != null && requestDigest != null && responseBytes != null && responseBytes.Length != 0 && responseBytes.Length <= 49152)
			{
				if (ownerState.Responses.TryGetValue(key, out MultiUserContainerOwnerResponse value))
				{
					ownerState.TotalResponseBytes = Math.Max(0, ownerState.TotalResponseBytes - value.ResponseBytes.Length);
					ownerState.Responses.Remove(key);
				}
				if (ownerState.Responses.Count + ownerState.UncertainRequests.Count < 128 && ownerState.TotalResponseBytes <= 33554432 - responseBytes.Length)
				{
					ownerState.Responses[key] = new MultiUserContainerOwnerResponse
					{
						CreatedAt = Time.unscaledTime,
						RequestDigest = requestDigest,
						ResponseBytes = responseBytes
					};
					ownerState.TotalResponseBytes += responseBytes.Length;
				}
			}
		}

		private static void QuarantineMultiUserContainerOwnerRequest(MultiUserContainerOwnerState ownerState, MultiUserContainerOwnerRequestKey key, byte[] requestDigest)
		{
			if (ownerState != null && requestDigest != null && requestDigest.Length == 32 && !ownerState.UncertainRequests.ContainsKey(key) && ownerState.Responses.Count + ownerState.UncertainRequests.Count < 128)
			{
				ownerState.UncertainRequests[key] = new MultiUserContainerUncertainRequest
				{
					RequestDigest = (byte[])requestDigest.Clone()
				};
			}
		}

		private static bool CanPersistMultiUserContainerDurableReceipt(Container container, long sender, MultiUserContainerRequest request, byte[] requestDigest)
		{
			MultiUserContainerResponse multiUserContainerResponse = CreateMultiUserContainerResponse(request);
			multiUserContainerResponse.Success = true;
			multiUserContainerResponse.Failure = MultiUserContainerFailure.None;
			multiUserContainerResponse.Amount = request.Amount;
			MultiUserContainerOperation operation = request.Operation;
			if ((operation == MultiUserContainerOperation.Remove || operation == MultiUserContainerOperation.Exchange) ? true : false)
			{
				ItemData itemAt = container.GetInventory().GetItemAt(request.SourcePosition.x, request.SourcePosition.y);
				if (itemAt == null || !MultiUserContainerTransferCore.MatchesExpectedStackState(request.Item.m_stack, itemAt.m_stack) || !IsExactMultiUserContainerItemMatch(request.Item, itemAt, request.Amount))
				{
					multiUserContainerResponse.Success = false;
					multiUserContainerResponse.Failure = MultiUserContainerFailure.ItemChanged;
					multiUserContainerResponse.Amount = 0;
				}
				else
				{
					try
					{
						multiUserContainerResponse.Item = itemAt.Clone();
						multiUserContainerResponse.Item.m_stack = request.Amount;
						multiUserContainerResponse.Item.m_equipped = false;
					}
					catch
					{
						return false;
					}
				}
			}
			if (!TryWriteMultiUserContainerResponse(multiUserContainerResponse, out ZPackage package))
			{
				return false;
			}
			byte[] array = package.GetArray();
			byte[] receiptBytes;
			if (array.Length <= 49152 && TryReadMultiUserContainerDurableReceipts(container, out List<MultiUserContainerDurableReceipt> receipts))
			{
				return TryUpsertMultiUserContainerDurableReceipt(receipts, new MultiUserContainerDurableReceipt
				{
					Acknowledged = false,
					RequesterPlayerId = request.RequesterPlayerId,
					Sender = sender,
					RequestId = request.RequestId,
					CreatedUtcTicks = DateTime.UtcNow.Ticks,
					RequestDigest = requestDigest,
					ResponseBytes = array
				}, out receiptBytes);
			}
			return false;
		}

		private static bool TryReadMultiUserContainerDurableReceipt(Container container, long requesterPlayerId, int requestId, out MultiUserContainerDurableReceipt? receipt)
		{
			receipt = null;
			ZDO val = (((Object)(object)container != (Object)null && !IsUnityNull((Object?)(object)container) && (Object)(object)container.m_nview != (Object)null && !IsUnityNull((Object?)(object)container.m_nview)) ? container.m_nview.GetZDO() : null);
			if (val != null)
			{
				return TryReadMultiUserContainerDurableReceipt(val, requesterPlayerId, requestId, out receipt);
			}
			return false;
		}

		private static bool TryReadMultiUserContainerDurableReceipt(ZDO zdo, long requesterPlayerId, int requestId, out MultiUserContainerDurableReceipt? receipt)
		{
			receipt = null;
			if (requesterPlayerId == 0L || requestId <= 0 || !TryReadMultiUserContainerDurableReceipts(zdo, out List<MultiUserContainerDurableReceipt> receipts))
			{
				return false;
			}
			receipt = receipts.Find((MultiUserContainerDurableReceipt candidate) => candidate.RequesterPlayerId == requesterPlayerId && candidate.RequestId == requestId);
			return receipt != null;
		}

		private static bool TryWriteMultiUserContainerDurableReceipt(Container container, long sender, long requesterPlayerId, int requestId, byte[] requestDigest, byte[] responseBytes, out bool outcomeUncertain)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			outcomeUncertain = false;
			if (sender == 0L || requesterPlayerId == 0L || requestId <= 0 || requestDigest == null || responseBytes == null || responseBytes.Length == 0 || responseBytes.Length > 49152 || !TryReadMultiUserContainerDurableReceipts(container, out List<MultiUserContainerDurableReceipt> receipts) || !TryUpsertMultiUserContainerDurableReceipt(receipts, new MultiUserContainerDurableReceipt
			{
				Acknowledged = false,
				RequesterPlayerId = requesterPlayerId,
				Sender = sender,
				RequestId = requestId,
				CreatedUtcTicks = DateTime.UtcNow.Ticks,
				RequestDigest = requestDigest,
				ResponseBytes = responseBytes
			}, out byte[] receiptBytes))
			{
				return false;
			}
			ZNetView nview = container.m_nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			try
			{
				val.Set("sighsorry.InventorySlots.MUC.Receipts.v3", receiptBytes);
				if (!AreMultiUserContainerDigestsEqual(val.GetByteArray("sighsorry.InventorySlots.MUC.Receipts.v3", (byte[])null) ?? Array.Empty<byte>(), receiptBytes))
				{
					outcomeUncertain = true;
					return false;
				}
			}
			catch (Exception ex)
			{
				outcomeUncertain = true;
				Log.LogWarning((object)("Built-in multi-user chest receipt save failed: " + ex.Message));
				return false;
			}
			try
			{
				ZDOMan instance = ZDOMan.instance;
				if (instance != null)
				{
					instance.ForceSendZDO(sender, val.m_uid);
				}
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Built-in multi-user chest receipt force-send failed: " + ex2.Message));
			}
			return true;
		}

		private static bool AcknowledgeMultiUserContainerDurableReceipt(Container container, long requesterPlayerId, int requestId, long sender)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (requesterPlayerId == 0L || requestId <= 0 || !TryReadMultiUserContainerDurableReceipts(container, out List<MultiUserContainerDurableReceipt> receipts))
			{
				return false;
			}
			MultiUserContainerDurableReceipt multiUserContainerDurableReceipt = receipts.Find((MultiUserContainerDurableReceipt candidate) => candidate.RequesterPlayerId == requesterPlayerId && candidate.RequestId == requestId);
			if (multiUserContainerDurableReceipt == null)
			{
				return false;
			}
			multiUserContainerDurableReceipt.Acknowledged = true;
			multiUserContainerDurableReceipt.CreatedUtcTicks = DateTime.UtcNow.Ticks;
			multiUserContainerDurableReceipt.ResponseBytes = Array.Empty<byte>();
			if (!TrySerializeMultiUserContainerDurableReceipts(receipts, out byte[] receiptBytes))
			{
				return false;
			}
			ZNetView nview = container.m_nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			try
			{
				val.Set("sighsorry.InventorySlots.MUC.Receipts.v3", receiptBytes);
				if (!AreMultiUserContainerDigestsEqual(val.GetByteArray("sighsorry.InventorySlots.MUC.Receipts.v3", (byte[])null) ?? Array.Empty<byte>(), receiptBytes))
				{
					return false;
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Built-in multi-user chest receipt cleanup failed: " + ex.Message));
				return false;
			}
			try
			{
				ZDOMan instance = ZDOMan.instance;
				if (instance != null)
				{
					instance.ForceSendZDO(sender, val.m_uid);
				}
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Built-in multi-user chest receipt cleanup force-send failed: " + ex2.Message));
			}
			return true;
		}

		private static bool TryReadMultiUserContainerDurableReceipts(Container container, out List<MultiUserContainerDurableReceipt>? receipts)
		{
			ZDO val = (((Object)(object)container != (Object)null && !IsUnityNull((Object?)(object)container) && (Object)(object)container.m_nview != (Object)null && !IsUnityNull((Object?)(object)container.m_nview)) ? container.m_nview.GetZDO() : null);
			if (val == null)
			{
				receipts = null;
				return false;
			}
			return TryReadMultiUserContainerDurableReceipts(val, out receipts);
		}

		private static bool TryReadMultiUserContainerDurableReceipts(ZDO zdo, out List<MultiUserContainerDurableReceipt>? receipts)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			receipts = new List<MultiUserContainerDurableReceipt>();
			if (zdo == null)
			{
				receipts = null;
				return false;
			}
			byte[] byteArray = zdo.GetByteArray("sighsorry.InventorySlots.MUC.Receipts.v3", (byte[])null);
			if (byteArray == null || byteArray.Length == 0)
			{
				return true;
			}
			if (byteArray.Length > 65536)
			{
				receipts = null;
				return false;
			}
			try
			{
				ZPackage val = new ZPackage(byteArray);
				if (val.ReadByte() != 3)
				{
					receipts = null;
					return false;
				}
				int num = val.ReadInt();
				if (num < 0 || num > 128)
				{
					receipts = null;
					return false;
				}
				HashSet<(long, int)> hashSet = new HashSet<(long, int)>();
				for (int i = 0; i < num; i++)
				{
					MultiUserContainerDurableReceipt multiUserContainerDurableReceipt = new MultiUserContainerDurableReceipt
					{
						Acknowledged = val.ReadBool(),
						RequesterPlayerId = val.ReadLong(),
						Sender = val.ReadLong(),
						RequestId = val.ReadInt(),
						CreatedUtcTicks = val.ReadLong()
					};
					if (!TryReadBoundedMultiUserContainerByteArray(val, 32, out byte[] bytes) || !TryReadBoundedMultiUserContainerByteArray(val, 49152, out byte[] bytes2))
					{
						receipts = null;
						return false;
					}
					multiUserContainerDurableReceipt.RequestDigest = bytes;
					multiUserContainerDurableReceipt.ResponseBytes = bytes2;
					if (multiUserContainerDurableReceipt.RequesterPlayerId == 0L || multiUserContainerDurableReceipt.Sender == 0L || multiUserContainerDurableReceipt.RequestId <= 0 || multiUserContainerDurableReceipt.RequestDigest.Length != 32 || multiUserContainerDurableReceipt.ResponseBytes.Length > 49152 || (multiUserContainerDurableReceipt.Acknowledged && multiUserContainerDurableReceipt.ResponseBytes.Length != 0) || (!multiUserContainerDurableReceipt.Acknowledged && multiUserContainerDurableReceipt.ResponseBytes.Length == 0) || !hashSet.Add((multiUserContainerDurableReceipt.RequesterPlayerId, multiUserContainerDurableReceipt.RequestId)))
					{
						receipts = null;
						return false;
					}
					long num2 = DateTime.UtcNow.Ticks - 300000000;
					if ((!multiUserContainerDurableReceipt.Acknowledged || multiUserContainerDurableReceipt.CreatedUtcTicks >= num2) && multiUserContainerDurableReceipt.CreatedUtcTicks > 0)
					{
						receipts.Add(multiUserContainerDurableReceipt);
					}
				}
				if (val.GetPos() != val.Size())
				{
					receipts = null;
					return false;
				}
				return true;
			}
			catch
			{
				receipts = null;
				return false;
			}
		}

		private static bool TryUpsertMultiUserContainerDurableReceipt(List<MultiUserContainerDurableReceipt> receipts, MultiUserContainerDurableReceipt receipt, out byte[]? receiptBytes)
		{
			receiptBytes = null;
			receipts.RemoveAll((MultiUserContainerDurableReceipt current) => current.RequesterPlayerId == receipt.RequesterPlayerId && current.RequestId == receipt.RequestId);
			if (receipts.Count >= 128)
			{
				return false;
			}
			receipts.Add(receipt);
			if (!TrySerializeMultiUserContainerDurableReceipts(receipts, out byte[] receiptBytes2))
			{
				return false;
			}
			receiptBytes = receiptBytes2;
			return true;
		}

		private static bool TrySerializeMultiUserContainerDurableReceipts(List<MultiUserContainerDurableReceipt> receipts, out byte[] receiptBytes)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			receiptBytes = Array.Empty<byte>();
			if (receipts.Count <= 0 || receipts.Count > 128)
			{
				return false;
			}
			try
			{
				ZPackage val = new ZPackage();
				val.Write((byte)3);
				val.Write(receipts.Count);
				foreach (MultiUserContainerDurableReceipt receipt in receipts)
				{
					val.Write(receipt.Acknowledged);
					val.Write(receipt.RequesterPlayerId);
					val.Write(receipt.Sender);
					val.Write(receipt.RequestId);
					val.Write(receipt.CreatedUtcTicks);
					val.Write(receipt.RequestDigest);
					val.Write(receipt.ResponseBytes);
				}
				if (val.Size() > 65536)
				{
					return false;
				}
				receiptBytes = val.GetArray();
				return true;
			}
			catch
			{
				receiptBytes = Array.Empty<byte>();
				return false;
			}
		}

		private static bool TryReadMultiUserContainerAcknowledge(ZPackage package, out int requestId, out long requesterPlayerId, out byte[]? requestDigest)
		{
			requestId = 0;
			requesterPlayerId = 0L;
			requestDigest = null;
			try
			{
				package.SetPos(0);
				if (package.ReadByte() != 3)
				{
					return false;
				}
				requestId = package.ReadInt();
				requesterPlayerId = package.ReadLong();
				if (!TryReadBoundedMultiUserContainerByteArray(package, 32, out byte[] bytes))
				{
					return false;
				}
				requestDigest = bytes;
				return requestId > 0 && requesterPlayerId != 0L && requestDigest.Length == 32 && package.GetPos() == package.Size();
			}
			catch
			{
				requestId = 0;
				requesterPlayerId = 0L;
				requestDigest = null;
				return false;
			}
		}

		private static bool TryReadBoundedMultiUserContainerByteArray(ZPackage package, int maximumBytes, out byte[] bytes)
		{
			bytes = Array.Empty<byte>();
			if (package == null || maximumBytes < 0 || package.Size() - package.GetPos() < 4)
			{
				return false;
			}
			int num = package.ReadInt();
			int num2 = package.Size() - package.GetPos();
			if (num < 0 || num > maximumBytes || num > num2)
			{
				return false;
			}
			bytes = package.ReadByteArray(num);
			return bytes.Length == num;
		}

		private static void PruneMultiUserContainerOwnerResponseCaches()
		{
			float num = Time.unscaledTime - 30f;
			List<Container> list = new List<Container>();
			foreach (KeyValuePair<Container, MultiUserContainerOwnerState> multiUserContainerOwnerState in MultiUserContainerOwnerStates)
			{
				Container key = multiUserContainerOwnerState.Key;
				if ((Object)(object)key == (Object)null || IsUnityNull((Object?)(object)key))
				{
					list.Add(key);
					continue;
				}
				List<MultiUserContainerOwnerRequestKey> list2 = new List<MultiUserContainerOwnerRequestKey>();
				foreach (KeyValuePair<MultiUserContainerOwnerRequestKey, MultiUserContainerOwnerResponse> response in multiUserContainerOwnerState.Value.Responses)
				{
					if (response.Value.CreatedAt < num)
					{
						list2.Add(response.Key);
					}
				}
				foreach (MultiUserContainerOwnerRequestKey item in list2)
				{
					if (multiUserContainerOwnerState.Value.Responses.TryGetValue(item, out MultiUserContainerOwnerResponse value))
					{
						multiUserContainerOwnerState.Value.TotalResponseBytes = Math.Max(0, multiUserContainerOwnerState.Value.TotalResponseBytes - value.ResponseBytes.Length);
					}
					multiUserContainerOwnerState.Value.Responses.Remove(item);
				}
			}
			foreach (Container item2 in list)
			{
				MultiUserContainerOwnerStates.Remove(item2);
			}
		}

		private static void SendMultiUserContainerResponse(Container container, long target, MultiUserContainerResponse response)
		{
			if (target != 0L && !((Object)(object)container == (Object)null) && !IsUnityNull((Object?)(object)container) && !((Object)(object)container.m_nview == (Object)null) && container.m_nview.IsValid() && TryWriteMultiUserContainerResponse(response, out ZPackage package))
			{
				container.m_nview.InvokeRPC(target, "InventorySlots_MUC_Response_v3", new object[1] { package });
			}
		}

		private static void SendMultiUserContainerResponse(Container container, long target, byte[] responseBytes)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			if (target != 0L && responseBytes != null && responseBytes.Length != 0 && responseBytes.Length <= 49152 && !((Object)(object)container == (Object)null) && !IsUnityNull((Object?)(object)container) && !((Object)(object)container.m_nview == (Object)null) && container.m_nview.IsValid())
			{
				container.m_nview.InvokeRPC(target, "InventorySlots_MUC_Response_v3", new object[1] { (object)new ZPackage(responseBytes) });
			}
		}

		internal static void AcknowledgeMultiUserContainerResponse(Container container, int requestId, long requesterPlayerId, byte[] requestDigest)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			if (!((Object)(object)container == (Object)null) && !IsUnityNull((Object?)(object)container) && !((Object)(object)container.m_nview == (Object)null) && container.m_nview.IsValid() && requestId > 0 && requesterPlayerId != 0L && requestDigest != null && requestDigest.Length == 32)
			{
				ZPackage val = new ZPackage();
				val.Write((byte)3);
				val.Write(requestId);
				val.Write(requesterPlayerId);
				val.Write(requestDigest);
				container.m_nview.InvokeRPC("InventorySlots_MUC_Ack_v3", new object[1] { val });
			}
		}

		internal static bool TryResolvePendingMultiUserContainerDurableReceipt(Container container)
		{
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if ((Object)(object)container == (Object)null || IsUnityNull((Object?)(object)container) || pendingMultiUserContainerTransfer == null || pendingMultiUserContainerTransfer.ResponseApplied || pendingMultiUserContainerTransfer.TerminalFailureReceived || (Object)(object)pendingMultiUserContainerTransfer.Container != (Object)(object)container || (Object)(object)container.m_nview == (Object)null || IsUnityNull((Object?)(object)container.m_nview))
			{
				return false;
			}
			ZNetView nview = container.m_nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val != null)
			{
				return TryResolvePendingMultiUserContainerDurableReceipt(pendingMultiUserContainerTransfer, container, val);
			}
			return false;
		}

		internal static bool TryResolvePendingMultiUserContainerDurableReceipt(ZDO zdo)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			PendingMultiUserContainerTransfer pendingMultiUserContainerTransfer = _pendingMultiUserContainerTransfer;
			if (zdo == null || pendingMultiUserContainerTransfer == null || pendingMultiUserContainerTransfer.ResponseApplied || pendingMultiUserContainerTransfer.TerminalFailureReceived || !((ZDOID)(ref zdo.m_uid)).Equals(pendingMultiUserContainerTransfer.ContainerId))
			{
				return false;
			}
			Container val = pendingMultiUserContainerTransfer.Container;
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)val.m_nview == (Object)null || IsUnityNull((Object?)(object)val.m_nview) || val.m_nview.GetZDO() != zdo)
			{
				val = null;
			}
			return TryResolvePendingMultiUserContainerDurableReceipt(pendingMultiUserContainerTransfer, val, zdo);
		}

		private static bool TryResolvePendingMultiUserContainerDurableReceipt(PendingMultiUserContainerTransfer pending, Container? container, ZDO zdo)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			ObservePendingMultiUserContainerOwner(pending, zdo.GetOwner());
			if (!TryReadMultiUserContainerDurableReceipt(zdo, pending.Request.RequesterPlayerId, pending.Request.RequestId, out MultiUserContainerDurableReceipt receipt) || receipt == null || receipt.Acknowledged || receipt.Sender != pending.RequesterPeerId || receipt.RequestId != pending.Request.RequestId || !AreMultiUserContainerDigestsEqual(receipt.RequestDigest, pending.RequestDigest))
			{
				return false;
			}
			if (!TryReadMultiUserContainerResponse(new ZPackage(receipt.ResponseBytes), out MultiUserContainerResponse response) || response == null)
			{
				return false;
			}
			long num = pending.Owner;
			if (!pending.RequestOwners.Contains(num))
			{
				using HashSet<long>.Enumerator enumerator = pending.RequestOwners.GetEnumerator();
				if (enumerator.MoveNext())
				{
					num = enumerator.Current;
				}
			}
			HandleMultiUserContainerResponse(container, num, response, fromDurableReceipt: true, zdo);
			if (!pending.ResponseApplied)
			{
				return _pendingMultiUserContainerTransfer != pending;
			}
			return true;
		}

		private static bool TryWriteMultiUserContainerRequest(MultiUserContainerRequest request, out ZPackage? package)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0043: 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)
			package = null;
			if (request == null || request.Item == null)
			{
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write((byte)3);
			val.Write(request.RequestId);
			val.Write((byte)request.Operation);
			val.Write(request.RequesterPlayerId);
			val.Write(request.SourcePosition);
			val.Write(request.TargetPosition);
			val.Write(request.ExpectedTargetStack);
			val.Write(request.Amount);
			if (!TryWriteMultiUserContainerItem(val, request.Item) || !TryWriteMultiUserContainerItem(val, request.CounterpartItem) || val.Size() > 98304)
			{
				return false;
			}
			package = val;
			return true;
		}

		private static bool TryReadMultiUserContainerRequestHeader(ZPackage package, out MultiUserContainerRequest? request)
		{
			//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_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)
			request = null;
			try
			{
				package.SetPos(0);
				if (package.ReadByte() != 3)
				{
					return false;
				}
				MultiUserContainerRequest multiUserContainerRequest = new MultiUserContainerRequest
				{
					RequestId = package.ReadInt(),
					Operation = (MultiUserContainerOperation)package.ReadByte(),
					RequesterPlayerId = package.ReadLong(),
					SourcePosition = package.ReadVector2i(),
					TargetPosition = package.ReadVector2i(),
					ExpectedTargetStack = package.ReadInt(),
					Amount = package.ReadInt()
				};
				request = multiUserContainerRequest;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryReadMultiUserContainerRequestItem(ZPackage package, MultiUserContainerRequest request)
		{
			try
			{
				if (!TryReadMultiUserContainerItem(package, out ItemData item) || item == null || !TryReadMultiUserContainerItem(package, out ItemData item2) || package.GetPos() != package.Size())
				{
					return false;
				}
				item.m_equipped = false;
				request.Item = item;
				if (item2 != null)
				{
					item2.m_equipped = false;
				}
				request.CounterpartItem = item2;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryWriteMultiUserContainerResponse(MultiUserContainerResponse response, out ZPackage? package)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			package = null;
			if (response == null)
			{
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write((byte)3);
			val.Write(response.RequestId);
			val.Write((byte)response.Operation);
			val.Write(response.Success);
			val.Write((byte)response.Failure);
			val.Write(response.Amount);
			val.Write(response.SourcePosition);
			val.Write(response.TargetPosition);
			if (!TryWriteMultiUserContainerItem(val, response.Item) || val.Size() > 49152)
			{
				return false;
			}
			package = val;
			return true;
		}

		private static bool TryReadMultiUserContainerResponse(ZPackage package, out MultiUserContainerResponse? response)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			response = null;
			try
			{
				package.SetPos(0);
				if (package.ReadByte() != 3)
				{
					return false;
				}
				MultiUserContainerResponse multiUserContainerResponse = new MultiUserContainerResponse
				{
					RequestId = package.ReadInt(),
					Operation = (MultiUserContainerOperation)package.ReadByte(),
					Success = package.ReadBool(),
					Failure = (MultiUserContainerFailure)package.ReadByte(),
					Amount = package.ReadInt(),
					SourcePosition = package.ReadVector2i(),
					TargetPosition = package.ReadVector2i()
				};
				if (!TryReadMultiUserContainerItem(package, out ItemData item) || package.GetPos() != package.Size() || multiUserContainerResponse.RequestId <= 0 || !Enum.IsDefined(typeof(MultiUserContainerOperation), multiUserContainerResponse.Operation) || !Enum.IsDefined(typeof(MultiUserContainerFailure), multiUserContainerResponse.Failure) || multiUserContainerResponse.Amount < 0)
				{
					return false;
				}
				if (item != null)
				{
					item.m_equipped = false;
				}
				multiUserContainerResponse.Item = item;
				response = multiUserContainerResponse;
				return true;
			}
			catch (Exception ex) when (ex is ArgumentException || ex is InvalidOperationException || ex is EndOfStreamException || ex is IOException)
			{
				return false;
			}
		}

		private static void ApplyMyLittleUICraftingCompatibility()
		{
			if (_myLittleUICraftingCompatibilityApplied || !IsMyLittleUIActive())
			{
				return;
			}
			int num = 0;
			MethodBase[] array = Harmony.GetAllPatchedMethods().ToArray();
			foreach (MethodBase methodBase in array)
			{
				Patches patchInfo = Harmony.GetPatchInfo(methodBase);
				if (patchInfo != null)
				{
					num += UnpatchMyLittleUIConflictingPatches(methodBase, patchInfo.Prefixes);
					num += UnpatchMyLittleUIConflictingPatches(methodBase, patchInfo.Postfixes);
					num += UnpatchMyLittleUIConflictingPatches(methodBase, patchInfo.Transpilers);
					num += UnpatchMyLittleUIConflictingPatches(methodBase, patchInfo.Finalizers);
				}
			}
			_myLittleUICraftingCompatibilityApplied = true;
			if (num > 0)
			{
				Log.LogInfo((object)$"Disabled {num} MyLittleUI conflicting UI patch(es) for InventorySlots compatibility.");
			}
		}

		private static int UnpatchMyLittleUIConflictingPatches(MethodBase original, IEnumerable<Patch> patches)
		{
			int num = 0;
			Patch[] array = patches.ToArray();
			foreach (Patch val in array)
			{
				if (string.Equals(val.owner, "shudnal.MyLittleUI", StringComparison.Ordinal) && IsMyLittleUIConflictingPatchMethod(val.PatchMethod))
				{
					try
					{
						_instance._harmony.Unpatch(original, val.PatchMethod);
						num++;
					}
					catch (Exception ex)
					{
						Log.LogWarning((object)("Failed to disable MyLittleUI compatibility patch " + GeneralExtensions.FullDescription((MethodBase)val.PatchMethod) + ": " + ex.Message));
					}
				}
			}
			return num;
		}

		private static bool IsMyLittleUIConflictingPatchMethod(MethodInfo method)
		{
			string value = method.DeclaringType?.FullName ?? "";
			return MyLittleUIConflictingPatchTypeNames.Contains<string>(value, StringComparer.Ordinal);
		}

		private static void UpdateMyLittleUICraftingObjectSuppression(InventoryGui? gui, bool shouldSuppress)
		{
			UpdateMyLittleUICraftingObjectSuppression(gui, shouldSuppress, GetCraftingTabAdapterState(gui));
		}

		private static void UpdateMyLittleUICraftingObjectSuppression(InventoryGui? gui, bool shouldSuppress, CraftingTabAdapterState adapter)
		{
			if (!shouldSuppress)
			{
				ResetMyLittleUICraftingObjectCache();
			}
			else
			{
				DisableMyLittleUICraftingObjects(gui, adapter);
			}
		}

		private static void DisableMyLittleUICraftingObjects(InventoryGui? gui, CraftingTabAdapterState adapter)
		{
			if (!IsMyLittleUIActive() || (Object)(object)gui == (Object)null || IsUnityNull((Object?)(object)gui) || !InventoryGui.IsVisible())
			{
				ResetMyLittleUICraftingObjectCache();
				return;
			}
			int myLittleUICraftingObjectRootSignature = GetMyLittleUICraftingObjectRootSignature(gui);
			string myLittleUICraftingSuppressionSignature = GetMyLittleUICraftingSuppressionSignature(gui, myLittleUICraftingObjectRootSignature, adapter);
			if (!_myLittleUIInventoryVisibleLastFrame || !string.Equals(_myLittleUICraftingSuppressionSignature, myLittleUICraftingSuppressionSignature, StringComparison.Ordinal) || myLittleUICraftingObjectRootSignature != _myLittleUICraftingObjectRootSignature || (Time.unscaledTime >= _nextMyLittleUICraftingObjectScanTime && !HasCachedMyLittleUICraftingObjects()))
			{
				CachedMyLittleUICraftingObjects.Clear();
				if ((Object)(object)gui.m_crafting != (Object)null)
				{
					CacheMyLittleUICraftingObjects((Transform)(object)gui.m_crafting);
				}
				_myLittleUICraftingObjectRootSignature = myLittleUICraftingObjectRootSignature;
				_myLittleUICraftingSuppressionSignature = myLittleUICraftingSuppressionSignature;
				_nextMyLittleUICraftingObjectScanTime = Time.unscaledTime + 0.5f;
			}
			DisableCachedMyLittleUICraftingObjects();
			_myLittleUIInventoryVisibleLastFrame = true;
			_myLittleUICraftingSuppressionActive = true;
		}

		private static bool HasCachedMyLittleUICraftingObjects()
		{
			int num = CachedMyLittleUICraftingObjects.Count - 1;
			while (num >= 0)
			{
				Transform val = CachedMyLittleUICraftingObjects[num];
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
				{
					CachedMyLittleUICraftingObjects.RemoveAt(num);
					num--;
					continue;
				}
				return true;
			}
			return false;
		}

		private static int GetMyLittleUICraftingObjectRootSignature(InventoryGui gui)
		{
			int hash = 17;
			AddRoot((Transform?)(object)gui.m_crafting);
			return hash;
			void AddRoot(Transform? root)
			{
				if ((Object)(object)root == (Object)null || IsUnityNull((Object?)(object)root))
				{
					hash = hash * 31 - 1;
				}
				else
				{
					hash = hash * 31 + ((Object)root).GetInstanceID();
					hash = hash * 31 + root.childCount;
					hash = hash * 31 + (((Component)root).gameObject.activeInHierarchy ? 1 : 0);
				}
			}
		}

		private static string GetMyLittleUICraftingSuppressionSignature(InventoryGui gui, int rootSignature, CraftingTabAdapterState adapter)
		{
			return $"{rootSignature}|{adapter.Kind}|applied={_craftingRedesignApplied}|craft={SafeReadBool(() => gui.InCraftTab())}|upgrade={SafeReadBool(() => gui.InUpradeTab())}";
		}

		private static void CacheMyLittleUICraftingObjects(Transform root)
		{
			MyLittleUICraftingObjectMarker[] componentsInChildren = ((Component)root).GetComponentsInChildren<MyLittleUICraftingObjectMarker>(true);
			foreach (MyLittleUICraftingObjectMarker myLittleUICraftingObjectMarker in componentsInChildren)
			{
				if ((Object)(object)myLittleUICraftingObjectMarker != (Object)null && !IsUnityNull((Object?)(object)myLittleUICraftingObjectMarker))
				{
					AddMyLittleUICraftingObject(((Component)myLittleUICraftingObjectMarker).transform);
				}
			}
			CacheMyLittleUICraftingObjectsRecursive(root);
		}

		private static void CacheMyLittleUICraftingObjectsRecursive(Transform root)
		{
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (IsMyLittleUICraftingObjectName(((Object)child).name))
				{
					AddMyLittleUICraftingObject(child);
				}
				CacheMyLittleUICraftingObjectsRecursive(child);
			}
		}

		private static void AddMyLittleUICraftingObject(Transform transform)
		{
			if (!((Object)(object)transform == (Object)null) && !IsUnityNull((Object?)(object)transform))
			{
				if (!CachedMyLittleUICraftingObjects.Contains(transform))
				{
					CachedMyLittleUICraftingObjects.Add(transform);
				}
				if ((Object)(object)((Component)transform).GetComponent<MyLittleUICraftingObjectMarker>() == (Object)null)
				{
					((Component)transform).gameObject.AddComponent<MyLittleUICraftingObjectMarker>();
				}
			}
		}

		private static void DisableCachedMyLittleUICraftingObjects()
		{
			for (int num = CachedMyLittleUICraftingObjects.Count - 1; num >= 0; num--)
			{
				Transform val = CachedMyLittleUICraftingObjects[num];
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
				{
					CachedMyLittleUICraftingObjects.RemoveAt(num);
				}
				else if (((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private static void ResetMyLittleUICraftingObjectCache()
		{
			if (_myLittleUICraftingSuppressionActive || CachedMyLittleUICraftingObjects.Count != 0 || _myLittleUICraftingObjectRootSignature != 0 || !string.IsNullOrEmpty(_myLittleUICraftingSuppressionSignature))
			{
				CachedMyLittleUICraftingObjects.Clear();
				_myLittleUICraftingObjectRootSignature = 0;
				_myLittleUICraftingSuppressionSignature = "";
				_nextMyLittleUICraftingObjectScanTime = 0f;
				_myLittleUIInventoryVisibleLastFrame = false;
				_myLittleUICraftingSuppressionActive = false;
			}
		}

		private static bool IsMyLittleUICraftingObjectName(string name)
		{
			if (!MyLittleUICraftingObjectNames.Contains<string>(name, StringComparer.Ordinal))
			{
				return MyLittleUICraftingObjectPrefixes.Any((string prefix) => name.StartsWith(prefix, StringComparison.Ordinal));
			}
			return true;
		}

		private static bool IsMyLittleUIActive()
		{
			if (!_myLittleUIPluginPresenceResolved)
			{
				_myLittleUIPluginDetected = HasPlugin("shudnal.MyLittleUI");
				_myLittleUIPluginPresenceResolved = true;
			}
			return _myLittleUIPluginDetected;
		}

		private static void ToggleCraftingRecipeTooltip(InventoryGui gui, int index)
		{
			if (!TryGetCraftingRecipePair(gui, index, out var _))
			{
				return;
			}
			PinnedTooltipContext currentCraftingPinnedTooltipContext = GetCurrentCraftingPinnedTooltipContext(gui);
			if (currentCraftingPinnedTooltipContext == PinnedTooltipContext.None)
			{
				return;
			}
			SetPinnedTooltipContext(currentCraftingPinnedTooltipContext);
			if (FindCraftingPinnedTooltipSlot(index) >= 0)
			{
				List<int> activeCraftingPinnedTooltipIndices = GetActiveCraftingPinnedTooltipIndices();
				activeCraftingPinnedTooltipIndices.RemoveAll((int activeIndex) => activeIndex == index);
				RebuildCraftingPinnedTooltips(gui, activeCraftingPinnedTooltipIndices);
				CraftingController.MarkRecipeGridLayoutDirty();
				return;
			}
			List<int> activeCraftingPinnedTooltipIndices2 = GetActiveCraftingPinnedTooltipIndices();
			int activePinnedTooltipSlotCount = GetActivePinnedTooltipSlotCount();
			if (activeCraftingPinnedTooltipIndices2.Count >= activePinnedTooltipSlotCount)
			{
				activeCraftingPinnedTooltipIndices2.Insert(0, index);
				activeCraftingPinnedTooltipIndices2.RemoveAt(activeCraftingPinnedTooltipIndices2.Count - 1);
			}
			else
			{
				activeCraftingPinnedTooltipIndices2.Add(index);
			}
			RebuildCraftingPinnedTooltips(gui, activeCraftingPinnedTooltipIndices2);
			CraftingController.MarkRecipeGridLayoutDirty();
		}

		private static int FindCraftingPinnedTooltipSlot(int index)
		{
			for (int i = 0; i < PinnedTooltips.Crafting.RecipeIndices.Length; i++)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf && PinnedTooltips.Crafting.RecipeIndices[i] == index)
				{
					return i;
				}
			}
			return -1;
		}

		private static List<int> GetActiveCraftingPinnedTooltipIndices()
		{
			List<int> list = new List<int>();
			int firstActiveCraftingPinnedTooltipSlot = GetFirstActiveCraftingPinnedTooltipSlot();
			for (int num = 2; num >= firstActiveCraftingPinnedTooltipSlot; num--)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[num];
				int num2 = PinnedTooltips.Crafting.RecipeIndices[num];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf && num2 >= 0)
				{
					list.Add(num2);
				}
			}
			return list;
		}

		private static void RebuildCraftingPinnedTooltips(InventoryGui gui, List<int> indices)
		{
			HideCraftingPinnedTooltips();
			int num = 2;
			int firstActiveCraftingPinnedTooltipSlot = GetFirstActiveCraftingPinnedTooltipSlot();
			foreach (int index in indices)
			{
				if (num < firstActiveCraftingPinnedTooltipSlot)
				{
					break;
				}
				PinCraftingRecipeTooltip(gui, index, num--);
			}
		}

		private static void PinCraftingRecipeTooltip(InventoryGui gui, int index, int slot)
		{
			//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_0060: 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_006b: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: 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_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			if (slot < 0 || slot >= PinnedTooltips.Crafting.Panels.Length || !TryGetCraftingRecipePair(gui, index, out var pair))
			{
				return;
			}
			PinnedTooltipContext currentCraftingPinnedTooltipContext = GetCurrentCraftingPinnedTooltipContext(gui);
			if (currentCraftingPinnedTooltipContext == PinnedTooltipContext.None)
			{
				return;
			}
			SetPinnedTooltipContext(currentCraftingPinnedTooltipContext);
			RectTransform val = EnsureCraftingPinnedTooltipPanel(gui, slot);
			HideInventoryPinnedTooltips();
			Transform parent = ((Transform)val).parent;
			object parent2 = ((object)((parent is RectTransform) ? parent : null)) ?? ((object)gui.m_crafting);
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize((RectTransform?)parent2);
			Vector2 pinnedTooltipPosition = GetPinnedTooltipPosition((RectTransform?)parent2, slot, pinnedTooltipPanelSize, CraftingPinnedTooltipFixedOffset);
			SetCenteredRect((RectTransform)parent2, val, pinnedTooltipPosition, pinnedTooltipPanelSize);
			ConfigurePinnedTooltipPanelBackground(val);
			((Transform)val).SetAsLastSibling();
			((Component)val).gameObject.SetActive(true);
			PinnedTooltips.Crafting.RecipeIndices[slot] = index;
			bool flag = IsVeiledRecipeMasked(pair);
			if ((Object)(object)PinnedTooltips.Crafting.Icons[slot] != (Object)null && (Object)(object)((RecipeDataPair)(ref pair)).Recipe != (Object)null && (Object)(object)((RecipeDataPair)(ref pair)).Recipe.m_item != (Object)null)
			{
				PinnedTooltips.Crafting.Icons[slot].sprite = GetCraftingRecipeIcon(pair);
				((Graphic)PinnedTooltips.Crafting.Icons[slot]).color = (flag ? Color.black : Color.white);
				((Component)PinnedTooltips.Crafting.Icons[slot]).gameObject.SetActive(true);
			}
			if ((Object)(object)PinnedTooltips.Crafting.Texts[slot] != (Object)null)
			{
				TMP_Text? obj = PinnedTooltips.Crafting.Texts[slot];
				ApplyDefaultFontAsset(obj);
				ApplyTooltipSourceFont(obj, "Text");
				((Behaviour)obj).enabled = true;
				((Component)obj).gameObject.SetActive(true);
				((Graphic)obj).color = Color.white;
				obj.overflowMode = (TextOverflowModes)0;
				obj.text = BuildCraftingPinnedTooltipText(pair);
			}
			bool num = !flag && UpdateCraftingJewelcraftingTooltip(val, pair, ref PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot]);
			bool flag2 = false;
			if (num)
			{
				HideCraftingGemIconRow(ref PinnedTooltips.Crafting.GemIconRows[slot]);
			}
			else if (flag)
			{
				if ((Object)(object)PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot]))
				{
					((Component)PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot]).gameObject.SetActive(false);
				}
				HideCraftingGemIconRow(ref PinnedTooltips.Crafting.GemIconRows[slot]);
			}
			else
			{
				flag2 = UpdateCraftingGemIconRow(val, pair, ref PinnedTooltips.Crafting.GemIconRows[slot], new Vector2(18f, 82f), 28f, 6f);
			}
			SetCraftingPinnedTooltipTextReservedSpace(val, flag2);
			ConfigureCraftingTooltipRecipeRow(val, pair, new Vector2(18f, 18f), 54f, 8f);
			if ((Object)(object)PinnedTooltips.Crafting.Texts[slot] != (Object)null)
			{
				float bottomReserved = (flag2 ? 124f : 92f);
				ApplyPinnedTooltipDynamicTextLayout(val, PinnedTooltips.Crafting.Texts[slot], slot, CraftingPinnedTooltipFixedOffset, 102f, bottomReserved, GetPinnedTooltipMaxTextViewportHeight(val, 102f, bottomReserved));
			}
			CraftingController.MarkRecipeGridLayoutDirty();
		}

		private static bool IsCraftingRecipeTooltipPinned(int index)
		{
			if (index < 0)
			{
				return false;
			}
			for (int i = 0; i < PinnedTooltips.Crafting.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf && PinnedTooltips.Crafting.RecipeIndices[i] == index)
				{
					return true;
				}
			}
			return false;
		}

		private static RectTransform EnsureCraftingPinnedTooltipPanel(InventoryGui gui, int slot)
		{
			RectTransform val = EnsurePinnedTooltipPanel(gui.m_crafting, "InventorySlots_CraftingPinnedTooltip_" + slot, PinnedTooltips.Crafting.Panels[slot]);
			PinnedTooltips.Crafting.Icons[slot] = EnsurePinnedTooltipIcon(val);
			PinnedTooltips.Crafting.Texts[slot] = EnsurePinnedTooltipBodyText(val, 16f);
			RectTransform?[] jewelcraftingTooltipRoots = PinnedTooltips.Crafting.JewelcraftingTooltipRoots;
			int num = slot;
			Transform obj = ((Transform)val).Find("InventorySlots_JewelcraftingTooltipRoot");
			jewelcraftingTooltipRoots[num] = ((obj != null) ? ((Component)obj).GetComponent<RectTransform>() : null);
			RectTransform?[] gemIconRows = PinnedTooltips.Crafting.GemIconRows;
			int num2 = slot;
			Transform obj2 = ((Transform)val).Find("InventorySlots_CraftingGemIconRow");
			gemIconRows[num2] = ((obj2 != null) ? ((Component)obj2).GetComponent<RectTransform>() : null);
			PinnedTooltips.Crafting.Panels[slot] = val;
			return val;
		}

		private static void HideCraftingPinnedTooltips()
		{
			for (int i = 0; i < PinnedTooltips.Crafting.Panels.Length; i++)
			{
				HideCraftingPinnedTooltip(i);
			}
		}

		private static void HideCraftingPinnedTooltip(int slot)
		{
			if (slot >= 0 && slot < PinnedTooltips.Crafting.Panels.Length)
			{
				if ((Object)(object)PinnedTooltips.Crafting.Panels[slot] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Crafting.Panels[slot]))
				{
					ResetPinnedTooltipTextScrollState(PinnedTooltips.Crafting.Panels[slot]);
					((Component)PinnedTooltips.Crafting.Panels[slot]).gameObject.SetActive(false);
				}
				if ((Object)(object)PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot]))
				{
					((Component)PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot]).gameObject.SetActive(false);
				}
				if ((Object)(object)PinnedTooltips.Crafting.GemIconRows[slot] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Crafting.GemIconRows[slot]))
				{
					((Component)PinnedTooltips.Crafting.GemIconRows[slot]).gameObject.SetActive(false);
				}
				PinnedTooltips.Crafting.RecipeIndices[slot] = -1;
				CraftingController.MarkRecipeGridLayoutDirty();
			}
		}

		private static string BuildCraftingPinnedTooltipText(RecipeDataPair pair)
		{
			//IL_0000: 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)
			string craftingRecipeDisplayName = GetCraftingRecipeDisplayName(pair);
			string craftingRecipeTooltip = GetCraftingRecipeTooltip(pair);
			return "<size=28><color=#FFD36A>" + craftingRecipeDisplayName + "</color></size>\n" + craftingRecipeTooltip;
		}

		private static bool IsInventoryPinnedTooltipSlotActive(int slot)
		{
			if (slot >= 0 && slot < PinnedTooltips.Inventory.Panels.Length && (Object)(object)PinnedTooltips.Inventory.Panels[slot] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Inventory.Panels[slot]))
			{
				return ((Component)PinnedTooltips.Inventory.Panels[slot]).gameObject.activeSelf;
			}
			return false;
		}

		private static void ToggleInventoryItemTooltip(InventoryGui gui, InventoryGrid grid, Vector2i pos, ItemData item)
		{
			//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_003d: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			if (item?.m_shared == null)
			{
				return;
			}
			SetPinnedTooltipContext(PinnedTooltipContext.InventoryContainer);
			if (FindInventoryPinnedTooltipSlot(grid, pos, item) >= 0)
			{
				List<InventoryPinnedTooltipTarget> activeInventoryPinnedTooltipTargets = GetActiveInventoryPinnedTooltipTargets();
				activeInventoryPinnedTooltipTargets.RemoveAll((InventoryPinnedTooltipTarget target) => IsSameInventoryPinnedTooltipTarget(target, grid, pos, item));
				RebuildInventoryPinnedTooltips(gui, activeInventoryPinnedTooltipTargets);
				return;
			}
			List<InventoryPinnedTooltipTarget> activeInventoryPinnedTooltipTargets2 = GetActiveInventoryPinnedTooltipTargets();
			int activePinnedTooltipSlotCount = GetActivePinnedTooltipSlotCount();
			if (activeInventoryPinnedTooltipTargets2.Count >= activePinnedTooltipSlotCount)
			{
				activeInventoryPinnedTooltipTargets2.Insert(0, new InventoryPinnedTooltipTarget(grid, pos, item));
				activeInventoryPinnedTooltipTargets2.RemoveAt(activeInventoryPinnedTooltipTargets2.Count - 1);
			}
			else
			{
				activeInventoryPinnedTooltipTargets2.Add(new InventoryPinnedTooltipTarget(grid, pos, item));
			}
			RebuildInventoryPinnedTooltips(gui, activeInventoryPinnedTooltipTargets2);
		}

		private static bool IsSameInventoryPinnedTooltipTarget(int slot, InventoryGrid grid, Vector2i pos, ItemData item)
		{
			//IL_0043: 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)
			if (slot < 0 || slot >= PinnedTooltips.Inventory.Panels.Length)
			{
				return false;
			}
			if ((Object)(object)PinnedTooltips.Inventory.Grids[slot] == (Object)(object)grid && PinnedTooltips.Inventory.Positions[slot] == pos)
			{
				if (PinnedTooltips.Inventory.Items[slot] != item)
				{
					return PinnedTooltips.Inventory.Items[slot]?.m_shared?.m_name == item.m_shared?.m_name;
				}
				return true;
			}
			return false;
		}

		private static bool IsSameInventoryPinnedTooltipTarget(InventoryPinnedTooltipTarget target, InventoryGrid grid, Vector2i pos, ItemData item)
		{
			//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)
			if ((Object)(object)target.Grid == (Object)(object)grid && target.Pos == pos)
			{
				if (target.Item != item)
				{
					return target.Item.m_shared?.m_name == item.m_shared?.m_name;
				}
				return true;
			}
			return false;
		}

		private static int FindInventoryPinnedTooltipSlot(InventoryGrid grid, Vector2i pos, ItemData item)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < GetActivePinnedTooltipSlotCount(); i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf && IsSameInventoryPinnedTooltipTarget(i, grid, pos, item))
				{
					return i;
				}
			}
			return -1;
		}

		private static List<InventoryPinnedTooltipTarget> GetActiveInventoryPinnedTooltipTargets()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			List<InventoryPinnedTooltipTarget> list = new List<InventoryPinnedTooltipTarget>();
			for (int i = 0; i < GetActivePinnedTooltipSlotCount(); i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				ItemData val2 = PinnedTooltips.Inventory.Items[i];
				InventoryGrid val3 = PinnedTooltips.Inventory.Grids[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf && (Object)(object)val3 != (Object)null && val2?.m_shared != null)
				{
					list.Add(new InventoryPinnedTooltipTarget(val3, PinnedTooltips.Inventory.Positions[i], val2));
				}
			}
			return list;
		}

		private static void RebuildInventoryPinnedTooltips(InventoryGui gui, List<InventoryPinnedTooltipTarget> targets)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			HideInventoryPinnedTooltips();
			int activePinnedTooltipSlotCount = GetActivePinnedTooltipSlotCount();
			for (int i = 0; i < targets.Count && i < activePinnedTooltipSlotCount; i++)
			{
				InventoryPinnedTooltipTarget inventoryPinnedTooltipTarget = targets[i];
				PinInventoryItemTooltip(gui, inventoryPinnedTooltipTarget.Grid, inventoryPinnedTooltipTarget.Pos, inventoryPinnedTooltipTarget.Item, i);
			}
			RefreshInventoryPinnedTooltipBorders();
		}

		private static void PinInventoryItemTooltip(InventoryGui gui, InventoryGrid grid, Vector2i pos, ItemData item, int slot)
		{
			//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_0065: 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_006b: 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_0072: 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_00c7: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: 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)
			if (!((Object)(object)gui == (Object)null) && item?.m_shared != null && slot >= 0 && slot < PinnedTooltips.Inventory.Panels.Length)
			{
				SetPinnedTooltipContext(PinnedTooltipContext.InventoryContainer);
				HideCraftingPinnedTooltips();
				RectTransform val = EnsureInventoryPinnedTooltipPanel(gui, slot);
				Transform parent = ((Transform)val).parent;
				object parent2 = ((object)((parent is RectTransform) ? parent : null)) ?? ((object)ResolveInventoryPinnedTooltipParent(gui));
				Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize((RectTransform?)parent2);
				Vector2 pinnedTooltipPosition = GetPinnedTooltipPosition((RectTransform?)parent2, slot, pinnedTooltipPanelSize, InventoryPinnedTooltipFixedOffset);
				SetCenteredRect((RectTransform)parent2, val, pinnedTooltipPosition, pinnedTooltipPanelSize);
				ConfigurePinnedTooltipPanelBackground(val);
				((Component)val).gameObject.SetActive(true);
				RaiseInventoryPinnedTooltips();
				PinnedTooltips.Inventory.Items[slot] = item;
				PinnedTooltips.Inventory.Grids[slot] = grid;
				PinnedTooltips.Inventory.Positions[slot] = pos;
				bool reserveJewelcraftingSpace = UpdateInventoryPinnedJewelcraftingTooltip(val, item, grid);
				SetInventoryPinnedTooltipTextReservedSpace(val, reserveJewelcraftingSpace);
				if ((Object)(object)PinnedTooltips.Inventory.Icons[slot] != (Object)null)
				{
					PinnedTooltips.Inventory.Icons[slot].sprite = item.GetIcon();
					((Graphic)PinnedTooltips.Inventory.Icons[slot]).color = Color.white;
					((Component)PinnedTooltips.Inventory.Icons[slot]).gameObject.SetActive(true);
				}
				if ((Object)(object)PinnedTooltips.Inventory.Texts[slot] != (Object)null)
				{
					TMP_Text val2 = PinnedTooltips.Inventory.Texts[slot];
					ApplyDefaultFontAsset(val2);
					ApplyTooltipSourceFont(val2, "Text");
					((Behaviour)val2).enabled = true;
					((Component)val2).gameObject.SetActive(true);
					((Graphic)val2).color = Color.white;
					val2.overflowMode = (TextOverflowModes)0;
					val2.text = BuildInventoryPinnedTooltipText(item);
					ApplyPinnedTooltipDynamicTextLayout(val, val2, slot, InventoryPinnedTooltipFixedOffset, 102f, 18f);
				}
			}
		}

		private static RectTransform EnsureInventoryPinnedTooltipPanel(InventoryGui gui, int slot)
		{
			RectTransform parent = ResolveInventoryPinnedTooltipParent(gui);
			string name = "InventorySlots_InventoryPinnedTooltip_" + slot;
			RectTransform val = EnsurePinnedTooltipPanel(parent, name, PinnedTooltips.Inventory.Panels[slot], delegate
			{
				if (!((Object)(object)gui.m_player != (Object)null) || IsUnityNull((Object?)(object)gui.m_player) || !((Object)(object)gui.m_player != (Object)(object)parent))
				{
					return (RectTransform?)null;
				}
				Transform obj = ((Transform)gui.m_player).Find(name);
				return (obj == null) ? null : ((Component)obj).GetComponent<RectTransform>();
			});
			PinnedTooltips.Inventory.Icons[slot] = EnsurePinnedTooltipIcon(val);
			PinnedTooltips.Inventory.Texts[slot] = EnsurePinnedTooltipBodyText(val, 16f);
			PinnedTooltips.Inventory.JewelcraftingTooltipRoots[slot] = FindJewelcraftingTooltipRoot(val);
			PinnedTooltips.Inventory.Panels[slot] = val;
			return val;
		}

		private static RectTransform ResolveInventoryPinnedTooltipParent(InventoryGui gui)
		{
			if ((Object)(object)gui != (Object)null && (Object)(object)gui.m_inventoryRoot != (Object)null && !IsUnityNull((Object?)(object)gui.m_inventoryRoot))
			{
				Transform inventoryRoot = gui.m_inventoryRoot;
				RectTransform val = (RectTransform)(((object)((inventoryRoot is RectTransform) ? inventoryRoot : null)) ?? ((object)((Component)gui.m_inventoryRoot).GetComponent<RectTransform>()));
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
				{
					return val;
				}
			}
			return gui.m_player;
		}

		private static void RaiseInventoryPinnedTooltips()
		{
			for (int i = 0; i < PinnedTooltips.Inventory.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeInHierarchy)
				{
					((Transform)val).SetAsLastSibling();
				}
			}
		}

		internal static void HideInventoryPinnedTooltips()
		{
			for (int i = 0; i < PinnedTooltips.Inventory.Panels.Length; i++)
			{
				HideInventoryPinnedTooltip(i);
			}
			RefreshInventoryPinnedTooltipBorders();
		}

		private static void HideInventoryPinnedTooltip(int slot)
		{
			//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)
			if (slot >= 0 && slot < PinnedTooltips.Inventory.Panels.Length)
			{
				if ((Object)(object)PinnedTooltips.Inventory.Panels[slot] != (Object)null && !IsUnityNull((Object?)(object)PinnedTooltips.Inventory.Panels[slot]))
				{
					ResetPinnedTooltipTextScrollState(PinnedTooltips.Inventory.Panels[slot]);
					((Component)PinnedTooltips.Inventory.Panels[slot]).gameObject.SetActive(false);
				}
				PinnedTooltips.Inventory.Items[slot] = null;
				PinnedTooltips.Inventory.Grids[slot] = null;
				PinnedTooltips.Inventory.Positions[slot] = new Vector2i(-1, -1);
			}
		}

		private static string BuildInventoryPinnedTooltipText(ItemData item)
		{
			string text = LocalizeUi(item.m_shared.m_name, item.m_shared.m_name);
			string text2 = ((Localization.instance != null) ? Localization.instance.Localize(item.GetTooltip(-1)) : item.GetTooltip(-1));
			return "<size=28><color=#FFD36A>" + text + "</color></size>\n" + text2;
		}

		private static string GetCraftingPinnedTooltipGridSignature()
		{
			string text = GetActivePinnedTooltipSlotCount().ToString();
			for (int i = 0; i < PinnedTooltips.Crafting.RecipeIndices.Length; i++)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				text = text + "|" + (((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf) ? PinnedTooltips.Crafting.RecipeIndices[i] : (-1));
			}
			return text;
		}

		private static Vector2 GetPinnedTooltipPosition(int slot, Vector2 size, Vector2 groupOffset)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return GetPinnedTooltipPosition(null, slot, size, groupOffset);
		}

		private static Vector2 GetPinnedTooltipPosition(RectTransform? parent, int slot, Vector2 size, Vector2 groupOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_00c1: 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_00b0: 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)
			float num = size.x + 15f;
			int num2 = Mathf.Clamp(slot, 0, 2);
			float num3 = 1f;
			float y = GetPinnedTooltipPanelSize().y;
			float num4 = groupOffset.x + ((float)num2 - num3) * num;
			float num5 = (y - size.y) * 0.5f + groupOffset.y;
			if ((Object)(object)parent != (Object)null && !IsUnityNull((Object?)(object)parent))
			{
				if (TryGetPinnedTooltipVerticalFrame(parent, out var frame))
				{
					num5 = frame.TopY - size.y * 0.5f;
				}
				if (TryGetPinnedTooltipStartLocalX(parent, out var x))
				{
					if (TooltipController.IsCraftingPinnedContext())
					{
						int num6 = 2 - num2;
						num4 = x - (float)num6 * num - size.x * 0.5f;
					}
					else
					{
						num4 = x + (float)num2 * num + size.x * 0.5f;
					}
				}
			}
			return new Vector2(num4, num5);
		}

		private static int GetActivePinnedTooltipSlotCount()
		{
			return Mathf.Clamp((int)((_pinnedTooltipSlots != null) ? _pinnedTooltipSlots.Value : PinnedTooltipSlotMode.Three), 1, 3);
		}

		private static int GetFirstActiveCraftingPinnedTooltipSlot()
		{
			return 3 - GetActivePinnedTooltipSlotCount();
		}

		private static PinnedTooltipContext GetCurrentCraftingPinnedTooltipContext(InventoryGui gui)
		{
			if (IsJewelcraftingSocketTabActive(gui))
			{
				return PinnedTooltipContext.CraftingUpgrade;
			}
			if (gui.InUpradeTab())
			{
				return PinnedTooltipContext.CraftingUpgrade;
			}
			if (gui.InCraftTab())
			{
				return PinnedTooltipContext.CraftingCraft;
			}
			return PinnedTooltipContext.None;
		}

		private static void SetPinnedTooltipContext(PinnedTooltipContext context)
		{
			TooltipController.SetPinnedContext(context);
		}

		private static void SyncPinnedTooltipContextWithCraftingTab(InventoryGui gui)
		{
			TooltipController.SyncCraftingPinnedContext(GetCurrentCraftingPinnedTooltipContext(gui));
		}

		private static void ApplyPinnedTooltipSlotLimit()
		{
			int activePinnedTooltipSlotCount = GetActivePinnedTooltipSlotCount();
			int firstActiveCraftingPinnedTooltipSlot = GetFirstActiveCraftingPinnedTooltipSlot();
			bool flag = false;
			for (int i = 0; i < 3; i++)
			{
				if (i >= activePinnedTooltipSlotCount && (IsInventoryPinnedTooltipSlotActive(i) || PinnedTooltips.Inventory.Items[i] != null))
				{
					HideInventoryPinnedTooltip(i);
					flag = true;
				}
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				if (i < firstActiveCraftingPinnedTooltipSlot && (PinnedTooltips.Crafting.RecipeIndices[i] >= 0 || ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf)))
				{
					HideCraftingPinnedTooltip(i);
				}
			}
			if (flag)
			{
				RefreshInventoryPinnedTooltipBorders();
			}
			RaiseInventoryPinnedTooltips();
		}

		private static void InvalidatePinnedTooltipUi()
		{
			ApplyPinnedTooltipSlotLimit();
			RefreshPinnedTooltipLayouts();
			RefreshPinnedTooltipBackgrounds();
			RefreshInventoryPinnedTooltipBorders();
			CraftingController.MarkRecipeGridLayoutDirty();
		}

		private static void RefreshPinnedTooltipLayouts()
		{
			//IL_0064: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < PinnedTooltips.Inventory.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeInHierarchy)
				{
					TMP_Text val2 = PinnedTooltips.Inventory.Texts[i] ?? FindPinnedTooltipText(val);
					if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
					{
						ApplyPinnedTooltipDynamicTextLayout(val, val2, i, InventoryPinnedTooltipFixedOffset, 102f, 18f, 0f, resetScroll: false);
					}
				}
			}
			for (int j = 0; j < PinnedTooltips.Crafting.Panels.Length; j++)
			{
				RectTransform val3 = PinnedTooltips.Crafting.Panels[j];
				if (!((Object)(object)val3 == (Object)null) && !IsUnityNull((Object?)(object)val3) && ((Component)val3).gameObject.activeInHierarchy)
				{
					TMP_Text val4 = PinnedTooltips.Crafting.Texts[j] ?? FindPinnedTooltipText(val3);
					if (!((Object)(object)val4 == (Object)null) && !IsUnityNull((Object?)(object)val4))
					{
						PinnedTooltipPanelUiCache component = ((Component)val3).GetComponent<PinnedTooltipPanelUiCache>();
						float bottomReserved = (((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component) && component.TextBottomReserved > 1f) ? component.TextBottomReserved : 92f);
						ApplyPinnedTooltipDynamicTextLayout(val3, val4, j, CraftingPinnedTooltipFixedOffset, 102f, bottomReserved, GetPinnedTooltipMaxTextViewportHeight(val3, 102f, bottomReserved), resetScroll: false);
					}
				}
			}
		}

		private static void RefreshPinnedTooltipBackgrounds()
		{
			RectTransform[] panels = PinnedTooltips.Inventory.Panels;
			foreach (RectTransform val in panels)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
				{
					ConfigurePinnedTooltipPanelBackground(val);
				}
			}
			panels = PinnedTooltips.Crafting.Panels;
			foreach (RectTransform val2 in panels)
			{
				if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2))
				{
					ConfigurePinnedTooltipPanelBackground(val2);
				}
			}
		}

		private static Vector2 GetPinnedTooltipPanelSize()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(Mathf.Clamp(PinnedTooltipFixedPanelSize.x, 180f, 1200f), Mathf.Clamp(PinnedTooltipFixedPanelSize.y, 180f, 1200f));
		}

		private static Vector2 GetPinnedTooltipPanelSize(RectTransform? parent)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize();
			if ((Object)(object)parent != (Object)null && !IsUnityNull((Object?)(object)parent) && TryGetPinnedTooltipVerticalFrame(parent, out var frame))
			{
				pinnedTooltipPanelSize.y = Mathf.Clamp(frame.Height, 180f, 1200f);
			}
			return pinnedTooltipPanelSize;
		}

		private static Vector2 GetPinnedTooltipPanelSize(float height)
		{
			//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_0006: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize();
			return new Vector2(pinnedTooltipPanelSize.x, Mathf.Clamp(height, 180f, pinnedTooltipPanelSize.y));
		}

		private static Vector2 GetPinnedTooltipPanelSize(RectTransform? parent, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize(parent);
			return new Vector2(pinnedTooltipPanelSize.x, Mathf.Clamp(height, 180f, pinnedTooltipPanelSize.y));
		}

		private static Vector2 GetPinnedTooltipPanelSize(float height, float minHeight)
		{
			//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_0006: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize();
			return new Vector2(pinnedTooltipPanelSize.x, Mathf.Clamp(height, Mathf.Clamp(minHeight, 180f, pinnedTooltipPanelSize.y), pinnedTooltipPanelSize.y));
		}

		private static Vector2 GetPinnedTooltipPanelSize(RectTransform? parent, float height, float minHeight)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize(parent);
			return new Vector2(pinnedTooltipPanelSize.x, Mathf.Clamp(height, Mathf.Clamp(minHeight, 180f, pinnedTooltipPanelSize.y), pinnedTooltipPanelSize.y));
		}

		private static bool TryGetPinnedTooltipVerticalFrame(RectTransform parent, out PinnedTooltipVerticalFrame frame)
		{
			frame = default(PinnedTooltipVerticalFrame);
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance) || !TryGetDefaultEquipmentPanelBottomWorldY(instance, parent, out var localY) || !TryGetCraftingPanelBottomWorldY(instance, parent, out var localY2))
			{
				return false;
			}
			float num = localY + GetPinnedTooltipTopOffset();
			float num2 = localY2 + GetPinnedTooltipBottomOffset();
			if (float.IsNaN(num) || float.IsNaN(num2) || float.IsInfinity(num) || float.IsInfinity(num2) || num <= num2 + 180f)
			{
				return false;
			}
			frame = new PinnedTooltipVerticalFrame(num, num2);
			return true;
		}

		private static bool TryGetPinnedTooltipStartLocalX(RectTransform parent, out float x)
		{
			x = 0f;
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance))
			{
				return false;
			}
			if (TooltipController.IsCraftingPinnedContext())
			{
				if (!TryGetRectWorldMinX(instance.m_crafting, out var x2))
				{
					return false;
				}
				x = WorldXToCenteredAnchoredX(parent, x2) + GetPinnedTooltipCraftingStartOffset();
			}
			else
			{
				if (!TryGetRectWorldMaxX(instance.m_player, out var x3))
				{
					return false;
				}
				x = WorldXToCenteredAnchoredX(parent, x3) + GetPinnedTooltipInventoryStartOffset();
			}
			if (!float.IsNaN(x))
			{
				return !float.IsInfinity(x);
			}
			return false;
		}

		private static float GetPinnedTooltipTopOffset()
		{
			return -12f;
		}

		private static float GetPinnedTooltipBottomOffset()
		{
			return 60f;
		}

		private static float GetPinnedTooltipInventoryStartOffset()
		{
			return 6f;
		}

		private static float GetPinnedTooltipCraftingStartOffset()
		{
			return -80f;
		}

		private static bool TryGetDefaultEquipmentPanelBottomWorldY(InventoryGui gui, RectTransform parent, out float localY)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00a6: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			localY = 0f;
			InventoryGrid playerGrid = gui.m_playerGrid;
			if ((Object)(object)playerGrid == (Object)null || IsUnityNull((Object?)(object)playerGrid) || (Object)(object)playerGrid.m_gridRoot == (Object)null || IsUnityNull((Object?)(object)playerGrid.m_gridRoot))
			{
				return false;
			}
			int num = ((playerGrid.m_inventory != null) ? playerGrid.m_inventory.GetWidth() : playerGrid.m_width);
			if (num <= 0)
			{
				num = 8;
			}
			float num2 = Mathf.Max(1f, playerGrid.m_elementSpace);
			Vector3 val = GetSidePanelBasePosition(GetGridOrigin(playerGrid), num, num2) + Vector2.op_Implicit(EquipmentSlotsPanelFixedOffset) + new Vector3(0f, -3f * num2, 0f);
			float y = ((Transform)playerGrid.m_gridRoot).TransformPoint(val).y;
			localY = WorldYToCenteredAnchoredY(parent, y);
			if (!float.IsNaN(localY))
			{
				return !float.IsInfinity(localY);
			}
			return false;
		}

		private static bool TryGetCraftingPanelBottomWorldY(InventoryGui gui, RectTransform parent, out float localY)
		{
			localY = 0f;
			RectTransform crafting = gui.m_crafting;
			if (!TryGetRectWorldMinY(crafting, out var y))
			{
				return false;
			}
			if ((Object)(object)crafting != (Object)null && !IsUnityNull((Object?)(object)crafting))
			{
				y = GetPinnedTooltipCraftingPanelVirtualBottomWorldY(crafting, y);
			}
			localY = WorldYToCenteredAnchoredY(parent, y);
			if (!float.IsNaN(localY))
			{
				return !float.IsInfinity(localY);
			}
			return false;
		}

		private static float GetPinnedTooltipCraftingPanelVirtualBottomWorldY(RectTransform craftingPanel, float currentWorldBottomY)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			float remainingCraftingPanelVirtualExtension = GetRemainingCraftingPanelVirtualExtension(craftingPanel);
			if (remainingCraftingPanelVirtualExtension <= 0.01f)
			{
				return currentWorldBottomY;
			}
			Vector3 val = ((Transform)craftingPanel).TransformVector(new Vector3(0f, (0f - remainingCraftingPanelVirtualExtension) * Mathf.Clamp01(craftingPanel.pivot.y), 0f));
			float num = currentWorldBottomY + val.y;
			if (!float.IsNaN(num) && !float.IsInfinity(num))
			{
				return num;
			}
			return currentWorldBottomY;
		}

		private static float GetRemainingCraftingPanelVirtualExtension(RectTransform craftingPanel)
		{
			//IL_0035: 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)
			float num = 84f;
			if (num <= 0.01f)
			{
				return 0f;
			}
			if (_craftingPanelRootSnapshot == null || (Object)(object)_craftingPanelRootSnapshot.Rect != (Object)(object)craftingPanel)
			{
				return num;
			}
			float num2 = Mathf.Max(0f, craftingPanel.sizeDelta.y - _craftingPanelOriginalSizeDelta.y);
			return Mathf.Max(0f, num - num2);
		}

		private static float WorldXToCenteredAnchoredX(RectTransform parent, float worldX)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0025: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Transform)parent).position;
			return ((Transform)parent).InverseTransformPoint(new Vector3(worldX, position.y, position.z)).x - GetCenteredAnchorReference(parent).x;
		}

		private static float WorldYToCenteredAnchoredY(RectTransform parent, float worldY)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Transform)parent).position;
			return ((Transform)parent).InverseTransformPoint(new Vector3(position.x, worldY, position.z)).y - GetCenteredAnchorReference(parent).y;
		}

		private static Vector2 GetCenteredAnchorReference(RectTransform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = parent.rect;
			return new Vector2(((Rect)(ref rect)).xMin + ((Rect)(ref rect)).width * 0.5f, ((Rect)(ref rect)).yMin + ((Rect)(ref rect)).height * 0.5f);
		}

		private static bool TryGetRectWorldMinX(RectTransform? rect, out float x)
		{
			return TryGetRectWorldEdge(rect, 0, findMax: false, out x);
		}

		private static bool TryGetRectWorldMaxX(RectTransform? rect, out float x)
		{
			return TryGetRectWorldEdge(rect, 0, findMax: true, out x);
		}

		private static bool TryGetRectWorldMinY(RectTransform? rect, out float y)
		{
			return TryGetRectWorldEdge(rect, 1, findMax: false, out y);
		}

		private static bool TryGetRectWorldEdge(RectTransform? rect, int axis, bool findMax, out float value)
		{
			value = 0f;
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rect.GetWorldCorners(array);
			value = ((axis == 0) ? array[0].x : array[0].y);
			for (int i = 1; i < array.Length; i++)
			{
				float num = ((axis == 0) ? array[i].x : array[i].y);
				value = (findMax ? Mathf.Max(value, num) : Mathf.Min(value, num));
			}
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static TMP_Text? FindPinnedTooltipText(RectTransform panel)
		{
			PinnedTooltipPanelUiCache component = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>();
			if ((Object)(object)component?.BodyText != (Object)null && !IsUnityNull((Object?)(object)component.BodyText) && component.BodyText.transform.IsChildOf((Transform)(object)panel))
			{
				return component.BodyText;
			}
			TMP_Text[] componentsInChildren = ((Component)panel).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Object)val).name == "Text")
				{
					(component ?? ((Component)panel).gameObject.AddComponent<PinnedTooltipPanelUiCache>()).BodyText = val;
					return val;
				}
			}
			return null;
		}

		private static Image EnsurePinnedTooltipIcon(RectTransform panel)
		{
			//IL_003a: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Transform)panel).Find("Icon");
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : new GameObject("Icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>());
			if ((Object)(object)((Transform)val2).parent != (Object)(object)panel)
			{
				((Transform)val2).SetParent((Transform)(object)panel, false);
			}
			SetTopLeftRectLayout(val2, new Vector2(16f, -16f), new Vector2(72f, 72f));
			Image obj = ((Component)val2).GetComponent<Image>() ?? ((Component)val2).gameObject.AddComponent<Image>();
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		private static RectTransform EnsurePinnedTooltipPanel(RectTransform parent, string name, RectTransform? current, Func<RectTransform?>? findFallback = null)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = current;
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)((Transform)val).parent != (Object)(object)parent)
			{
				Transform val2 = ((Transform)parent).Find(name);
				val = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<RectTransform>() : null);
				if (val == null)
				{
					val = findFallback?.Invoke();
				}
				if (val == null)
				{
					val = new GameObject(name, new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					}).GetComponent<RectTransform>();
				}
				((Transform)val).SetParent((Transform)(object)parent, false);
			}
			ConfigurePinnedTooltipPanelBackground(val);
			ConfigurePinnedTooltipPanelRaycast(val);
			return val;
		}

		private static void ConfigurePinnedTooltipPanelRaycast(RectTransform panel)
		{
			PinnedTooltipPanelUiCache pinnedTooltipPanelUiCache = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>() ?? ((Component)panel).gameObject.AddComponent<PinnedTooltipPanelUiCache>();
			if ((Object)(object)pinnedTooltipPanelUiCache.Background == (Object)null || IsUnityNull((Object?)(object)pinnedTooltipPanelUiCache.Background))
			{
				pinnedTooltipPanelUiCache.Background = ((Component)panel).GetComponent<Image>();
			}
			if ((Object)(object)pinnedTooltipPanelUiCache.Background != (Object)null)
			{
				((Graphic)pinnedTooltipPanelUiCache.Background).raycastTarget = false;
			}
			Transform obj = ((Transform)panel).Find("Icon");
			Image val = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			if (val != null)
			{
				((Graphic)val).raycastTarget = false;
			}
			TMP_Text val2 = FindPinnedTooltipText(panel);
			if (val2 != null)
			{
				((Graphic)val2).raycastTarget = false;
			}
		}

		private static TMP_Text EnsurePinnedTooltipBodyText(RectTransform panel, float fontSize)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text text = FindPinnedTooltipText(panel);
			if ((Object)(object)text == (Object)null || IsUnityNull((Object?)(object)text))
			{
				CreateTextRect("Text", (Transform)(object)panel, out text);
			}
			(((Component)panel).GetComponent<PinnedTooltipPanelUiCache>() ?? ((Component)panel).gameObject.AddComponent<PinnedTooltipPanelUiCache>()).BodyText = text;
			ApplyDefaultFontAsset(text);
			ApplyTooltipSourceFont(text, "Text");
			text.enableAutoSizing = false;
			text.fontSize = fontSize;
			((Graphic)text).color = Color.white;
			text.textWrappingMode = (TextWrappingModes)1;
			text.overflowMode = (TextOverflowModes)0;
			text.maxVisibleCharacters = int.MaxValue;
			text.maxVisibleWords = int.MaxValue;
			text.maxVisibleLines = int.MaxValue;
			((Graphic)text).raycastTarget = false;
			((Behaviour)text).enabled = true;
			((Component)text).gameObject.SetActive(true);
			EnsurePinnedTooltipTextScrollContent(panel, text);
			return text;
		}

		private static RectTransform EnsurePinnedTooltipTextScrollContent(RectTransform panel, TMP_Text text)
		{
			//IL_0088: 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_00b2: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			PinnedTooltipPanelUiCache cache = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>() ?? ((Component)panel).gameObject.AddComponent<PinnedTooltipPanelUiCache>();
			ScrollableTooltipBodyState scrollableTooltipBodyState = ScrollableTooltipBody.FromPinnedCache(cache);
			bool scrollRectEnabled = (Object)(object)scrollableTooltipBodyState.ScrollRect != (Object)null && !IsUnityNull((Object?)(object)scrollableTooltipBodyState.ScrollRect) && ((Behaviour)scrollableTooltipBodyState.ScrollRect).enabled;
			RectTransform result = ScrollableTooltipBody.Ensure(panel, text, scrollableTooltipBodyState, GetSolidUiSprite(), GetPinnedTooltipScrollSensitivity(), scrollRectEnabled, inertia: true, handleRaycastTarget: true, scrollbarRaycastTarget: true);
			ScrollableTooltipBody.ApplyToPinnedCache(scrollableTooltipBodyState, cache);
			RectTransform rectTransform = text.rectTransform;
			((Component)rectTransform).gameObject.SetActive(true);
			((Behaviour)text).enabled = true;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = Vector2.zero;
			((Graphic)text).raycastTarget = false;
			text.overflowMode = (TextOverflowModes)0;
			text.textWrappingMode = (TextWrappingModes)1;
			((Graphic)text).color = Color.white;
			return result;
		}

		private static void LayoutPinnedTooltipTextScrollbar(RectTransform rect, float topReserved, float bottomReserved)
		{
			ScrollableTooltipBody.LayoutStretchScrollbar(rect, 2f, 3f, topReserved, bottomReserved);
		}

		private static void ResetPinnedTooltipTextScrollState(RectTransform panel)
		{
			//IL_003a: 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)
			PinnedTooltipPanelUiCache component = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>();
			if (!((Object)(object)component == (Object)null) && !IsUnityNull((Object?)(object)component))
			{
				if ((Object)(object)component.TextContent != (Object)null && !IsUnityNull((Object?)(object)component.TextContent))
				{
					component.TextContent.anchoredPosition = Vector2.zero;
				}
				if ((Object)(object)component.TextScrollRect != (Object)null && !IsUnityNull((Object?)(object)component.TextScrollRect))
				{
					component.TextScrollRect.verticalNormalizedPosition = 1f;
					component.TextScrollRect.velocity = Vector2.zero;
					component.TextScrollRect.StopMovement();
				}
				if ((Object)(object)component.TextScrollbar != (Object)null && !IsUnityNull((Object?)(object)component.TextScrollbar))
				{
					SetPinnedTooltipScrollbarVisible(component.TextScrollbar, visible: false);
				}
				component.TextLayoutSignature = "";
				component.TextRepairSignature = "";
			}
		}

		private static void RepairCraftingPinnedTooltipTextVisibility()
		{
			//IL_00c2: 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)
			for (int i = 0; i < PinnedTooltips.Crafting.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Component)val).gameObject.activeSelf)
				{
					continue;
				}
				TMP_Text val2 = PinnedTooltips.Crafting.Texts[i];
				if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2))
				{
					val2 = FindPinnedTooltipText(val);
					PinnedTooltips.Crafting.Texts[i] = val2;
				}
				if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2))
				{
					continue;
				}
				bool flag = false;
				if (!((Component)val2).gameObject.activeSelf)
				{
					flag = true;
					((Component)val2).gameObject.SetActive(true);
				}
				if (!((Behaviour)val2).enabled)
				{
					flag = true;
					((Behaviour)val2).enabled = true;
				}
				if (((Graphic)val2).color.a <= 0.01f)
				{
					flag = true;
					((Graphic)val2).color = Color.white;
				}
				PinnedTooltipPanelUiCache component = ((Component)val).GetComponent<PinnedTooltipPanelUiCache>();
				if (!((Object)(object)component == (Object)null) && !IsUnityNull((Object?)(object)component))
				{
					string pinnedTooltipRepairSignature = GetPinnedTooltipRepairSignature(val, val2, component);
					if (flag || !string.Equals(component.TextRepairSignature, pinnedTooltipRepairSignature, StringComparison.Ordinal))
					{
						RepairPinnedTooltipScrollbarVisibility(val, val2);
						component.TextRepairSignature = pinnedTooltipRepairSignature;
					}
				}
			}
		}

		private static bool HandleCraftingPinnedTooltipWheel()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (!TooltipController.IsCraftingPinnedContext())
			{
				return false;
			}
			if (ShouldBlockGlobalHotkeys(Player.m_localPlayer))
			{
				return false;
			}
			bool flag = IsGamepadUiScrollActive();
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Continuous);
			if (Mathf.Abs(uiScrollDelta) < 0.01f)
			{
				return false;
			}
			for (int i = 0; i < PinnedTooltips.Crafting.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Crafting.Panels[i];
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeInHierarchy && (flag || RectContainsScreenPoint(val, GetUiMousePosition())))
				{
					return TryScrollPinnedTooltipPanel(val, i, uiScrollDelta);
				}
			}
			return false;
		}

		private static bool HandleInventoryPinnedTooltipWheel()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!TooltipController.IsInventoryPinnedContext() || ShouldBlockGlobalHotkeys(Player.m_localPlayer))
			{
				return false;
			}
			bool flag = IsGamepadUiScrollActive();
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Continuous);
			if (Mathf.Abs(uiScrollDelta) < 0.01f)
			{
				return false;
			}
			for (int i = 0; i < PinnedTooltips.Inventory.Panels.Length; i++)
			{
				RectTransform val = PinnedTooltips.Inventory.Panels[i];
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeInHierarchy && (flag || RectContainsScreenPoint(val, GetUiMousePosition())))
				{
					return TryScrollPinnedTooltipPanel(val, i, uiScrollDelta);
				}
			}
			return false;
		}

		private static bool TryScrollPinnedTooltipPanel(RectTransform panel, int slot, float wheel)
		{
			PinnedTooltipPanelUiCache component = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>();
			if ((Object)(object)component == (Object)null || IsUnityNull((Object?)(object)component) || (Object)(object)component.TextScrollRect == (Object)null || IsUnityNull((Object?)(object)component.TextScrollRect) || !((Behaviour)component.TextScrollRect).enabled || component.TextContentHeight <= component.TextViewportHeight + 8f)
			{
				return false;
			}
			float num = Mathf.Max(1f, component.TextContentHeight - component.TextViewportHeight);
			float num2 = wheel * GetPinnedTooltipScrollSensitivity() / num;
			component.TextScrollRect.verticalNormalizedPosition = Mathf.Clamp01(component.TextScrollRect.verticalNormalizedPosition + num2);
			if ((Object)(object)component.TextScrollbar != (Object)null && !IsUnityNull((Object?)(object)component.TextScrollbar))
			{
				component.TextScrollbar.value = component.TextScrollRect.verticalNormalizedPosition;
			}
			return true;
		}

		private static void RepairPinnedTooltipScrollbarVisibility(RectTransform panel, TMP_Text text)
		{
			//IL_0090: 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_00e2: 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)
			PinnedTooltipPanelUiCache component = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>();
			if (!((Object)(object)component == (Object)null) && !IsUnityNull((Object?)(object)component) && !((Object)(object)component.TextScrollRect == (Object)null) && !IsUnityNull((Object?)(object)component.TextScrollRect) && !((Object)(object)component.TextScrollbar == (Object)null) && !IsUnityNull((Object?)(object)component.TextScrollbar) && !((Object)(object)component.TextViewport == (Object)null) && !IsUnityNull((Object?)(object)component.TextViewport) && !((Object)(object)component.TextContent == (Object)null) && !IsUnityNull((Object?)(object)component.TextContent))
			{
				Rect rect = text.rectTransform.rect;
				float num = Mathf.Max(1f, ((Rect)(ref rect)).width);
				float pinnedTooltipTextOnlyPreferredHeight = GetPinnedTooltipTextOnlyPreferredHeight(text, num);
				float num2 = LayoutPinnedTooltipExtraScrollContent(panel, num, pinnedTooltipTextOnlyPreferredHeight);
				float num3 = pinnedTooltipTextOnlyPreferredHeight + num2 + (component.TextHasViewportCap ? 0f : 0f);
				float num4;
				if (!(component.TextViewportHeight > 1f))
				{
					rect = component.TextViewport.rect;
					num4 = ((Rect)(ref rect)).height;
				}
				else
				{
					num4 = component.TextViewportHeight;
				}
				float num5 = num4;
				if (!(num5 < 1f))
				{
					num = ((component.TextWidth > 1f) ? component.TextWidth : num);
					num3 = (component.TextContentHeight = Mathf.Max(1f, num3));
					bool flag = num3 > num5 + 8f;
					ApplyPinnedTooltipTextScrollGeometry(panel, text, component, num, num3, num5, resetScroll: false, flag);
					component.TextScrollRect.scrollSensitivity = GetPinnedTooltipScrollSensitivity();
					SetPinnedTooltipScrollbarVisible(component.TextScrollbar, flag);
					component.TextScrollbar.size = (flag ? Mathf.Clamp01(num5 / num3) : 1f);
					component.TextScrollRect.verticalScrollbar = (flag ? component.TextScrollbar : null);
					component.TextScrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)(!flag);
					((Behaviour)component.TextScrollRect).enabled = flag;
				}
			}
		}

		private static string GetPinnedTooltipRepairSignature(RectTransform panel, TMP_Text text, PinnedTooltipPanelUiCache cache)
		{
			//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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = text.rectTransform.rect;
			float num;
			Rect rect2;
			if (!(cache.TextViewportHeight > 1f))
			{
				if (!((Object)(object)cache.TextViewport != (Object)null) || IsUnityNull((Object?)(object)cache.TextViewport))
				{
					num = 0f;
				}
				else
				{
					rect2 = cache.TextViewport.rect;
					num = ((Rect)(ref rect2)).height;
				}
			}
			else
			{
				num = cache.TextViewportHeight;
			}
			float num2 = num;
			object[] array = new object[13];
			rect2 = panel.rect;
			array[0] = ((Rect)(ref rect2)).width;
			rect2 = panel.rect;
			array[1] = ((Rect)(ref rect2)).height;
			array[2] = ((Rect)(ref rect)).width;
			array[3] = ((Rect)(ref rect)).height;
			array[4] = num2;
			array[5] = cache.TextWidth;
			array[6] = cache.TextTopReserved;
			array[7] = cache.TextBottomReserved;
			array[8] = cache.TextHasViewportCap;
			array[9] = GetPinnedTooltipScrollSensitivity();
			array[10] = ((Transform)panel).childCount;
			array[11] = text.text?.Length ?? 0;
			array[12] = text.text?.GetHashCode() ?? 0;
			return string.Format("{0:0.###}|{1:0.###}|{2:0.###}|{3:0.###}|{4:0.###}|{5:0.###}|{6:0.###}|{7:0.###}|{8}|{9:0.###}|{10}|{11}|{12}", array);
		}

		private static float GetPinnedTooltipScrollSensitivity()
		{
			return 240f;
		}

		private static float GetPinnedTooltipPreferredTextHeight(TMP_Text text, float textWidth)
		{
			return GetPinnedTooltipTextOnlyPreferredHeight(text, textWidth);
		}

		private static float GetPinnedTooltipTextOnlyPreferredHeight(TMP_Text text, float textWidth)
		{
			//IL_001c: 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_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_004a: 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_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_00c6: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			string text2 = text.text ?? "";
			text.rectTransform.sizeDelta = new Vector2(textWidth, 1f);
			float num = text.GetPreferredValues(text2, textWidth, 0f).y;
			text.ForceMeshUpdate(true, true);
			Bounds textBounds = text.textBounds;
			if (!float.IsNaN(((Bounds)(ref textBounds)).size.y) && !float.IsInfinity(((Bounds)(ref textBounds)).size.y) && ((Bounds)(ref textBounds)).size.y > 0f)
			{
				num = Mathf.Max(num, ((Bounds)(ref textBounds)).size.y);
			}
			TMP_TextInfo textInfo = text.textInfo;
			if (textInfo != null && textInfo.lineCount > 0 && textInfo.lineInfo != null && textInfo.lineInfo.Length >= textInfo.lineCount)
			{
				TMP_LineInfo val = textInfo.lineInfo[0];
				TMP_LineInfo val2 = textInfo.lineInfo[textInfo.lineCount - 1];
				float num2 = val.ascender - val2.descender;
				if (!float.IsNaN(num2) && !float.IsInfinity(num2))
				{
					num = Mathf.Max(num, num2);
				}
			}
			if (!float.IsNaN(num) && !float.IsInfinity(num) && !(num < 1f))
			{
				return Mathf.Max(1f, num);
			}
			return 1f;
		}

		private static float GetPinnedTooltipMaxTextViewportHeight(RectTransform panel, float topReserved, float bottomReserved)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)panel).parent;
			RectTransform parent2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			return Mathf.Max(120f, GetPinnedTooltipPanelSize(parent2).y - topReserved - bottomReserved);
		}

		private static Vector2 ApplyPinnedTooltipDynamicTextLayout(RectTransform panel, TMP_Text text, int slot, Vector2 groupOffset, float topReserved, float bottomReserved, float maxTextViewportHeight = 0f, bool resetScroll = true)
		{
			//IL_0023: 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_006c: 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_00bc: 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_00e6: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: 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_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: 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_02bc: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			EnsurePinnedTooltipTextScrollContent(panel, text);
			PinnedTooltipPanelUiCache component = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>();
			Transform parent = ((Transform)panel).parent;
			RectTransform parent2 = (RectTransform)(((object)((parent is RectTransform) ? parent : null)) ?? ((object)panel));
			string pinnedTooltipTextLayoutSignature = GetPinnedTooltipTextLayoutSignature(panel, text, slot, groupOffset, topReserved, bottomReserved, maxTextViewportHeight);
			if (!resetScroll && ((Component)panel).gameObject.activeInHierarchy && string.Equals(component.TextLayoutSignature, pinnedTooltipTextLayoutSignature, StringComparison.Ordinal))
			{
				Rect rect = panel.rect;
				return ((Rect)(ref rect)).size;
			}
			Vector2 pinnedTooltipPanelSize = GetPinnedTooltipPanelSize(parent2);
			float num = Mathf.Max(40f, pinnedTooltipPanelSize.x - 44f);
			((Behaviour)text).enabled = true;
			((Component)text).gameObject.SetActive(true);
			text.rectTransform.anchorMin = new Vector2(0f, 1f);
			text.rectTransform.anchorMax = new Vector2(0f, 1f);
			text.rectTransform.pivot = new Vector2(0f, 1f);
			text.rectTransform.anchoredPosition = Vector2.zero;
			text.rectTransform.sizeDelta = new Vector2(num, 1f);
			text.ForceMeshUpdate(true, true);
			float pinnedTooltipPreferredTextHeight = GetPinnedTooltipPreferredTextHeight(text, num);
			bool flag = maxTextViewportHeight > 1f;
			float num2 = LayoutPinnedTooltipExtraScrollContent(panel, num, pinnedTooltipPreferredTextHeight);
			float num3 = pinnedTooltipPreferredTextHeight + num2 + (flag ? 0f : 0f);
			float num4 = (flag ? Mathf.Min(num3, maxTextViewportHeight) : num3);
			float height = topReserved + bottomReserved + num4;
			float minHeight = topReserved + bottomReserved + 72f;
			Vector2 pinnedTooltipPanelSize2 = GetPinnedTooltipPanelSize(parent2, height, minHeight);
			Vector2 pinnedTooltipPosition = GetPinnedTooltipPosition(parent2, slot, pinnedTooltipPanelSize2, groupOffset);
			Transform parent3 = ((Transform)panel).parent;
			SetCenteredRect((RectTransform)(((object)((parent3 is RectTransform) ? parent3 : null)) ?? ((object)panel)), panel, pinnedTooltipPosition, pinnedTooltipPanelSize2);
			_ = component.TextScrollView;
			_ = component.TextViewport;
			float num5 = Mathf.Max(1f, pinnedTooltipPanelSize2.y - topReserved - bottomReserved);
			if (flag)
			{
				num5 = Mathf.Min(num5, maxTextViewportHeight);
				float num6 = topReserved + bottomReserved + num5;
				if (num6 < pinnedTooltipPanelSize2.y - 0.5f)
				{
					pinnedTooltipPanelSize2 = GetPinnedTooltipPanelSize(parent2, num6, minHeight);
					pinnedTooltipPosition = GetPinnedTooltipPosition(parent2, slot, pinnedTooltipPanelSize2, groupOffset);
					Transform parent4 = ((Transform)panel).parent;
					SetCenteredRect((RectTransform)(((object)((parent4 is RectTransform) ? parent4 : null)) ?? ((object)panel)), panel, pinnedTooltipPosition, pinnedTooltipPanelSize2);
				}
			}
			component.TextWidth = num;
			component.TextContentHeight = num3;
			component.TextViewportHeight = num5;
			component.TextTopReserved = topReserved;
			component.TextBottomReserved = bottomReserved;
			component.TextHasViewportCap = flag;
			component.TextRepairSignature = "";
			bool flag2 = num3 > num5 + 8f;
			ApplyPinnedTooltipTextScrollGeometry(panel, text, component, num, num3, num5, resetScroll, flag2);
			if ((Object)(object)component.TextScrollbar != (Object)null && !IsUnityNull((Object?)(object)component.TextScrollbar))
			{
				LayoutPinnedTooltipTextScrollbar((RectTransform)((Component)component.TextScrollbar).transform, topReserved, bottomReserved);
				SetPinnedTooltipScrollbarVisible(component.TextScrollbar, flag2);
				component.TextScrollbar.size = (flag2 ? Mathf.Clamp01(num5 / num3) : 1f);
				component.TextScrollbar.value = ((resetScroll || !flag2) ? 1f : Mathf.Clamp01(((Object)(object)component.TextScrollRect != (Object)null && !IsUnityNull((Object?)(object)component.TextScrollRect)) ? component.TextScrollRect.verticalNormalizedPosition : component.TextScrollbar.value));
			}
			if ((Object)(object)component.TextScrollRect != (Object)null)
			{
				component.TextScrollRect.scrollSensitivity = GetPinnedTooltipScrollSensitivity();
				if (resetScroll || !flag2)
				{
					component.TextScrollRect.verticalNormalizedPosition = 1f;
				}
				component.TextScrollRect.verticalScrollbar = (flag2 ? component.TextScrollbar : null);
				component.TextScrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)(!flag2);
				((Behaviour)component.TextScrollRect).enabled = flag2;
			}
			if ((Object)(object)component.TextScrollView != (Object)null)
			{
				Image component2 = ((Component)component.TextScrollView).GetComponent<Image>();
				if (component2 != null)
				{
					((Graphic)component2).raycastTarget = false;
				}
			}
			if ((Object)(object)component.TextViewport != (Object)null)
			{
				Image component3 = ((Component)component.TextViewport).GetComponent<Image>();
				if (component3 != null)
				{
					((Graphic)component3).raycastTarget = false;
				}
			}
			component.TextLayoutSignature = GetPinnedTooltipTextLayoutSignature(panel, text, slot, groupOffset, topReserved, bottomReserved, maxTextViewportHeight);
			return pinnedTooltipPanelSize2;
		}

		private static string GetPinnedTooltipTextLayoutSignature(RectTransform panel, TMP_Text text, int slot, Vector2 groupOffset, float topReserved, float bottomReserved, float maxTextViewportHeight)
		{
			//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)
			Transform parent = ((Transform)panel).parent;
			RectTransform val = (RectTransform)(((object)((parent is RectTransform) ? parent : null)) ?? ((object)panel));
			Rect rect = val.rect;
			string text2 = text.text ?? "";
			return string.Join("|", slot, groupOffset.x.ToString("0.###"), groupOffset.y.ToString("0.###"), topReserved.ToString("0.###"), bottomReserved.ToString("0.###"), maxTextViewportHeight.ToString("0.###"), ((Object)val).GetInstanceID(), ((Rect)(ref rect)).width.ToString("0.###"), ((Rect)(ref rect)).height.ToString("0.###"), ((Transform)panel).childCount, text2.Length, text2.GetHashCode(), Screen.width, Screen.height, GetPinnedTooltipExtraLayoutSignature(panel), 240f.ToString("0.###"));
		}

		private static string GetPinnedTooltipExtraLayoutSignature(RectTransform panel)
		{
			RectTransform val = FindJewelcraftingTooltipRoot(panel);
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && ((Component)val).gameObject.activeSelf)
			{
				JewelcraftingTooltipLayoutCache component = ((Component)val).GetComponent<JewelcraftingTooltipLayoutCache>();
				return string.Join(":", "jc", ((Object)val).GetInstanceID(), component?.Signature ?? "", (component != null && component.Visible) ? "1" : "0", (component != null && component.HasResolvedSocketGems) ? "1" : "0", GetJewelcraftingNativeTooltipLayoutSignature(val));
			}
			Transform val2 = ((Transform)panel).Find("InventorySlots_CraftingGemIconRow");
			if ((Object)(object)val2 != (Object)null && !IsUnityNull((Object?)(object)val2) && ((Component)val2).gameObject.activeSelf)
			{
				return $"gems:{((Object)val2).GetInstanceID()}:{val2.childCount}";
			}
			Transform val3 = ((Transform)panel).Find("RecipeRow");
			if ((Object)(object)val3 != (Object)null && !IsUnityNull((Object?)(object)val3) && ((Component)val3).gameObject.activeSelf)
			{
				return $"recipe:{((Object)val3).GetInstanceID()}:{val3.childCount}";
			}
			return "";
		}

		private static void ApplyPinnedTooltipTextScrollGeometry(RectTransform panel, TMP_Text text, PinnedTooltipPanelUiCache cache, float textWidth, float contentHeight, float viewportHeight, bool resetScroll, bool needsScroll)
		{
			//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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_00d9: 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)
			if (!((Object)(object)cache.TextScrollView == (Object)null) && !IsUnityNull((Object?)(object)cache.TextScrollView) && !((Object)(object)cache.TextViewport == (Object)null) && !IsUnityNull((Object?)(object)cache.TextViewport) && !((Object)(object)cache.TextContent == (Object)null) && !IsUnityNull((Object?)(object)cache.TextContent))
			{
				float num = (((Object)(object)cache.TextScrollRect != (Object)null && !IsUnityNull((Object?)(object)cache.TextScrollRect)) ? cache.TextScrollRect.verticalNormalizedPosition : 1f);
				Vector2 anchoredPosition = cache.TextContent.anchoredPosition;
				RectTransform? textScrollView = cache.TextScrollView;
				SetTopLeftRectLayout(textScrollView, new Vector2(18f, 0f - cache.TextTopReserved), new Vector2(textWidth, viewportHeight));
				RectTransform? textViewport = cache.TextViewport;
				SetStretchRectLayout(textViewport, Vector2.zero, Vector2.zero);
				RectTransform textContent = cache.TextContent;
				SetTopLeftRectLayout(textContent, (resetScroll || !needsScroll) ? Vector2.zero : anchoredPosition, new Vector2(textWidth, contentHeight));
				RectTransform rectTransform = text.rectTransform;
				if ((Object)(object)((Transform)rectTransform).parent != (Object)(object)textContent)
				{
					((Transform)rectTransform).SetParent((Transform)(object)textContent, false);
				}
				SetTopLeftRectLayout(rectTransform, Vector2.zero, new Vector2(textWidth, contentHeight));
				((Component)text).gameObject.SetActive(true);
				Canvas.ForceUpdateCanvases();
				LayoutRebuilder.ForceRebuildLayoutImmediate(textContent);
				LayoutRebuilder.ForceRebuildLayoutImmediate(textViewport);
				LayoutRebuilder.ForceRebuildLayoutImmediate(textScrollView);
				LayoutRebuilder.ForceRebuildLayoutImmediate(panel);
				if ((Object)(object)cache.TextScrollRect != (Object)null && !IsUnityNull((Object?)(object)cache.TextScrollRect))
				{
					cache.TextScrollRect.verticalNormalizedPosition = ((resetScroll || !needsScroll) ? 1f : Mathf.Clamp01(num));
				}
			}
		}

		private static void SetPinnedTooltipScrollbarVisible(Scrollbar? scrollbar, bool visible)
		{
			if ((Object)(object)scrollbar == (Object)null || IsUnityNull((Object?)(object)scrollbar))
			{
				return;
			}
			((Component)scrollbar).gameObject.SetActive(visible);
			((Behaviour)scrollbar).enabled = visible;
			if ((Object)(object)((Selectable)scrollbar).targetGraphic != (Object)null && !IsUnityNull((Object?)(object)((Selectable)scrollbar).targetGraphic))
			{
				((Behaviour)((Selectable)scrollbar).targetGraphic).enabled = visible;
				((Selectable)scrollbar).targetGraphic.raycastTarget = visible;
			}
			Graphic[] componentsInChildren = ((Component)scrollbar).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val))
				{
					((Behaviour)val).enabled = visible;
					val.raycastTarget = visible;
				}
			}
		}

		private static void ConfigurePinnedTooltipPanelBackground(RectTransform panel)
		{
			//IL_0117: 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)
			if ((Object)(object)panel == (Object)null || IsUnityNull((Object?)(object)panel))
			{
				return;
			}
			PinnedTooltipPanelUiCache pinnedTooltipPanelUiCache = ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>() ?? ((Component)panel).gameObject.AddComponent<PinnedTooltipPanelUiCache>();
			if ((Object)(object)pinnedTooltipPanelUiCache.Background == (Object)null || IsUnityNull((Object?)(object)pinnedTooltipPanelUiCache.Background))
			{
				pinnedTooltipPanelUiCache.Background = ((Component)panel).GetComponent<Image>();
			}
			Image background = pinnedTooltipPanelUiCache.Background;
			if (!((Object)(object)background == (Object)null) && !IsUnityNull((Object?)(object)background))
			{
				Sprite solidUiSprite = GetSolidUiSprite();
				float num = Mathf.Clamp01(GetAdvancedConfigFloat(_pinnedTooltipBackgroundAlpha, 0.9f));
				Color val = default(Color);
				((Color)(ref val))..ctor(0f, 0f, 0f, num);
				string text = (((Object)(object)solidUiSprite != (Object)null && !IsUnityNull((Object?)(object)solidUiSprite)) ? ((Object)solidUiSprite).GetInstanceID() : 0) + "|" + num.ToString("0.###", CultureInfo.InvariantCulture);
				if (!(pinnedTooltipPanelUiCache.BackgroundSignature == text) || !((Object)(object)background.sprite == (Object)(object)solidUiSprite) || !(((Graphic)background).color == val) || ((Graphic)background).raycastTarget)
				{
					background.sprite = solidUiSprite;
					((Graphic)background).color = val;
					((Graphic)background).raycastTarget = false;
					pinnedTooltipPanelUiCache.BackgroundSignature = text;
				}
			}
		}

		private static void SetCenteredRect(RectTransform parent, RectTransform rect, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			SetCenteredRectLayout(rect, anchoredPosition, size);
		}

		private static void EnsureInventoryPinnedTooltipHandlers(InventoryGrid? grid)
		{
			if ((Object)(object)grid == (Object)null || grid.m_elements == null)
			{
				return;
			}
			InventoryPinnedTooltipGridMarker inventoryPinnedTooltipGridMarker = GetInventoryPinnedTooltipGridMarker(grid);
			if ((Object)(object)inventoryPinnedTooltipGridMarker != (Object)null && IsInventoryPinnedTooltipGridCurrent(grid, inventoryPinnedTooltipGridMarker))
			{
				return;
			}
			foreach (Element element in grid.m_elements)
			{
				if (IsUnityNull((Object?)(object)element?.m_go))
				{
					continue;
				}
				UIInputHandler componentInChildren = element.m_go.GetComponentInChildren<UIInputHandler>(true);
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					InventoryPinnedTooltipInputMarker inventoryPinnedTooltipInputMarker = ((Component)componentInChildren).GetComponent<InventoryPinnedTooltipInputMarker>() ?? ((Component)componentInChildren).gameObject.AddComponent<InventoryPinnedTooltipInputMarker>();
					if (!inventoryPinnedTooltipInputMarker.HoverInitialized)
					{
						componentInChildren.m_onPointerEnter = (Action<UIInputHandler>)Delegate.Combine(componentInChildren.m_onPointerEnter, new Action<UIInputHandler>(HandleInventoryGridTooltipPointerEnter));
						componentInChildren.m_onPointerExit = (Action<UIInputHandler>)Delegate.Combine(componentInChildren.m_onPointerExit, new Action<UIInputHandler>(HandleInventoryGridTooltipPointerExit));
						inventoryPinnedTooltipInputMarker.HoverInitialized = true;
					}
				}
			}
			if ((Object)(object)inventoryPinnedTooltipGridMarker != (Object)null)
			{
				StoreInventoryPinnedTooltipGridSignature(grid, inventoryPinnedTooltipGridMarker);
			}
		}

		private static InventoryPinnedTooltipGridMarker? GetInventoryPinnedTooltipGridMarker(InventoryGrid grid)
		{
			if ((Object)(object)grid.m_gridRoot == (Object)null || IsUnityNull((Object?)(object)grid.m_gridRoot))
			{
				return null;
			}
			return ((Component)grid.m_gridRoot).GetComponent<InventoryPinnedTooltipGridMarker>() ?? ((Component)grid.m_gridRoot).gameObject.AddComponent<InventoryPinnedTooltipGridMarker>();
		}

		private static bool IsInventoryPinnedTooltipGridCurrent(InventoryGrid grid, InventoryPinnedTooltipGridMarker marker)
		{
			GetInventoryPinnedTooltipGridSignature(grid, out var elementListId, out var elementCount, out var firstElementId, out var lastElementId);
			if (marker.ElementListId == elementListId && marker.ElementCount == elementCount && marker.FirstElementId == firstElementId)
			{
				return marker.LastElementId == lastElementId;
			}
			return false;
		}

		private static void StoreInventoryPinnedTooltipGridSignature(InventoryGrid grid, InventoryPinnedTooltipGridMarker marker)
		{
			GetInventoryPinnedTooltipGridSignature(grid, out var elementListId, out var elementCount, out var firstElementId, out var lastElementId);
			marker.ElementListId = elementListId;
			marker.ElementCount = elementCount;
			marker.FirstElementId = firstElementId;
			marker.LastElementId = lastElementId;
		}

		private static void GetInventoryPinnedTooltipGridSignature(InventoryGrid grid, out int elementListId, out int elementCount, out int firstElementId, out int lastElementId)
		{
			elementListId = grid.m_elements?.GetHashCode() ?? 0;
			elementCount = grid.m_elements?.Count ?? 0;
			firstElementId = ((elementCount > 0 && !IsUnityNull((Object?)(object)grid.m_elements[0]?.m_go)) ? ((Object)grid.m_elements[0].m_go).GetInstanceID() : 0);
			lastElementId = ((elementCount > 0 && !IsUnityNull((Object?)(object)grid.m_elements[elementCount - 1]?.m_go)) ? ((Object)grid.m_elements[elementCount - 1].m_go).GetInstanceID() : 0);
		}

		private static void HandleInventoryGridTooltipPointerEnter(UIInputHandler handler)
		{
			//IL_0035: 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)
			if (!((Object)(object)handler == (Object)null) && !((Object)(object)InventoryGui.instance == (Object)null))
			{
				InventoryGui instance = InventoryGui.instance;
				if (TryGetInventoryGridItemFromHandler(instance.m_playerGrid, handler, out ItemData item, out Vector2i pos))
				{
					TooltipController.SetInventoryHover(instance.m_playerGrid, pos);
				}
				else if (TryGetInventoryGridItemFromHandler(instance.m_containerGrid, handler, out item, out pos))
				{
					TooltipController.SetInventoryHover(instance.m_containerGrid, pos);
				}
			}
		}

		private static void HandleInventoryGridTooltipPointerExit(UIInputHandler handler)
		{
			//IL_0035: 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)handler == (Object)null) && !((Object)(object)InventoryGui.instance == (Object)null))
			{
				InventoryGui instance = InventoryGui.instance;
				if (TryGetInventoryGridItemFromHandler(instance.m_playerGrid, handler, out ItemData item, out Vector2i pos) && TooltipController.IsInventoryHover(instance.m_playerGrid, pos))
				{
					ClearInventoryPinnedTooltipHover();
				}
				else if (TryGetInventoryGridItemFromHandler(instance.m_containerGrid, handler, out item, out pos) && TooltipController.IsInventoryHover(instance.m_containerGrid, pos))
				{
					ClearInventoryPinnedTooltipHover();
				}
			}
		}

		private static void ClearInventoryPinnedTooltipHover()
		{
			TooltipController.ClearInventoryHover();
		}

		private static void HandlePinnedTooltipHotkey()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (InventoryGui.IsVisible() && !((Object)(object)InventoryGui.instance == (Object)null) && !ShouldBlockGlobalHotkeys(Player.m_localPlayer) && IsPinnedTooltipKeyDown())
			{
				InventoryGui instance = InventoryGui.instance;
				InventoryGrid grid;
				Vector2i pos;
				ItemData item;
				if (TryGetCraftingPinnedTooltipTargetIndex(instance, out var index))
				{
					ToggleCraftingRecipeTooltip(instance, index);
					ResetHoverTooltipAfterPinnedTooltipToggle();
				}
				else if (TryGetInventoryPinnedTooltipHoverTarget(out grid, out pos, out item))
				{
					ToggleInventoryItemTooltip(instance, grid, pos, item);
					ResetHoverTooltipAfterPinnedTooltipToggle();
				}
			}
		}

		private static bool TryGetCraftingPinnedTooltipTargetIndex(InventoryGui gui, out int index)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			index = CraftingController.HoveredRecipeIndex;
			if (index >= 0 && TryGetCraftingRecipePair(gui, index, out var pair))
			{
				return true;
			}
			index = GetSelectedCraftingRecipeIndexSafe(gui);
			if (index < 0 || !TryGetCraftingRecipePair(gui, index, out pair))
			{
				index = -1;
				return false;
			}
			int num = FindCraftingRecipeViewIndex(index);
			int craftingRecipeGridCapacity = GetCraftingRecipeGridCapacity();
			int num2 = num - _craftingRecipePage * craftingRecipeGridCapacity;
			if (num < 0 || num2 < 0 || num2 >= craftingRecipeGridCapacity || num2 >= CraftingRecipes.GridCells.Count)
			{
				index = -1;
				return false;
			}
			CraftingRecipeGridCell craftingRecipeGridCell = CraftingRecipes.GridCells[num2];
			if ((Object)(object)craftingRecipeGridCell.Go == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGridCell.Go) || !craftingRecipeGridCell.Go.activeInHierarchy || !RectContainsScreenPoint(craftingRecipeGridCell.Rect, GetUiMousePosition()))
			{
				index = -1;
				return false;
			}
			return true;
		}

		private static void ResetHoverTooltipAfterPinnedTooltipToggle()
		{
			UITooltip current = UITooltip.m_current;
			GameObject hovered = UITooltip.m_hovered;
			HideInventoryOwnedHoverTooltips();
			UITooltip.HideTooltip();
			RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
			RestartInventoryContainerHoverTooltip(current, hovered);
		}

		private static bool IsPinnedTooltipKeyDown()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (_pinnedTooltipKey == null || !IsShortcutDownAllowingAltPair(_pinnedTooltipKey.Value))
			{
				return IsControllerHotkeyDown(_controllerPinnedTooltipButton);
			}
			return true;
		}

		private static bool TryGetInventoryPinnedTooltipHoverTarget(out InventoryGrid? grid, out Vector2i pos, out ItemData? item)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			TooltipController.TryGetInventoryHover(out grid, out pos);
			item = null;
			if ((Object)(object)grid == (Object)null || grid.m_inventory == null || pos.x < 0 || pos.y < 0 || IsOutOfBounds(grid.m_inventory, pos))
			{
				return false;
			}
			item = grid.m_inventory.GetItemAt(pos.x, pos.y);
			return item?.m_shared != null;
		}

		private static bool TryGetInventoryGridItemFromHandler(InventoryGrid? grid, UIInputHandler handler, out ItemData? item, out Vector2i pos)
		{
			//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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			item = null;
			pos = new Vector2i(-1, -1);
			if ((Object)(object)grid == (Object)null || grid.m_inventory == null || (Object)(object)handler == (Object)null)
			{
				return false;
			}
			pos = grid.GetButtonPos(((Component)handler).gameObject);
			if (pos.x < 0 || pos.y < 0 || IsOutOfBounds(grid.m_inventory, pos))
			{
				return false;
			}
			item = grid.m_inventory.GetItemAt(pos.x, pos.y);
			return item?.m_shared != null;
		}

		private static bool IsAnyAltHeld()
		{
			if (!Input.GetKey((KeyCode)308))
			{
				return Input.GetKey((KeyCode)307);
			}
			return true;
		}

		private static void BindConfigs()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Expected O, but got Unknown
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Expected O, but got Unknown
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Expected O, but got Unknown
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Expected O, but got Unknown
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Expected O, but got Unknown
			//IL_0756: Unknown result type (might be due to invalid IL or missing references)
			//IL_0766: Expected O, but got Unknown
			//IL_0793: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: Expected O, but got Unknown
			//IL_07d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e0: Expected O, but got Unknown
			//IL_09d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f5: Expected O, but got Unknown
			//IL_0a14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a28: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a38: Expected O, but got Unknown
			//IL_0a51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a75: Expected O, but got Unknown
			//IL_0a8e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab2: Expected O, but got Unknown
			//IL_0ad1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af5: Expected O, but got Unknown
			//IL_0b09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2d: Expected O, but got Unknown
			//IL_0b41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b55: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b65: Expected O, but got Unknown
			//IL_0b82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba6: Expected O, but got Unknown
			//IL_0bc3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be7: Expected O, but got Unknown
			//IL_0c04: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c28: Expected O, but got Unknown
			//IL_0c45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c69: Expected O, but got Unknown
			//IL_0c86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0caa: Expected O, but got Unknown
			//IL_0cc7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cdb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ceb: Expected O, but got Unknown
			_serverConfigLocked = OrderedConfigEntry("1 - General", "Lock Configuration", Toggle.On, "When enabled, only server admins can modify this mod's synced configuration.", 1000);
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			_progressiveRowsEnabled = ConfigEntry("2 - Progressive Slots", "Enable Progressive Rows", Toggle.On, "When enabled, extra inventory rows unlock by item discovery while the internal inventory height stays fixed.");
			_maxExtraRows = ConfigEntry("2 - Progressive Slots", "Maximum Extra Rows", 5, new ConfigDescription("Maximum extra regular inventory rows that can become usable through progression. Slot coordinates stay fixed at the mod's reserved maximum.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5), Array.Empty<object>()));
			_rowUnlockItems = new ConfigEntry<string>[5]
			{
				ConfigEntry("2 - Progressive Slots", "Extra Row 1 Items", "HardAntler", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks extra row 1."),
				ConfigEntry("2 - Progressive Slots", "Extra Row 2 Items", "CryptKey", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks extra row 2."),
				ConfigEntry("2 - Progressive Slots", "Extra Row 3 Items", "Wishbone", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks extra row 3."),
				ConfigEntry("2 - Progressive Slots", "Extra Row 4 Items", "DragonTear", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks extra row 4."),
				ConfigEntry("2 - Progressive Slots", "Extra Row 5 Items", "YagluthDrop", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks extra row 5.")
			};
			_quickSlotRows = ConfigEntry("2 - Progressive Slots", "Quick Slot Rows", 3, new ConfigDescription("Number of fixed three-slot quick slot rows reserved after equipment slots.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 3), Array.Empty<object>()));
			_quickSlotProgressionEnabled = ConfigEntry("2 - Progressive Slots", "Enable Quick Slot Progression", Toggle.On, "When enabled, quick slot row 1 is available at start and quick slot rows 2-3 unlock by item discovery.");
			_quickSlotRowUnlockItems = new ConfigEntry<string>[2]
			{
				ConfigEntry("2 - Progressive Slots", "Quick Slot Row 2 Items", "HardAntler", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks quick slot row 2."),
				ConfigEntry("2 - Progressive Slots", "Quick Slot Row 3 Items", "CryptKey", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks quick slot row 3.")
			};
			_equipmentSlotProgressionEnabled = ConfigEntry("2 - Progressive Slots", "Enable Equipment Slot Progression", Toggle.On, "When enabled, equipment slots unlock after the player discovers, carries, or has equipped an item accepted by that slot.");
			BindInventoryStateConfigInvalidation();
			_restockTargetStackLimitsConfig = ConfigEntry("3 - Restock", "Restock Target Stack Limits", "", new ConfigDescription("Client-only per-item target stack caps for Take stacks/restock into favorite slots. Keys may be prefab names, internal item names, or localized item names in the current client language, such as Stone: 10, Coins: 500. Separate entries with commas, semicolons, or new lines. Empty uses each item's normal max stack; 0 prevents restocking that item.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 700,
					CustomDrawer = DrawRestockTargetStackLimitsConfig
				}
			}), synchronizedSetting: false);
			_restockTargetStackLimitsConfig.SettingChanged += delegate
			{
				RefreshRestockTargetStackLimits();
			};
			RefreshRestockTargetStackLimits();
			_deathKeepRulesEnabled = OrderedConfigEntry("1 - General", "Enable Death Keep Rules", Toggle.On, "When enabled, items matching the YAML KeepOnDeath list stay in the player inventory instead of moving to the tombstone. When disabled, KeepOnDeath is ignored and death uses the normal tombstone behavior.", 990);
			_enableInventoryTrashPanel = OrderedConfigEntry("1 - General", "Enable Inventory Trash Panel", Toggle.On, "When enabled, shows a trash panel below the player inventory. Dropping a held player-inventory item on it opens a confirmation dialog before deleting the held amount.", 980);
			_areaQuickStackRange = OrderedConfigEntry("1 - General", "Area Quick Stack Range", 10f, new ConfigDescription("Range in meters for hover Area Quick Stack. Set to 0 to disable area quick stack. The opened-container Place stacks button only uses the current container. Built-in multi-user remote targets are also limited to 10 meters from the player.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()), 970);
			_areaRestockRange = OrderedConfigEntry("1 - General", "Area Take Stacks Range", 10f, new ConfigDescription("Range in meters for hover Area Take Stacks. Set to 0 to disable area take stacks. The opened-container Take stacks button only uses the current container. Built-in multi-user remote targets are also limited to 10 meters from the player.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()), 960);
			_enableBuiltInMultiUserChest = OrderedConfigEntry("1 - General", "Enable Multi User Chest", Toggle.On, "Enables InventorySlots' built-in multi-user access for standard player-built chests. On is the default. If the external MultiUserChest mod is installed, it takes precedence and this setting is ignored. To use the built-in implementation, remove the external mod from the server and all clients, then restart.", 950);
			_inventoryRowsDisplayMode = OrderedConfigEntry("4 - Client", "Inventory Rows Display Mode", InventoryRowsDisplayMode.Expandable, "Client-only regular inventory row display mode. Fixed always shows all unlocked regular inventory rows. Expandable restores the last locally remembered visible row count and changes it with mouse wheel while the inventory is open.", 900, synchronizedSetting: false);
			_autoFavoriteHotbarSwitchRow = OrderedConfigEntry("4 - Client", "Auto Favorite Hotbar Switch Row", Toggle.On, "When enabled, marks row 2 as favorite when the local player is loaded or spawned. Turn this Off if you want row 2 favorites to stay manually controlled. Not synced with server.", 890, synchronizedSetting: false);
			_inventorySortMode = OrderedConfigEntry("4 - Client", "Inventory Sort Mode", CraftingRecipeSortMode.GroupThenTier, "Sorting mode used by player inventory and container sort buttons. GroupThenTier sorts predefined group first, then biome/resource tier. TierThenGroup sorts biome/resource tier first, then predefined group.", 880, synchronizedSetting: false);
			_containerActionSuccessFx = OrderedConfigEntry("4 - Client", "Container Action Success FX", Toggle.On, "Enables chest-unlock success effects for hover hold area quick stack/restock. Shows VFX at up to 10 changed containers and plays the SFX once at the interacted container. Opened-container buttons do not spawn effects. Not synced with server.", 870, synchronizedSetting: false);
			_containerPreviewCloseDelay = OrderedConfigEntry("4 - Client", "Container Preview Close Delay", 0.3f, new ConfigDescription("Client-only container preview control. 0 disables the preview. Values above 0 enable it and set how many seconds, up to 1 second, the last valid container remains visible after looking away. A zero-sized placeholder inventory is never used.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), 860, synchronizedSetting: false);
			_mouseUiScrollMultiplier = OrderedConfigEntry("4 - Client", "Mouse UI Scroll Multiplier", 1f, new ConfigDescription("Global multiplier for InventorySlots mouse-wheel UI scrolling. Applies to recipe pages, recipe zoom, expandable inventory rows, and InventorySlots tooltip scrolling. Not synced with server.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()), 790, synchronizedSetting: false);
			_quickSlotHudFollowsPanel = OrderedConfigEntry("5 - Client UI", "Quick Slot HUD Follows Panel", Toggle.On, "When enabled, the quick slot HUD follows the quick slot inventory panel position. Turn this Off to keep the HUD at its last saved position while moving the panel separately. Not synced with server.", 910, synchronizedSetting: false);
			_showInventoryWheelButton = OrderedConfigEntry("5 - Client UI", "Show Inventory Wheel Hint", Toggle.On, "Show the mouse wheel hint next to the player inventory when expandable inventory rows are available. Not synced with server.", 900, synchronizedSetting: false);
			_showHotbarSwitchHint = OrderedConfigEntry("5 - Client UI", "Show Hotbar Switch Hint", Toggle.On, "Show the hotbar row switch hint next to the hotbar. Not synced with server.", 890, synchronizedSetting: false);
			_showCraftingHoverTooltip = OrderedConfigEntry("5 - Client UI", "Show Crafting Hover Tooltip", CraftingHoverTooltipMode.Full, "Controls InventorySlots recipe hover tooltips in the crafting station grid. Full shows the recipe title, item tooltip, and requirement row. TitleOnly shows only the recipe title. Off disables hover tooltips. Pinned crafting tooltips still work when this is Off. Not synced with server.", 870, synchronizedSetting: false);
			_pinnedTooltipSlots = OrderedConfigEntry("5 - Client UI", "Pinned Tooltip Slots", PinnedTooltipSlotMode.Two, "Number of comparison tooltip panels available for pinning. Inventory/container panels unfold from the inventory panel edge to the right, and crafting panels unfold from the crafting panel edge to the left.", 860, synchronizedSetting: false);
			_pinnedTooltipBackgroundAlpha = OrderedConfigEntry("5 - Client UI", "Pinned Tooltip Background Alpha", 0.9f, new ConfigDescription("Advanced alpha for pinned tooltip panel backgrounds. 0 is fully transparent and 1 is fully opaque. Not synced with server.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), 850, synchronizedSetting: false);
			_craftingHoverTooltipBackgroundAlpha = OrderedConfigEntry("5 - Client UI", "Crafting Hover Tooltip Background Alpha", 0.9f, new ConfigDescription("Alpha for InventorySlots crafting recipe hover tooltip backgrounds. 0 is fully transparent and 1 is fully opaque. Not synced with server.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), 840, synchronizedSetting: false);
			_inventoryContainerHoverTooltipBackgroundAlpha = OrderedConfigEntry("5 - Client UI", "Inventory Container Hover Tooltip Background Alpha", 0.9f, new ConfigDescription("Alpha for InventorySlots inventory and container hover tooltip backgrounds. 0 is fully transparent and 1 is fully opaque. Not synced with server.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), 830, synchronizedSetting: false);
			_playerStatBarLengthScaling = OrderedConfigEntry("5 - Client UI", "Player Stat Bar Length Scaling", PlayerStatBarLengthScaling.Logarithmic, "Controls visual length scaling for player health, food, stamina, eitr, and adrenaline bars. Linear keeps vanilla proportional length. Logarithmic keeps values up to 100 unchanged and compresses higher values with the natural logarithm. Not synced with server.", 820, synchronizedSetting: false);
			LoadInventoryPanelPositionsFromClientState();
			_pinnedTooltipSlots.SettingChanged += delegate
			{
				InvalidatePinnedTooltipUi();
			};
			_pinnedTooltipBackgroundAlpha.SettingChanged += delegate
			{
				RefreshPinnedTooltipBackgrounds();
			};
			_showCraftingHoverTooltip.SettingChanged += delegate
			{
				OnCraftingHoverTooltipConfigChanged();
			};
			_craftingHoverTooltipBackgroundAlpha.SettingChanged += delegate
			{
				RefreshCraftingHoverTooltipBackground();
			};
			_inventoryContainerHoverTooltipBackgroundAlpha.SettingChanged += delegate
			{
				RefreshInventoryContainerHoverTooltipBackground();
			};
			_enableInventoryTrashPanel.SettingChanged += delegate
			{
				OnInventoryTrashPanelConfigChanged();
			};
			_autoFavoriteHotbarSwitchRow.SettingChanged += delegate
			{
				ApplyAutoFavoriteHotbarSwitchRowToLocalPlayer();
			};
			_quickSlotHudFollowsPanel.SettingChanged += delegate
			{
				OnQuickSlotHudFollowsPanelChanged();
			};
			BindCraftingClientConfigs();
			_enableGamepadUiScroll = OrderedConfigEntry("7 - Controller Input", "Enable Gamepad UI Scroll", Toggle.On, "Allow gamepad input to emulate InventorySlots UI scrolling while gamepad input is active. Not synced with server.", 600, synchronizedSetting: false);
			_gamepadUiScrollSource = OrderedConfigEntry("7 - Controller Input", "Gamepad UI Scroll Source", GamepadUiScrollSource.RightStickY, "Gamepad input used for InventorySlots UI scrolling. RightStickY uses the right stick vertical axis; DPadVertical uses held up/down; RightStickYOrDPadVertical accepts either.", 590, synchronizedSetting: false);
			_gamepadUiScrollSensitivity = OrderedConfigEntry("7 - Controller Input", "Gamepad UI Scroll Sensitivity", 6f, new ConfigDescription("Continuous gamepad UI scroll speed multiplier for tooltip panels. Discrete UI actions such as recipe pages still move one step per repeat.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 20f), Array.Empty<object>()), 580, synchronizedSetting: false);
			_gamepadUiScrollRepeatDelay = OrderedConfigEntry("7 - Controller Input", "Gamepad UI Scroll Repeat Delay", 0.18f, new ConfigDescription("Delay in seconds between repeated gamepad scroll steps for discrete UI actions such as recipe pages and expandable inventory rows.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 0.75f), Array.Empty<object>()), 570, synchronizedSetting: false);
			_gamepadUiScrollDeadzone = OrderedConfigEntry("7 - Controller Input", "Gamepad UI Scroll Deadzone", 0.35f, new ConfigDescription("Minimum gamepad stick magnitude required before InventorySlots treats it as UI scroll input.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 0.95f), Array.Empty<object>()), 560, synchronizedSetting: false);
			_enableControllerHotkeys = OrderedConfigEntry("7 - Controller Input", "Enable Controller Hotkeys", Toggle.On, "Allow optional controller actions below to trigger InventorySlots hotkeys. Off disables an action. Not synced with server.", 500, synchronizedSetting: false);
			_controllerDPadHotkeyMode = OrderedConfigEntry("7 - Controller Input", "Controller DPad Hotkey Mode", ControllerDPadHotkeyMode.InventoryNavigation, "Controls how InventorySlots should treat DPad controller hotkeys. InventoryNavigation leaves DPad actions for vanilla inventory navigation. Hotkeys allows DPad action configs to fire. HotkeysWhileHoldingModifier only allows them while the Controller DPad Modifier Button is held.", 495, synchronizedSetting: false);
			_controllerDPadModifierButton = OrderedControllerHotkeyConfigEntry("Controller DPad Modifier Button", ControllerHotkeyAction.Off, "Controller action held when Controller DPad Hotkey Mode is HotkeysWhileHoldingModifier. Off disables the modifier gate.", 493);
			_controllerCraftingGridZoomModifierButton = OrderedControllerHotkeyConfigEntry("Controller Crafting Grid Zoom Modifier Button", ControllerHotkeyAction.JoyLStick, "Controller action held while using gamepad UI scroll over the crafting recipe grid to zoom instead of changing recipe pages. Off disables this controller modifier.", 490);
			_controllerPinnedTooltipButton = OrderedControllerHotkeyConfigEntry("Controller Pinned Tooltip Button", ControllerHotkeyAction.Off, "Controller action pressed while hovering an inventory, container, or crafting recipe item to pin or unpin its tooltip. Off disables this controller hotkey.", 480);
			_controllerFavoriteModifierButton = OrderedControllerHotkeyConfigEntry("Controller Favorite Modifier Button", ControllerHotkeyAction.Off, "Controller action held while activating an inventory cell or crafting recipe icon to toggle favorite. Off disables this controller modifier.", 470);
			_controllerClearCraftingFavoritesButton = OrderedControllerHotkeyConfigEntry("Controller Clear Crafting Favorites Button", ControllerHotkeyAction.Off, "Controller action pressed while hovering the favorite group icon to clear crafting or upgrade favorites. Off disables this controller hotkey.", 460);
			_controllerHotbarSwitchButton = OrderedControllerHotkeyConfigEntry("Controller Hotbar Switch Button", ControllerHotkeyAction.Off, "Controller action pressed to rotate unlocked regular inventory rows. Off disables this controller hotkey.", 450);
			_controllerContainerRestockButton = OrderedControllerHotkeyConfigEntry("Controller Container Restock Button", ControllerHotkeyAction.Off, "Controller action held while looking at a container to take stacks into favorite slots from that container and nearby containers. Off disables this controller hotkey.", 440);
			_controllerQuickSlotButtons = new ConfigEntry<ControllerHotkeyAction>[9]
			{
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 1 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 1. Off disables this controller hotkey.", 421),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 2 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 2. Off disables this controller hotkey.", 420),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 3 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 3. Off disables this controller hotkey.", 419),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 4 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 4. Off disables this controller hotkey.", 418),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 5 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 5. Off disables this controller hotkey.", 417),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 6 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 6. Off disables this controller hotkey.", 416),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 7 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 7. Off disables this controller hotkey.", 415),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 8 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 8. Off disables this controller hotkey.", 414),
				OrderedControllerHotkeyConfigEntry("Controller Quick Slot 9 Button", ControllerHotkeyAction.Off, "Controller action pressed to activate quick slot 9. Off disables this controller hotkey.", 413)
			};
			_hotbarSwitchKey = OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Hotbar Switch Key", new KeyboardShortcut((KeyCode)96, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey used to rotate unlocked regular inventory rows.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 780, synchronizedSetting: false);
			_containerRestockKey = OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Container Restock Key", new KeyboardShortcut((KeyCode)101, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hold this while hovering a container to take stacks into favorite slots from that container and nearby containers. Alt accepts both LeftAlt and RightAlt.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 770, synchronizedSetting: false);
			_favoriteModifierKey = OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Favorite Modifier Key", new KeyboardShortcut((KeyCode)308, Array.Empty<KeyCode>()), new ConfigDescription("Hold this and left-click a player inventory cell to toggle that favorite slot. Alt accepts both LeftAlt and RightAlt.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 760, synchronizedSetting: false);
			_pinnedTooltipKey = OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Pinned Tooltip Key", new KeyboardShortcut((KeyCode)325, Array.Empty<KeyCode>()), new ConfigDescription("Key used while hovering an inventory, container, or crafting recipe item to pin or unpin its comparison tooltip.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 750, synchronizedSetting: false);
			_quickSlotHotkeys = new ConfigEntry<KeyboardShortcut>[9]
			{
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 1 Hotkey", new KeyboardShortcut((KeyCode)122, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey used to activate quick slot 1.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 730, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 2 Hotkey", new KeyboardShortcut((KeyCode)120, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey used to activate quick slot 2.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 728, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 3 Hotkey", new KeyboardShortcut((KeyCode)99, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey used to activate quick slot 3.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 726, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 4 Hotkey", new KeyboardShortcut((KeyCode)122, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hotkey used to activate quick slot 4.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 724, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 5 Hotkey", new KeyboardShortcut((KeyCode)120, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hotkey used to activate quick slot 5.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 722, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 6 Hotkey", new KeyboardShortcut((KeyCode)99, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hotkey used to activate quick slot 6.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 720, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 7 Hotkey", new KeyboardShortcut((KeyCode)49, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hotkey used to activate quick slot 7.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 718, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 8 Hotkey", new KeyboardShortcut((KeyCode)50, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hotkey used to activate quick slot 8.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 716, synchronizedSetting: false),
				OrderedConfigEntry<KeyboardShortcut>("6 - Client Keys", "Quick Slot 9 Hotkey", new KeyboardShortcut((KeyCode)51, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), new ConfigDescription("Hotkey used to activate quick slot 9.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), 714, synchronizedSetting: false)
			};
		}

		private static void BindInventoryStateConfigInvalidation()
		{
			AddInventoryStateConfigInvalidation<Toggle>(_progressiveRowsEnabled);
			AddInventoryStateConfigInvalidation<int>(_maxExtraRows);
			ConfigEntry<string>[] rowUnlockItems = _rowUnlockItems;
			for (int i = 0; i < rowUnlockItems.Length; i++)
			{
				AddInventoryStateConfigInvalidation<string>(rowUnlockItems[i]);
			}
			AddSlotDefinitionConfigInvalidation<int>(_quickSlotRows);
			AddInventoryStateConfigInvalidation<Toggle>(_quickSlotProgressionEnabled);
			rowUnlockItems = _quickSlotRowUnlockItems;
			for (int i = 0; i < rowUnlockItems.Length; i++)
			{
				AddInventoryStateConfigInvalidation<string>(rowUnlockItems[i]);
			}
			AddInventoryStateConfigInvalidation<Toggle>(_equipmentSlotProgressionEnabled);
		}

		private static void AddInventoryStateConfigInvalidation<T>(ConfigEntry<T> entry)
		{
			entry.SettingChanged += delegate
			{
				RequestLocalInventoryState(InventoryStateEnsureReason.ConfigChanged, InventoryStateAuditLevel.FullIntegrity);
			};
		}

		private static void AddSlotDefinitionConfigInvalidation<T>(ConfigEntry<T> entry)
		{
			entry.SettingChanged += delegate
			{
				RebuildSlotDefinitions();
				RequestLocalInventoryState(InventoryStateEnsureReason.ConfigChanged, InventoryStateAuditLevel.FullIntegrity);
			};
		}

		private void Awake()
		{
			_instance = this;
			Localizer.OnLocalizationComplete += HandleLocalizationComplete;
			Localizer.Load((BaseUnityPlugin)(object)this);
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			BindConfigs();
			EnsureDefaultYamlFiles();
			InitializeJewelcraftingSlotCompatibility();
			InitializeBackpackCompatibility();
			InitializeMagicSupremacyCompatibility();
			InitializeYamlSync();
			_harmony.PatchAll();
			ApplyMyLittleUICraftingCompatibility();
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			Log.LogInfo((object)"InventorySlots loaded.");
		}

		private void Update()
		{
			ProcessYamlHotReload();
			UpdateMultiUserContainerRuntime();
			UpdateMultiUserContainerBatchRuntime();
			if (IsDedicatedServer)
			{
				return;
			}
			ApplyMyLittleUICraftingCompatibility();
			if (!InventoryGui.IsVisible())
			{
				UpdateMyLittleUICraftingObjectSuppression(InventoryGui.instance, shouldSuppress: false);
				UpdateQuickSlotInventoryPanelsWhileHidden();
			}
			Player localPlayer = Player.m_localPlayer;
			if (IsUnityNull((Object?)(object)localPlayer) || localPlayer.m_isLoading)
			{
				ClearQuickSlotsHud();
				HideQuickSlotInventoryPanels();
				ClearCustomEquipmentVisuals();
				SetHintActive(TooltipUi.HotbarSwitchHudHint, active: false);
				return;
			}
			ProcessDeferredInventoryStateEnsure(localPlayer);
			HandleHotbarSwitch(localPlayer);
			HandleQuickSlotHotkeys(localPlayer);
			HandleContainerQuickStackHotkey(localPlayer);
			HandleContainerRestockHotkey(localPlayer);
			UpdateQuickSlotsHud(localPlayer);
			UpdateHotbarSwitchHud();
			ApplyPinnedTooltipSlotLimit();
			RefreshJewelcraftingPinnedTooltips();
			HandlePinnedTooltipHotkey();
			HandleInventoryPinnedTooltipWheel();
			if (!(Time.time < _nextRefreshTime))
			{
				float num = Mathf.Max(0.25f, 1f);
				_nextRefreshTime = Time.time + num;
				RefreshItemNameTokens();
				RebuildStationInputTokens();
				RefreshJewelcraftingSlotDefinitionsIfNeeded(localPlayer);
				PrunePendingSlotActions(localPlayer);
				EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PeriodicAudit, InventoryStateAuditLevel.HeightOnly);
				float num2 = Mathf.Max(num, 5f);
				float num3 = Mathf.Max(num2, 30f);
				bool flag = _nextHeavyAuditTime <= 0f || Time.time >= _nextHeavyAuditTime;
				bool flag2 = _nextLightAuditTime <= 0f || Time.time >= _nextLightAuditTime;
				if (flag && ShouldDelayPeriodicFullIntegrityAudit())
				{
					_nextHeavyAuditTime = Mathf.Max(Time.time + num, InventorySafety.HeavyAuditDelayUntil);
					flag = false;
				}
				if (flag)
				{
					_nextHeavyAuditTime = Time.time + num3;
					_nextLightAuditTime = Time.time + num2;
					EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PeriodicAudit, InventoryStateAuditLevel.FullIntegrity);
				}
				else if (flag2)
				{
					_nextLightAuditTime = Time.time + num2;
					EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PeriodicAudit, InventoryStateAuditLevel.SlotLight);
				}
			}
		}

		private static bool ShouldDelayPeriodicFullIntegrityAudit()
		{
			return InventorySafety.HeavyAuditDelayUntil > Time.time;
		}

		private void OnDestroy()
		{
			ShutdownMultiUserContainerRuntime();
			ShutdownContainerPreview();
			Localizer.OnLocalizationComplete -= HandleLocalizationComplete;
			StopYamlWatcher();
			((BaseUnityPlugin)this).Config.Save();
		}

		private static void HandleLocalizationComplete()
		{
			_uiLocalizationVersion++;
			CraftingController.MarkSearchInputDirty();
			CraftingController.MarkGroupRailDirty();
			ClearCraftingEnglishLocalizationCaches();
			CraftingController.MarkRecipeGridLayoutDirty();
		}

		private static string NormalizeSlotId(string? id)
		{
			return InventorySlotsConfigCore.NormalizeSlotId(id);
		}

		private static string NormalizeGroupId(string? id)
		{
			return InventorySlotsConfigCore.NormalizeGroupId(id);
		}

		private static string NormalizeResourceToken(string? token)
		{
			return InventorySlotsConfigCore.NormalizeResourceToken(token);
		}

		private static string GetPlayerId(Player player)
		{
			Game instance = Game.instance;
			PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
			if (val == null)
			{
				return player.GetPlayerID().ToString();
			}
			return val.GetPlayerID().ToString();
		}

		private static bool IsUnityNull(Object? obj)
		{
			return obj == (Object)null;
		}

		private static string SafeReadBool(Func<bool> read)
		{
			try
			{
				return read() ? "true" : "false";
			}
			catch
			{
				return "<error>";
			}
		}

		private static ConfigEntry<T> ConfigEntry<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)_instance).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private static ConfigEntry<T> OrderedConfigEntry<T>(string group, string name, T value, ConfigDescription description, int order, bool synchronizedSetting = true)
		{
			return ConfigEntry(group, name, value, WithConfigurationManagerOrder(description, order), synchronizedSetting);
		}

		private static ConfigEntry<ControllerHotkeyAction> OrderedControllerHotkeyConfigEntry(string name, ControllerHotkeyAction value, string description, int order)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			ConfigDescription description2 = new ConfigDescription(description + " Use the dropdown, Presets, or Capture in Configuration Manager.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order,
					CustomDrawer = DrawControllerHotkeyConfig
				}
			});
			return ConfigEntry("7 - Controller Input", name, value, description2, synchronizedSetting: false);
		}

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

		private static ConfigDescription WithConfigurationManagerOrder(ConfigDescription description, int order)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			object[] array = description.Tags.Concat(new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			}).ToArray();
			return new ConfigDescription(description.Description, description.AcceptableValues, array);
		}

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

		private static bool QuickSlotAcceptsItem(ItemData? item)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			foreach (string item2 in _yamlConfig.QuickSlots ?? new List<string>())
			{
				if (ItemMatchesYamlReferenceToken(item, item2))
				{
					return true;
				}
			}
			return false;
		}

		private static void HandleHotbarSwitch(Player player)
		{
			//IL_0014: 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)
			if (ShouldBlockGlobalHotkeys(player) || ((_hotbarSwitchKey == null || !_hotbarSwitchKey.Value.IsKeyDown()) && !IsControllerHotkeyDown(_controllerHotbarSwitchButton)))
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			int num = Mathf.Clamp(2, 1, GetUsableRegularRows(player));
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && item.m_gridPos.y >= 0 && item.m_gridPos.y < num && !TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition _))
				{
					item.m_gridPos.y--;
					if (item.m_gridPos.y < 0)
					{
						item.m_gridPos.y = num - 1;
					}
				}
			}
			inventory.Changed();
		}

		private static void HandleQuickSlotHotkeys(Player player)
		{
			//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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (_quickSlotHotkeys == null || ShouldBlockGlobalHotkeys(player))
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			int num = Mathf.Min(GetUnlockedQuickSlotCount(player), _quickSlotHotkeys.Length);
			ConfigEntry<ControllerHotkeyAction>[] controllerQuickSlotButtons = _controllerQuickSlotButtons;
			int num2 = Mathf.Min(num, (controllerQuickSlotButtons != null) ? controllerQuickSlotButtons.Length : 0);
			for (int i = 0; i < num2; i++)
			{
				if (controllerQuickSlotButtons != null && IsControllerHotkeyDown(controllerQuickSlotButtons[i]) && TryGetQuickSlotDefinition(i, out SlotDefinition slot) && IsQuickSlotUnlocked(player, slot))
				{
					ActivateQuickSlotHotkey(player, inventory, slot);
					return;
				}
			}
			for (int j = 0; j < num; j++)
			{
				KeyboardShortcut value = _quickSlotHotkeys[j].Value;
				if (((KeyboardShortcut)(ref value)).Modifiers.Any() && IsShortcutDownAllowingAltPair(value) && TryGetQuickSlotDefinition(j, out SlotDefinition slot2) && IsQuickSlotUnlocked(player, slot2))
				{
					ActivateQuickSlotHotkey(player, inventory, slot2);
					return;
				}
			}
			for (int k = 0; k < num; k++)
			{
				KeyboardShortcut value2 = _quickSlotHotkeys[k].Value;
				if (!((KeyboardShortcut)(ref value2)).Modifiers.Any() && IsShortcutDownAllowingAltPair(value2) && TryGetQuickSlotDefinition(k, out SlotDefinition slot3) && IsQuickSlotUnlocked(player, slot3))
				{
					ActivateQuickSlotHotkey(player, inventory, slot3);
					break;
				}
			}
		}

		private static void ActivateQuickSlotHotkey(Player player, Inventory inventory, SlotDefinition slot)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
			if (itemAt != null && slot.Accepts(itemAt))
			{
				((Humanoid)player).UseItem(inventory, itemAt, false);
				inventory.Changed();
			}
		}

		private static bool TryGetRecycleNReclaimApi(out RecycleNReclaimApi? api)
		{
			return TryGetCompatApi("Azumatt.Recycle_N_Reclaim", "Recycle_N_Reclaim reclaim tab", CompatRuntime.RecycleNReclaim, RecycleNReclaimApi.TryCreate, "Recycle_N_Reclaim compatibility disabled", out api);
		}

		private static bool IsRecycleNReclaimReclaimTabActive(InventoryGui? gui = null)
		{
			if ((Object)(object)gui != (Object)null && ((Object)(object)gui.m_crafting == (Object)null || !((Component)gui.m_crafting).gameObject.activeInHierarchy))
			{
				return false;
			}
			int frameCount = Time.frameCount;
			if (_recycleNReclaimActiveFrame == frameCount)
			{
				return _recycleNReclaimActiveFrameValue;
			}
			_recycleNReclaimActiveFrame = frameCount;
			_recycleNReclaimActiveFrameValue = TryGetRecycleNReclaimApi(out RecycleNReclaimApi api) && api.IsRecycleTabActive();
			return _recycleNReclaimActiveFrameValue;
		}

		private static bool TryGetRecycleNReclaimRecyclingImpedimentCount(int originalIndex, out int count)
		{
			count = 0;
			if (TryGetRecycleNReclaimApi(out RecycleNReclaimApi api) && api.IsRecycleTabActive())
			{
				return api.TryGetRecyclingImpedimentCount(originalIndex, out count);
			}
			return false;
		}

		private static string GetRecycleNReclaimContextSignature()
		{
			if (Time.unscaledTime < _recycleNReclaimContextSignatureExpiresAt)
			{
				return _recycleNReclaimContextSignature;
			}
			_recycleNReclaimContextSignatureExpiresAt = Time.unscaledTime + 0.1f;
			_recycleNReclaimContextSignature = ((TryGetRecycleNReclaimApi(out RecycleNReclaimApi api) && api.IsRecycleTabActive()) ? api.GetContextSignature() : "");
			return _recycleNReclaimContextSignature;
		}

		private static void ClearRecycleNReclaimSignatureCaches()
		{
			_recycleNReclaimActiveFrame = -1;
			_recycleNReclaimActiveFrameValue = false;
			_recycleNReclaimContextSignatureExpiresAt = 0f;
			_recycleNReclaimContextSignature = "";
			ClearRecycleNReclaimRecipeListSignatureCache();
		}

		private static bool TryGetRecycleNReclaimSummary(int originalIndex, List<string> impediments, List<RecycleNReclaimYieldTextEntry> yields)
		{
			impediments.Clear();
			yields.Clear();
			if (TryGetRecycleNReclaimApi(out RecycleNReclaimApi api) && api.IsRecycleTabActive())
			{
				return api.TryGetReclaimSummary(originalIndex, impediments, yields);
			}
			return false;
		}

		internal static void OnRecycleNReclaimNativePanelUpdated()
		{
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null) && !IsUnityNull((Object?)(object)instance) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				ClearRecycleNReclaimSignatureCaches();
				if (TryGetRecycleNReclaimApi(out RecycleNReclaimApi api) && api != null && api.IsRecycleTabActive())
				{
					api.TryRefreshSelectedRecipeUi();
					ClearRecycleNReclaimSignatureCaches();
					UpdateCraftingPanelRedesign(instance, CraftingPanelUpdateReason.RecipeListChanged);
				}
			}
		}

		private static void ApplyRecycleNReclaimCraftingRedesignVisibility(InventoryGui gui)
		{
			SetCraftingVanillaDetailVisible(gui, visible: false);
			_craftingVanillaDetailHidden = true;
			EnsureCraftingVanillaPanelBackgroundsHidden(gui);
		}

		private static bool ShouldIncludeRecycleNReclaimRecipeInView(RecipeDataPair pair)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (((RecipeDataPair)(ref pair)).ItemData != null)
			{
				return RecipeMatchesCraftingSearch(pair);
			}
			return false;
		}

		private static int CompareRecycleNReclaimRecipeViewEntries(CraftingRecipeViewEntry a, CraftingRecipeViewEntry b)
		{
			CraftingRecipeSortMode mode = _craftingRecipeSortMode?.Value ?? CraftingRecipeSortMode.TierThenGroup;
			int num = SortKeyComparerCore.Compare(a.SortKey, b.SortKey, mode);
			if (num == 0)
			{
				return a.OriginalIndex.CompareTo(b.OriginalIndex);
			}
			return num;
		}

		private static bool TryGetRecycleNReclaimRecipeActionAvailable(int originalIndex, RecipeDataPair pair, out bool available)
		{
			available = false;
			if (!IsRecycleNReclaimReclaimTabActive(InventoryGui.instance))
			{
				return false;
			}
			available = ((originalIndex >= 0 && TryGetRecycleNReclaimRecyclingImpedimentCount(originalIndex, out var count)) ? (count == 0) : ((RecipeDataPair)(ref pair)).CanCraft);
			return true;
		}

		private static string GetRecycleNReclaimRecipeDisplayName(RecipeDataPair pair)
		{
			if (((RecipeDataPair)(ref pair)).ItemData == null)
			{
				return "";
			}
			string text = Localization.instance.Localize(((RecipeDataPair)(ref pair)).ItemData.m_shared.m_name);
			if (((RecipeDataPair)(ref pair)).ItemData.m_stack > 1 && ((RecipeDataPair)(ref pair)).ItemData.m_shared.m_maxStackSize > 1)
			{
				text += $" x{((RecipeDataPair)(ref pair)).ItemData.m_stack}";
			}
			return text;
		}

		private static string GetRecycleNReclaimRecipeTooltip(RecipeDataPair pair)
		{
			if (((RecipeDataPair)(ref pair)).ItemData == null)
			{
				return "";
			}
			int quality = Mathf.Max(1, ((RecipeDataPair)(ref pair)).ItemData.m_quality);
			int amount = Mathf.Max(1, ((RecipeDataPair)(ref pair)).ItemData.m_stack);
			return GetLocalizedStaticItemTooltip(((RecipeDataPair)(ref pair)).ItemData, quality, crafting: false, amount);
		}

		private static string GetRecycleNReclaimRecipeCellAmountText(InventoryGui gui, RecipeDataPair pair)
		{
			if (!IsRecycleNReclaimReclaimTabActive(gui) || ((RecipeDataPair)(ref pair)).ItemData == null || ((RecipeDataPair)(ref pair)).ItemData.m_stack <= 1)
			{
				return "";
			}
			return ((RecipeDataPair)(ref pair)).ItemData.m_stack.ToString();
		}

		private static string GetRecycleNReclaimRecipeListSignature(InventoryGui? gui)
		{
			//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)
			if (gui?.m_availableRecipes == null)
			{
				return "";
			}
			object availableRecipes = gui.m_availableRecipes;
			int count = gui.m_availableRecipes.Count;
			if (_recycleNReclaimRecipeListSignatureListRef == availableRecipes && _recycleNReclaimRecipeListSignatureCount == count && Time.unscaledTime < _recycleNReclaimRecipeListSignatureExpiresAt)
			{
				return _recycleNReclaimRecipeListSignature;
			}
			int num = 17;
			for (int i = 0; i < count; i++)
			{
				RecipeDataPair val = gui.m_availableRecipes[i];
				ItemData itemData = ((RecipeDataPair)(ref val)).ItemData;
				num = num * 31 + i;
				num = num * 31 + (((Object)(object)((RecipeDataPair)(ref val)).Recipe != (Object)null) ? RuntimeHelpers.GetHashCode(((RecipeDataPair)(ref val)).Recipe) : 0);
				num = num * 31 + ((itemData != null) ? RuntimeHelpers.GetHashCode(itemData) : 0);
				if (itemData != null)
				{
					num = num * 31 + CleanPrefabName(GetItemPrefabName(itemData)).GetHashCode();
					num = num * 31 + itemData.m_quality;
					num = num * 31 + itemData.m_variant;
					num = num * 31 + itemData.m_stack;
					num = num * 31 + itemData.m_gridPos.x;
					num = num * 31 + itemData.m_gridPos.y;
					num = num * 31 + (itemData.m_equipped ? 1 : 0);
				}
			}
			_recycleNReclaimRecipeListSignatureListRef = availableRecipes;
			_recycleNReclaimRecipeListSignatureCount = count;
			_recycleNReclaimRecipeListSignatureExpiresAt = Time.unscaledTime + 0.1f;
			_recycleNReclaimRecipeListSignature = $"{count}:{num}";
			return _recycleNReclaimRecipeListSignature;
		}

		private static void ClearRecycleNReclaimRecipeListSignatureCache()
		{
			_recycleNReclaimRecipeListSignatureListRef = null;
			_recycleNReclaimRecipeListSignatureCount = -1;
			_recycleNReclaimRecipeListSignatureExpiresAt = 0f;
			_recycleNReclaimRecipeListSignature = "";
		}

		private static void LayoutRecycleNReclaimBottomControls(InventoryGui gui, RectTransform grid)
		{
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_013f: 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_016f: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			if (CraftingRecipes.View.Count == 0 || FindCraftingRecipeViewIndex(gui.GetSelectedRecipeIndex(false)) < 0)
			{
				HideCraftingRedesignBottomControls(gui);
				HideRecycleNReclaimHud();
				if ((Object)(object)_craftingCountInputRect != (Object)null)
				{
					((Component)_craftingCountInputRect).gameObject.SetActive(false);
				}
				CraftingController.StoreBottomControlsSignature("hidden");
				return;
			}
			Vector2 craftingBottomControlsFixedOffset = CraftingBottomControlsFixedOffset;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(136f, 42f);
			Vector2 anchoredPosition = GetCraftingGridCenteredPosition(grid, 0, 8, val, 2) + craftingBottomControlsFixedOffset + CraftingCraftButtonFixedOffset;
			string recycleNReclaimBottomControlsLayoutSignature = GetRecycleNReclaimBottomControlsLayoutSignature(gui, grid);
			bool flag = CraftingController.NeedsBottomControlsLayout(recycleNReclaimBottomControlsLayoutSignature);
			if ((Object)(object)_craftingCountInputRect != (Object)null)
			{
				((Component)_craftingCountInputRect).gameObject.SetActive(false);
			}
			if ((Object)(object)_craftingUpgradeProgressionRect != (Object)null)
			{
				((Component)_craftingUpgradeProgressionRect).gameObject.SetActive(false);
			}
			HideCraftingSocketWarning();
			if ((Object)(object)gui.m_minStationLevelIcon != (Object)null)
			{
				((Component)gui.m_minStationLevelIcon).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_minStationLevelText != (Object)null)
			{
				((Component)gui.m_minStationLevelText).gameObject.SetActive(false);
			}
			HideCraftingRequiredStationLevelTooltip();
			if ((Object)(object)gui.m_craftButton != (Object)null && flag)
			{
				SetCraftingTopLeftRect(rect: (RectTransform)((Component)gui.m_craftButton).transform, parent: gui.m_crafting, anchoredPosition: anchoredPosition, size: val);
				SetActionButtonTextAutoSize(gui.m_craftButton);
			}
			Transform craftProgressPanel = gui.m_craftProgressPanel;
			RectTransform val2 = (RectTransform)(object)((craftProgressPanel is RectTransform) ? craftProgressPanel : null);
			if (val2 != null && flag)
			{
				SetCraftingTopLeftRect(gui.m_crafting, val2, anchoredPosition, val);
				GuiBar craftProgressBar = gui.m_craftProgressBar;
				if (craftProgressBar != null)
				{
					craftProgressBar.SetWidth(val.x);
				}
			}
			bool flag2 = TryPrepareRecycleNReclaimSelectedSummary(gui);
			LayoutRecycleNReclaimYieldIcons(gui, grid, flag2 ? RecycleNReclaimHudYields : null);
			LayoutRecycleNReclaimHud(gui, grid, flag2, RecycleNReclaimHudImpediments, RecycleNReclaimHudYields);
			HideRecycleNReclaimVanillaDetailUi(gui);
			if ((Object)(object)gui.m_craftButton != (Object)null)
			{
				ApplyCraftingActionButtonTextStateColor(gui.m_craftButton, ((Selectable)gui.m_craftButton).interactable);
			}
			CraftingController.StoreBottomControlsSignature(recycleNReclaimBottomControlsLayoutSignature);
		}

		private static string GetRecycleNReclaimBottomControlsLayoutSignature(InventoryGui gui, RectTransform grid)
		{
			//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)
			return $"{((Object)gui.m_crafting).GetInstanceID()}|{((Object)grid).GetInstanceID()}|{grid.anchoredPosition.x:0.###}|{grid.anchoredPosition.y:0.###}|{GetUnityObjectId((Object?)(object)gui.m_craftButton)}|{GetUnityObjectId((Object?)(object)gui.m_craftProgressPanel)}|{64f:0.###}|{72f:0.###}|reclaim|ownedReq={CraftingRequirements.OwnedSlots.Count}";
		}

		private static void LayoutRecycleNReclaimHud(InventoryGui gui, RectTransform grid, bool hasSummary, IReadOnlyList<string> impediments, IReadOnlyList<RecycleNReclaimYieldTextEntry> yields)
		{
			//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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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)
			string text = BuildRecycleNReclaimHudText(gui, hasSummary, impediments, yields);
			if (string.IsNullOrWhiteSpace(text))
			{
				HideRecycleNReclaimHud();
				return;
			}
			RectTransform val = EnsureRecycleNReclaimHud(gui);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)_recycleNReclaimHudText == (Object)null))
			{
				Vector2 val2 = GetCraftingGridCellPosition(grid, 0, 9) + CraftingBottomControlsFixedOffset;
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(568f, 58f);
				string text2 = $"{((Object)gui.m_crafting).GetInstanceID()}|{((Object)grid).GetInstanceID()}|{val2.x:0.###}|{val2.y:0.###}|{val3.x:0.###}|{val3.y:0.###}|{text}";
				if (!string.Equals(_recycleNReclaimHudSignature, text2, StringComparison.Ordinal))
				{
					SetCraftingTopLeftRect(gui.m_crafting, val, val2, val3);
					ConfigureRecycleNReclaimHudText(_recycleNReclaimHudText, text);
					_recycleNReclaimHudSignature = text2;
				}
				((Transform)val).SetAsLastSibling();
				((Component)val).gameObject.SetActive(true);
			}
		}

		private static RectTransform? EnsureRecycleNReclaimHud(InventoryGui gui)
		{
			//IL_0093: 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)
			//IL_0126: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: 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_00fb: Expected O, but got Unknown
			if ((Object)(object)gui.m_crafting == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_recycleNReclaimHudRect != (Object)null && !IsUnityNull((Object?)(object)_recycleNReclaimHudRect) && (Object)(object)((Transform)_recycleNReclaimHudRect).parent == (Object)(object)gui.m_crafting)
			{
				return _recycleNReclaimHudRect;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_RecycleNReclaimHud");
			_recycleNReclaimHudRect = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_recycleNReclaimHudRect == (Object)null)
			{
				_recycleNReclaimHudRect = new GameObject("InventorySlots_RecycleNReclaimHud", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			}
			((Transform)_recycleNReclaimHudRect).SetParent((Transform)(object)gui.m_crafting, false);
			Image val2 = default(Image);
			if (((Component)_recycleNReclaimHudRect).TryGetComponent<Image>(ref val2))
			{
				((Behaviour)val2).enabled = false;
				((Graphic)val2).raycastTarget = false;
			}
			Transform val3 = ((Transform)_recycleNReclaimHudRect).Find("Text");
			RectTransform val4;
			if ((Object)(object)val3 != (Object)null)
			{
				TMP_Text component = ((Component)val3).GetComponent<TMP_Text>();
				if (component != null)
				{
					val4 = (RectTransform)val3;
					_recycleNReclaimHudText = component;
					goto IL_011a;
				}
			}
			val4 = CreateTextRect("Text", (Transform)(object)_recycleNReclaimHudRect, out _recycleNReclaimHudText);
			goto IL_011a;
			IL_011a:
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(12f, 5f);
			val4.offsetMax = new Vector2(-12f, -5f);
			((Transform)val4).localScale = Vector3.one;
			((Transform)val4).localRotation = Quaternion.identity;
			SetStretchRectLayout(val4, new Vector2(12f, 5f), new Vector2(-12f, -5f));
			ConfigureRecycleNReclaimHudText(_recycleNReclaimHudText, _recycleNReclaimHudText.text);
			return _recycleNReclaimHudRect;
		}

		private static bool TryPrepareRecycleNReclaimSelectedSummary(InventoryGui gui)
		{
			int selectedCraftingRecipeIndexSafe = GetSelectedCraftingRecipeIndexSafe(gui);
			if (selectedCraftingRecipeIndexSafe < 0)
			{
				RecycleNReclaimHudImpediments.Clear();
				RecycleNReclaimHudYields.Clear();
				return false;
			}
			if (TryGetRecycleNReclaimSummary(selectedCraftingRecipeIndexSafe, RecycleNReclaimHudImpediments, RecycleNReclaimHudYields))
			{
				return true;
			}
			if (TryGetRecycleNReclaimApi(out RecycleNReclaimApi api) && api != null && api.IsRecycleTabActive())
			{
				api.TryRefreshSelectedRecipeUi();
			}
			return TryGetRecycleNReclaimSummary(selectedCraftingRecipeIndexSafe, RecycleNReclaimHudImpediments, RecycleNReclaimHudYields);
		}

		private static void LayoutRecycleNReclaimYieldIcons(InventoryGui gui, RectTransform grid, IReadOnlyList<RecycleNReclaimYieldTextEntry>? yields)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00d8: 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)
			HideCraftingVanillaRequirementSlots(gui);
			if (yields != null)
			{
				int num = 0;
				int num2 = Mathf.Max(6, CraftingRequirements.OwnedSlots.Count);
				for (int i = 0; i < num2; i++)
				{
					if (num >= yields.Count || i >= 6)
					{
						if (i < CraftingRequirements.OwnedSlots.Count)
						{
							RectTransform val = CraftingRequirements.OwnedSlots[i];
							if (val != null && !IsUnityNull((Object?)(object)val))
							{
								((Component)val).gameObject.SetActive(false);
							}
						}
						continue;
					}
					RecycleNReclaimYieldTextEntry yield = yields[num++];
					RectTransform val2 = EnsureOwnedCraftingRequirementSlot(gui, i);
					if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2))
					{
						((Component)val2).gameObject.SetActive(true);
						int column = 2 + i;
						Vector2 anchoredPosition = GetCraftingGridCellPosition(grid, column, 8) + CraftingBottomControlsFixedOffset;
						SetCraftingTopLeftRect(gui.m_crafting, val2, anchoredPosition, new Vector2(64f, 64f));
						ConfigureRecycleNReclaimYieldIcon(val2, yield);
					}
				}
			}
			else
			{
				HideOwnedCraftingRequirementSlots();
			}
		}

		private static void ConfigureRecycleNReclaimYieldIcon(RectTransform rect, RecycleNReclaimYieldTextEntry yield)
		{
			//IL_00da: 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_0106: 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_0132: 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_0204: 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_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: 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_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			CraftingRequirementUiMarker craftingRequirementUiMarker = GetCraftingRequirementUiMarker(rect);
			HideCraftingRequirementSlotBackground(craftingRequirementUiMarker);
			string text = $"reclaim-yield|{64f:0.###}|{44f:0.###}";
			bool flag = !string.Equals(craftingRequirementUiMarker.LayoutSignature, text, StringComparison.Ordinal);
			if ((Object)(object)craftingRequirementUiMarker.Name != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Name))
			{
				((Component)craftingRequirementUiMarker.Name).gameObject.SetActive(false);
			}
			if ((Object)(object)craftingRequirementUiMarker.Hitbox != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Hitbox))
			{
				((Component)craftingRequirementUiMarker.Hitbox).gameObject.SetActive(false);
			}
			if ((Object)(object)craftingRequirementUiMarker.Icon != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Icon))
			{
				RectTransform icon = craftingRequirementUiMarker.Icon;
				((Component)icon).gameObject.SetActive(true);
				if (flag)
				{
					icon.anchorMin = new Vector2(0f, 1f);
					icon.anchorMax = new Vector2(0f, 1f);
					icon.pivot = new Vector2(0f, 1f);
					icon.anchoredPosition = new Vector2(10f, -10f);
					icon.sizeDelta = new Vector2(44f, 44f);
					((Transform)icon).localScale = Vector3.one;
				}
				if ((Object)(object)craftingRequirementUiMarker.IconImage != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.IconImage))
				{
					if (yield.Item != null)
					{
						craftingRequirementUiMarker.IconImage.sprite = yield.Item.GetIcon();
					}
					((Graphic)craftingRequirementUiMarker.IconImage).color = Color.white;
					((Graphic)craftingRequirementUiMarker.IconImage).raycastTarget = false;
				}
				ConfigureSimpleTooltip(((Component)icon).gameObject, LocalizeUi(yield.Name, yield.Name), enabled: true);
			}
			if ((Object)(object)craftingRequirementUiMarker.Amount != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.Amount))
			{
				RectTransform amount = craftingRequirementUiMarker.Amount;
				((Component)amount).gameObject.SetActive(true);
				if (flag)
				{
					amount.anchorMin = new Vector2(0.5f, 0f);
					amount.anchorMax = new Vector2(0.5f, 0f);
					amount.pivot = new Vector2(0.5f, 0f);
					amount.anchoredPosition = new Vector2(0f, 4f);
					amount.sizeDelta = new Vector2(60f, 20f);
					((Transform)amount).localScale = Vector3.one;
				}
				if ((Object)(object)craftingRequirementUiMarker.AmountText != (Object)null && !IsUnityNull((Object?)(object)craftingRequirementUiMarker.AmountText))
				{
					ApplyDefaultFontAsset(craftingRequirementUiMarker.AmountText);
					craftingRequirementUiMarker.AmountText.text = yield.Amount.ToString();
					((Graphic)craftingRequirementUiMarker.AmountText).color = Color.white;
					if (flag)
					{
						craftingRequirementUiMarker.AmountText.alignment = (TextAlignmentOptions)1026;
						craftingRequirementUiMarker.AmountText.enableAutoSizing = true;
						craftingRequirementUiMarker.AmountText.fontSizeMin = 10f;
						craftingRequirementUiMarker.AmountText.fontSizeMax = 16f;
						craftingRequirementUiMarker.AmountText.textWrappingMode = (TextWrappingModes)0;
						craftingRequirementUiMarker.AmountText.overflowMode = (TextOverflowModes)0;
					}
				}
			}
			RectTransform val = EnsureCraftingRequirementHitbox(rect, craftingRequirementUiMarker);
			DisableCompetingCraftingRequirementTooltips(rect, val, craftingRequirementUiMarker);
			ConfigureSimpleTooltip(((Component)val).gameObject, LocalizeUi(yield.Name, yield.Name), enabled: true);
			craftingRequirementUiMarker.LayoutSignature = text;
		}

		private static void ConfigureRecycleNReclaimHudText(TMP_Text text, string value)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)text == (Object)null) && !IsUnityNull((Object?)(object)text))
			{
				ApplyDefaultFontAsset(text);
				text.text = value;
				((Graphic)text).color = new Color(1f, 0.86f, 0.55f, 1f);
				text.alignment = (TextAlignmentOptions)513;
				text.textWrappingMode = (TextWrappingModes)1;
				text.overflowMode = (TextOverflowModes)3;
				text.enableAutoSizing = true;
				text.fontSizeMin = 10f;
				text.fontSizeMax = 16f;
				text.maxVisibleLines = 2;
				((Graphic)text).raycastTarget = false;
			}
		}

		private static string BuildRecycleNReclaimHudText(InventoryGui gui, bool hasSummary, IReadOnlyList<string> impediments, IReadOnlyList<RecycleNReclaimYieldTextEntry> yields)
		{
			if (GetSelectedCraftingRecipeIndexSafe(gui) < 0)
			{
				return "";
			}
			string text = BuildRecycleNReclaimStatusText(gui, hasSummary ? impediments : null);
			string text2 = BuildRecycleNReclaimDetailText(gui);
			if (string.IsNullOrWhiteSpace(text2) && !HasVisibleRecycleNReclaimYieldIcons(gui))
			{
				text2 = BuildRecycleNReclaimYieldText(hasSummary ? yields : null);
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return text2;
			}
			if (string.IsNullOrWhiteSpace(text2))
			{
				return text;
			}
			return text + "\n" + text2;
		}

		private static string BuildRecycleNReclaimStatusText(InventoryGui gui, IReadOnlyList<string>? impediments)
		{
			string text = (((Object)(object)gui.m_recipeDecription != (Object)null && !IsUnityNull((Object?)(object)gui.m_recipeDecription)) ? SanitizeRecycleNReclaimHudText(gui.m_recipeDecription.text ?? "") : "");
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			if (impediments != null && impediments.Count > 0)
			{
				return LocalizeUi("$inventoryslots_reclaim_blocked", "Blocked") + ": " + JoinRecycleNReclaimTextParts(impediments.Select(SanitizeRecycleNReclaimHudText), 3);
			}
			return LocalizeUi("$azumatt_recycle_n_reclaim_requirements_fulfilled", "Recycling requirements fulfilled");
		}

		private static string BuildRecycleNReclaimDetailText(InventoryGui gui)
		{
			if (!((Object)(object)gui.m_itemCraftType != (Object)null) || IsUnityNull((Object?)(object)gui.m_itemCraftType))
			{
				return "";
			}
			return SanitizeRecycleNReclaimHudText(gui.m_itemCraftType.text ?? "");
		}

		private static string BuildRecycleNReclaimYieldText(IReadOnlyList<RecycleNReclaimYieldTextEntry>? yields)
		{
			IEnumerable<string> parts;
			if (yields == null || yields.Count <= 0)
			{
				IEnumerable<string> enumerable = Enumerable.Empty<string>();
				parts = enumerable;
			}
			else
			{
				parts = yields.Select((RecycleNReclaimYieldTextEntry entry) => $"{LocalizeUi(entry.Name, entry.Name)} x{entry.Amount}");
			}
			string text = JoinRecycleNReclaimTextParts(parts, 5);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return LocalizeUi("$azumatt_recycle_n_reclaim_tooltip_yield_header", "Yield") + ": " + text;
			}
			return "";
		}

		private static bool HasVisibleRecycleNReclaimYieldIcons(InventoryGui gui)
		{
			return CraftingRequirements.OwnedSlots.Any((RectTransform slot) => (Object)(object)slot != (Object)null && !IsUnityNull((Object?)(object)slot) && ((Component)slot).gameObject.activeSelf);
		}

		private static string JoinRecycleNReclaimTextParts(IEnumerable<string> parts, int maxParts)
		{
			List<string> list = (from part in parts
				where !string.IsNullOrWhiteSpace(part)
				select part.Trim()).ToList();
			if (list.Count == 0)
			{
				return "";
			}
			int num = Mathf.Clamp(maxParts, 1, list.Count);
			string text = string.Join("; ", list.Take(num));
			int num2 = list.Count - num;
			if (num2 <= 0)
			{
				return text;
			}
			return $"{text}; +{num2}";
		}

		private static string SanitizeRecycleNReclaimHudText(string text)
		{
			string[] value = (from line in StripRichText(text).Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
				select line.Trim() into line
				where !string.IsNullOrWhiteSpace(line)
				select line).ToArray();
			return string.Join("; ", value);
		}

		private static void HideRecycleNReclaimVanillaDetailUi(InventoryGui gui)
		{
			if ((Object)(object)gui.m_recipeIcon != (Object)null)
			{
				((Component)gui.m_recipeIcon).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_recipeName != (Object)null)
			{
				((Component)gui.m_recipeName).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_recipeDecription != (Object)null)
			{
				((Component)gui.m_recipeDecription).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_itemCraftType != (Object)null)
			{
				((Component)gui.m_itemCraftType).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_variantButton != (Object)null)
			{
				((Component)gui.m_variantButton).gameObject.SetActive(false);
			}
			if ((Object)(object)gui.m_qualityPanel != (Object)null)
			{
				((Component)gui.m_qualityPanel).gameObject.SetActive(false);
			}
		}

		private static void HideRecycleNReclaimHud()
		{
			if ((Object)(object)_recycleNReclaimHudRect != (Object)null && !IsUnityNull((Object?)(object)_recycleNReclaimHudRect))
			{
				((Component)_recycleNReclaimHudRect).gameObject.SetActive(false);
			}
			_recycleNReclaimHudSignature = "";
		}

		private static void DrawRestockTargetStackLimitsConfig(ConfigEntryBase entry)
		{
			string text = (entry.BoxedValue as string) ?? "";
			if (!string.Equals(text, _restockTargetLimitEditorLastValue, StringComparison.Ordinal))
			{
				RestockTargetLimitEditorRows.Clear();
				RestockTargetLimitEditorRows.AddRange(ParseRestockTargetLimitEditorRows(text));
				_restockTargetLimitEditorLastValue = text;
			}
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			for (int i = 0; i < RestockTargetLimitEditorRows.Count; i++)
			{
				RestockTargetLimitEditorRow restockTargetLimitEditorRow = RestockTargetLimitEditorRows[i];
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Item", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(44f) });
				string text2 = GUILayout.TextField(restockTargetLimitEditorRow.Item, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MinWidth(130f) });
				GUILayout.Label("Max", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) });
				string text3 = FilterUnsignedIntText(GUILayout.TextField(restockTargetLimitEditorRow.Amount, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(58f) }));
				bool num = GUILayout.Button("-", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(24f) });
				GUILayout.EndHorizontal();
				if (num)
				{
					RestockTargetLimitEditorRows.RemoveAt(i--);
					UpdateRestockTargetStackLimitsConfigEntry(entry);
				}
				else if (!string.Equals(text2, restockTargetLimitEditorRow.Item, StringComparison.Ordinal) || !string.Equals(text3, restockTargetLimitEditorRow.Amount, StringComparison.Ordinal))
				{
					restockTargetLimitEditorRow.Item = text2;
					restockTargetLimitEditorRow.Amount = text3;
					UpdateRestockTargetStackLimitsConfigEntry(entry);
				}
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("+", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(24f) }))
			{
				RestockTargetLimitEditorRows.Add(new RestockTargetLimitEditorRow("", ""));
				UpdateRestockTargetStackLimitsConfigEntry(entry);
			}
			GUILayout.Label("Add restock limit", Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private static List<RestockTargetLimitEditorRow> ParseRestockTargetLimitEditorRows(string raw)
		{
			List<RestockTargetLimitEditorRow> list = new List<RestockTargetLimitEditorRow>();
			string[] array = raw.Replace("\r", "\n").Split(new char[3] { '\n', ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				int num = text.IndexOf('#');
				if (num >= 0)
				{
					text = text.Substring(0, num).Trim();
				}
				if (text.Length != 0)
				{
					int num2 = FindRestockTargetLimitEditorSeparator(text);
					if (num2 <= 0)
					{
						list.Add(new RestockTargetLimitEditorRow(text, ""));
					}
					else
					{
						list.Add(new RestockTargetLimitEditorRow(text.Substring(0, num2).Trim(), FilterUnsignedIntText(text.Substring(num2 + 1).Trim())));
					}
				}
			}
			return list;
		}

		private static int FindRestockTargetLimitEditorSeparator(string entry)
		{
			int num = entry.IndexOf(':');
			int num2 = entry.IndexOf('=');
			if (num < 0)
			{
				return num2;
			}
			if (num2 < 0)
			{
				return num;
			}
			return Math.Min(num, num2);
		}

		private static string FilterUnsignedIntText(string value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return new string(value.Where(char.IsDigit).ToArray());
			}
			return "";
		}

		private static void UpdateRestockTargetStackLimitsConfigEntry(ConfigEntryBase entry)
		{
			string text = (_restockTargetLimitEditorLastValue = SerializeRestockTargetLimitEditorRows());
			if (!string.Equals((entry.BoxedValue as string) ?? "", text, StringComparison.Ordinal))
			{
				entry.BoxedValue = text;
			}
		}

		private static string SerializeRestockTargetLimitEditorRows()
		{
			return string.Join("\n", from row in RestockTargetLimitEditorRows
				where !string.IsNullOrWhiteSpace(row.Item) || !string.IsNullOrWhiteSpace(row.Amount)
				select row.Item.Trim() + ": " + row.Amount.Trim());
		}

		internal static void PrunePendingSlotActions(Player? player = null)
		{
			if (player == null)
			{
				player = Player.m_localPlayer;
			}
			if ((Object)(object)player == (Object)null)
			{
				ClearPendingSlotActions();
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				ClearPendingSlotActions();
				return;
			}
			KeyValuePair<ItemData, PendingSlotEquip>[] array = InventorySafety.PendingSlotEquips.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ItemData, PendingSlotEquip> keyValuePair = array[i];
				ItemData key = keyValuePair.Key;
				PendingSlotEquip value = keyValuePair.Value;
				if (value == null || IsPendingSlotActionExpired(value.CreatedAt) || !inventory.ContainsItem(key) || !value.Slot.Accepts(key) || (!player.IsEquipActionQueued(key) && !key.m_equipped))
				{
					InventorySafety.PendingSlotEquips.Remove(key);
				}
			}
			KeyValuePair<ItemData, PendingSlotUnequip>[] array2 = InventorySafety.PendingSlotUnequips.ToArray();
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<ItemData, PendingSlotUnequip> keyValuePair2 = array2[i];
				ItemData key2 = keyValuePair2.Key;
				PendingSlotUnequip value2 = keyValuePair2.Value;
				if (value2 == null || IsPendingSlotActionExpired(value2.CreatedAt) || !inventory.ContainsItem(key2) || !value2.SourceSlot.Accepts(key2) || !player.IsEquipActionQueued(key2))
				{
					InventorySafety.PendingSlotUnequips.Remove(key2);
				}
			}
			KeyValuePair<ItemData, float>[] array3 = InventorySafety.SlotUnequipToInventoryRequests.ToArray();
			for (int i = 0; i < array3.Length; i++)
			{
				KeyValuePair<ItemData, float> keyValuePair3 = array3[i];
				ItemData key3 = keyValuePair3.Key;
				if (IsPendingSlotActionExpired(keyValuePair3.Value) || !inventory.ContainsItem(key3) || !key3.m_equipped)
				{
					InventorySafety.SlotUnequipToInventoryRequests.Remove(key3);
				}
			}
		}

		internal static void ClearPendingSlotActions()
		{
			InventorySafety.PendingSlotEquips.Clear();
			InventorySafety.PendingSlotUnequips.Clear();
			InventorySafety.SlotUnequipToInventoryRequests.Clear();
		}

		private static bool IsPendingSlotActionExpired(float createdAt)
		{
			float num = Mathf.Max(5f, 30f);
			return Time.time - createdAt > num;
		}

		internal static void SaveSlotBackup(Player player)
		{
			if (IsUnityNull((Object?)(object)player) || player.m_isLoading || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || HasServerCharactersActive)
			{
				return;
			}
			try
			{
				InventorySlotsBackup graph = CreateSlotBackup(inventory);
				ISerializer serializer = new SerializerBuilder().Build();
				player.m_customData["InventorySlotsBackup"] = serializer.Serialize(graph);
			}
			catch (Exception arg)
			{
				Log.LogWarning((object)$"Failed to save slot backup: {arg}");
			}
		}

		internal static void TryRestoreSlotBackup(Player player)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_006c: 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)
			if (IsUnityNull((Object?)(object)player) || HasServerCharactersActive || InventorySafety.RestoringSlotBackup)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || HasAnySlotTailItem(inventory) || !TryGetSlotBackup(player, out InventorySlotsBackup backup) || backup.nrOfItems <= 0)
			{
				return;
			}
			InventorySafety.RestoringSlotBackup = true;
			try
			{
				Inventory val = new Inventory("InventorySlotsBackup", (Sprite)null, backup.width, backup.height);
				val.Load(new ZPackage(backup.inventoryBase64).ReadCompressedPackage());
				if (val.NrOfItems() == 0)
				{
					return;
				}
				int fullHeightForWidth = GetFullHeightForWidth(inventory.GetWidth());
				if (inventory.m_height < fullHeightForWidth)
				{
					inventory.m_height = fullHeightForWidth;
				}
				int num = 0;
				Vector2i target = default(Vector2i);
				foreach (ItemData item in val.GetAllItemsInGridOrder().AsEnumerable().Reverse())
				{
					((Vector2i)(ref target))..ctor(item.m_gridPos.x, item.m_gridPos.y + GetFixedRegularRows());
					if (TryRestoreBackupItem(player, inventory, item, target))
					{
						num++;
					}
				}
				if (num > 0)
				{
					inventory.Changed();
					EnsureInventoryState(player, InventoryStateEnsureReason.BackupRestore);
					Log.LogInfo((object)$"Slot backup restored: {num}/{val.NrOfItems()} item(s). Backup date {backup.date}, world {backup.worldName}.");
				}
			}
			catch (Exception arg)
			{
				Log.LogWarning((object)$"Failed to restore slot backup: {arg}");
			}
			finally
			{
				InventorySafety.RestoringSlotBackup = false;
			}
		}

		private static InventorySlotsBackup CreateSlotBackup(Inventory inventory)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_007d: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			int width = inventory.GetWidth();
			int slotTailRows = GetSlotTailRows(width);
			Inventory val = new Inventory("InventorySlotsBackup", (Sprite)null, width, slotTailRows);
			foreach (ItemData item in from item in inventory.GetAllItemsInGridOrder()
				where item != null && item.m_gridPos.y >= GetFixedRegularRows()
				select item)
			{
				ItemData val2 = item.Clone();
				val2.m_gridPos = new Vector2i(val2.m_gridPos.x, val2.m_gridPos.y - GetFixedRegularRows());
				val.m_inventory.Add(val2);
			}
			ZPackage val3 = new ZPackage();
			val.Save(val3);
			ZPackage val4 = new ZPackage();
			val4.WriteCompressed(val3);
			return new InventorySlotsBackup
			{
				version = 1,
				date = DateTime.Now.ToString("s"),
				worldName = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetWorldName() : ""),
				nrOfItems = val.NrOfItems(),
				width = width,
				height = slotTailRows,
				fixedRegularRows = GetFixedRegularRows(),
				fullHeight = GetFullHeightForWidth(width),
				inventoryBase64 = val4.GetBase64()
			};
		}

		private static bool TryGetSlotBackup(Player player, out InventorySlotsBackup? backup)
		{
			backup = null;
			if (!player.m_customData.TryGetValue("InventorySlotsBackup", out var value) || string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			try
			{
				IDeserializer deserializer = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();
				backup = deserializer.Deserialize<InventorySlotsBackup>(value);
			}
			catch (Exception arg)
			{
				Log.LogWarning((object)$"Failed to parse slot backup: {arg}");
				return false;
			}
			if (backup != null)
			{
				return !string.IsNullOrWhiteSpace(backup.inventoryBase64);
			}
			return false;
		}

		private static bool TryRestoreBackupItem(Player player, Inventory inventory, ItemData backupItem, Vector2i target)
		{
			//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)
			ItemData val = backupItem.Clone();
			if (!IsOutOfBounds(inventory, target) && TryGetEmptyUsableSpecialSlotAtCell(player, inventory, val, target, out SlotDefinition slot))
			{
				return TryEquipIntoSlot(player, inventory, val, slot);
			}
			if (TryAutoPlaceItemInSpecialSlot(player, inventory, val))
			{
				return true;
			}
			val.m_equipped = false;
			ClearItemSlot(val);
			if (TryMoveToFirstFreeRegularCell(player, inventory, val))
			{
				inventory.m_inventory.Add(val);
				return true;
			}
			Log.LogWarning((object)("Unable to restore backup item " + (val.m_shared?.m_name ?? "<unknown>") + "; no valid inventory cell was available."));
			return false;
		}

		private static bool HasAnySlotTailItem(Inventory inventory)
		{
			return inventory.m_inventory.Any((ItemData item) => item != null && item.m_gridPos.y >= GetFixedRegularRows());
		}

		private static ItemData? FindItemForSlot(Player player, Inventory inventory, SlotDefinition slot)
		{
			//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_001d: 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)
			if (slot.Kind == SlotKind.Quick)
			{
				if (!IsQuickSlotUnlocked(player, slot))
				{
					return null;
				}
				Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
				ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
				if (itemAt == null || !slot.Accepts(itemAt))
				{
					return null;
				}
				return itemAt;
			}
			ItemData builtInEquipmentSlotItem = GetBuiltInEquipmentSlotItem(player, slot);
			if (builtInEquipmentSlotItem != null && slot.Accepts(builtInEquipmentSlotItem))
			{
				return builtInEquipmentSlotItem;
			}
			return FindCustomEquippedItemForSlot(inventory, slot);
		}

		private static ItemData? GetBuiltInEquipmentSlotItem(Player player, SlotDefinition slot)
		{
			return (ItemData?)(slot.Id switch
			{
				"helmet" => ((Humanoid)player).m_helmetItem, 
				"chest" => ((Humanoid)player).m_chestItem, 
				"legs" => ((Humanoid)player).m_legItem, 
				"cape" => ((Humanoid)player).m_shoulderItem, 
				"trinket" => ((Humanoid)player).m_trinketItem, 
				"utility" => ((Humanoid)player).m_utilityItem, 
				_ => null, 
			});
		}

		private static ItemData? FindItemForSlotIncludingGridCandidate(Player player, Inventory inventory, SlotDefinition slot)
		{
			//IL_0027: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ItemData val = FindItemForSlot(player, inventory, slot);
			if (val != null || InventorySafety.SuppressSlotAutoEquip || slot.Kind != SlotKind.BuiltIn || inventory == null)
			{
				return val;
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
			if (itemAt == null || !slot.Accepts(itemAt) || !CanUseSpecialSlot(player, inventory, itemAt, slot))
			{
				return null;
			}
			return itemAt;
		}

		private static bool RestoreBuiltInSlotEquipmentState(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if ((Object)(object)player == (Object)null || inventory == null || item == null || slot == null || slot.Kind != SlotKind.BuiltIn)
			{
				return false;
			}
			bool flag = false;
			if (item.m_customData != null && (item.m_customData.ContainsKey("InventorySlotsSlotId") || item.m_customData.ContainsKey("InventorySlotsEquippedBy")))
			{
				ClearItemSlot(item);
				flag = true;
			}
			bool flag2 = false;
			try
			{
				flag2 = ((Humanoid)player).IsItemEquiped(item);
				if (!flag2)
				{
					flag2 = ((Humanoid)player).EquipItem(item, true);
					flag = flag || flag2;
				}
			}
			catch
			{
				flag2 = item.m_equipped;
			}
			if (flag2 && !item.m_equipped)
			{
				item.m_equipped = true;
				flag = true;
			}
			if (flag)
			{
				((Humanoid)player).SetupEquipment();
			}
			return flag;
		}

		private static bool RestoreSlotEquipmentState(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if ((Object)(object)player == (Object)null || inventory == null || item == null || slot == null || slot.Kind == SlotKind.Quick)
			{
				return false;
			}
			if (slot.Kind == SlotKind.BuiltIn)
			{
				return RestoreBuiltInSlotEquipmentState(player, inventory, item, slot);
			}
			bool result = false;
			if (!item.m_equipped)
			{
				item.m_equipped = true;
				result = true;
			}
			string playerId = GetPlayerId(player);
			if (item.m_customData == null || !item.m_customData.TryGetValue("InventorySlotsSlotId", out var value) || !string.Equals(value, slot.Id, StringComparison.OrdinalIgnoreCase) || !item.m_customData.TryGetValue("InventorySlotsEquippedBy", out var value2) || value2 != playerId)
			{
				MarkItemSlot(player, item, slot);
				result = true;
			}
			OnCustomEquipmentCompatEquipped(player, item);
			return result;
		}

		private static ItemData? FindCustomEquippedItemForSlot(Inventory inventory, SlotDefinition slot)
		{
			if (inventory?.m_inventory == null)
			{
				return null;
			}
			foreach (ItemData item in inventory.m_inventory)
			{
				if (item != null && IsInventorySlotsCustomEquipped(item) && item.m_customData.TryGetValue("InventorySlotsSlotId", out var value) && string.Equals(value, slot.Id, StringComparison.OrdinalIgnoreCase) && slot.Accepts(item))
				{
					return item;
				}
			}
			return null;
		}

		internal static bool TryEquipIntoSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			//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_0085: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			if (!CanUseSpecialSlot(player, inventory, item, slot))
			{
				if (IsJewelcraftingUtilityGemBlockedForSlot(item, slot))
				{
					ShowJewelcraftingCannotEquipGemMessage((Humanoid)(object)player);
				}
				return false;
			}
			if (slot.Kind == SlotKind.Quick)
			{
				return TryPlaceQuickItemIntoSlot(player, inventory, item, slot);
			}
			if (!inventory.ContainsItem(item))
			{
				inventory.m_inventory.Add(item);
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			Vector2i gridPos = item.m_gridPos;
			bool incomingOriginalPosUsed = false;
			List<SlotEquipItemSnapshot> itemSnapshots = CaptureSlotEquipItemSnapshots(player, inventory, item, slot);
			HumanoidEquipmentSnapshot equipmentSnapshot = CaptureHumanoidEquipmentSnapshot(player);
			ItemData val = FindItemForSlot(player, inventory, slot);
			if (val != null && val != item)
			{
				UnequipInventorySlotsItem(player, val);
				if (!TryRelocateSlotEquipBlockingItem(player, inventory, val, item, gridPos, ref incomingOriginalPosUsed))
				{
					return FailSlotEquip();
				}
			}
			ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
			if (itemAt != null && itemAt != item && itemAt != val)
			{
				UnequipInventorySlotsItem(player, itemAt);
				if (!TryRelocateSlotEquipBlockingItem(player, inventory, itemAt, item, gridPos, ref incomingOriginalPosUsed))
				{
					return FailSlotEquip();
				}
			}
			UnequipConflictingCustomEquipmentItems(player, inventory, item, slot);
			if (slot.Kind == SlotKind.BuiltIn)
			{
				if (!((Humanoid)player).IsItemEquiped(item) && !((Humanoid)player).EquipItem(item, true))
				{
					return FailSlotEquip();
				}
			}
			else
			{
				item.m_equipped = true;
			}
			if (slot.Kind == SlotKind.CustomEquipment)
			{
				MarkItemSlot(player, item, slot);
				OnCustomEquipmentCompatEquipped(player, item);
			}
			else
			{
				ClearItemSlot(item);
			}
			item.m_gridPos = slotGridPos;
			((Humanoid)player).SetupEquipment();
			if (slot.Kind == SlotKind.CustomEquipment)
			{
				UpdateCustomEquipmentVisuals(player);
				RefreshExternalEquipmentEffects(player);
			}
			inventory.Changed();
			return true;
			bool FailSlotEquip()
			{
				RestoreSlotEquipMutationSnapshots(player, inventory, itemSnapshots, equipmentSnapshot);
				return false;
			}
		}

		private static List<SlotEquipItemSnapshot> CaptureSlotEquipItemSnapshots(Player player, Inventory inventory, ItemData incoming, SlotDefinition slot)
		{
			//IL_0043: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			List<SlotEquipItemSnapshot> snapshots = new List<SlotEquipItemSnapshot>();
			HashSet<ItemData> seen = new HashSet<ItemData>();
			Add(incoming);
			Add(FindItemForSlot(player, inventory, slot));
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			Add(inventory.GetItemAt(slotGridPos.x, slotGridPos.y));
			ItemData[] array = inventory.m_inventory.ToArray();
			foreach (ItemData val in array)
			{
				if (val != null && val != incoming && slot.Accepts(val) && (val.m_equipped || ((Humanoid)player).IsItemEquiped(val) || val.m_customData.ContainsKey("InventorySlotsSlotId")))
				{
					Add(val);
				}
			}
			return snapshots;
			void Add(ItemData? candidate)
			{
				if (candidate != null && seen.Add(candidate))
				{
					snapshots.Add(new SlotEquipItemSnapshot(candidate, inventory.ContainsItem(candidate)));
				}
			}
		}

		private static HumanoidEquipmentSnapshot CaptureHumanoidEquipmentSnapshot(Player player)
		{
			return new HumanoidEquipmentSnapshot((Humanoid)(object)player);
		}

		private static void RestoreSlotEquipMutationSnapshots(Player player, Inventory inventory, List<SlotEquipItemSnapshot> itemSnapshots, HumanoidEquipmentSnapshot equipmentSnapshot)
		{
			//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)
			foreach (SlotEquipItemSnapshot itemSnapshot in itemSnapshots)
			{
				ItemData item = itemSnapshot.Item;
				bool flag = inventory.ContainsItem(item);
				if (itemSnapshot.WasInInventory && !flag)
				{
					inventory.m_inventory.Add(item);
				}
				else if (!itemSnapshot.WasInInventory && flag)
				{
					inventory.m_inventory.Remove(item);
				}
				item.m_gridPos = itemSnapshot.GridPos;
				item.m_equipped = itemSnapshot.Equipped;
				item.m_customData.Clear();
				foreach (KeyValuePair<string, string> customDatum in itemSnapshot.CustomData)
				{
					item.m_customData[customDatum.Key] = customDatum.Value;
				}
			}
			RestoreHumanoidEquipmentSnapshot(player, equipmentSnapshot);
		}

		private static void RestoreHumanoidEquipmentSnapshot(Player player, HumanoidEquipmentSnapshot snapshot)
		{
			((Humanoid)player).m_rightItem = snapshot.RightItem;
			((Humanoid)player).m_leftItem = snapshot.LeftItem;
			((Humanoid)player).m_chestItem = snapshot.ChestItem;
			((Humanoid)player).m_legItem = snapshot.LegItem;
			((Humanoid)player).m_ammoItem = snapshot.AmmoItem;
			((Humanoid)player).m_helmetItem = snapshot.HelmetItem;
			((Humanoid)player).m_shoulderItem = snapshot.ShoulderItem;
			((Humanoid)player).m_utilityItem = snapshot.UtilityItem;
			((Humanoid)player).m_trinketItem = snapshot.TrinketItem;
			((Humanoid)player).SetupEquipment();
			UpdateCustomEquipmentVisuals(player);
		}

		internal static bool TryRouteInventoryUseToDedicatedSlot(Player player, Inventory inventory, ItemData item, out bool handled)
		{
			handled = false;
			if (!CanRouteEquipToDedicatedSlot(player, inventory, item))
			{
				return false;
			}
			if (!TryFindDedicatedEquipmentSlot(player, inventory, item, out SlotDefinition slot))
			{
				return false;
			}
			handled = true;
			return TryEquipIntoDedicatedSlot(player, inventory, item, slot);
		}

		internal static bool TryHandleDedicatedSlotUse(Player player, Inventory inventory, ItemData item, out bool allowVanilla)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			allowVanilla = true;
			if ((Object)(object)player == (Object)null || inventory == null || item == null || (Object)(object)player != (Object)(object)Player.m_localPlayer || inventory != ((Humanoid)player).GetInventory())
			{
				return false;
			}
			if (!TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition slot) || slot.Kind == SlotKind.Quick)
			{
				return false;
			}
			if (!((Humanoid)player).IsItemEquiped(item) && !HasInventorySlotsSlot(item))
			{
				allowVanilla = IsEquipableForInventorySlotsRouting(item);
				if (!allowVanilla)
				{
					TryEquipIntoSlot(player, inventory, item, slot);
				}
				return true;
			}
			if (!TryFindFreeRegularCell(player, inventory, out var _))
			{
				allowVanilla = false;
				((Character)player).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
				return true;
			}
			if (player.IsEquipActionQueued(item))
			{
				InventorySafety.SlotUnequipToInventoryRequests.Remove(item);
			}
			else
			{
				InventorySafety.SlotUnequipToInventoryRequests[item] = Time.time;
			}
			allowVanilla = IsEquipableForInventorySlotsRouting(item);
			if (!allowVanilla)
			{
				CompleteSlotUnequipToInventory(player, item);
			}
			return true;
		}

		internal static bool HasPendingSlotUnequipRequest(ItemData item)
		{
			if (item != null)
			{
				return InventorySafety.SlotUnequipToInventoryRequests.ContainsKey(item);
			}
			return false;
		}

		internal static void SetSlotUnequipInProgress(bool inProgress)
		{
			InventorySafety.SlotUnequipInProgress = inProgress;
		}

		internal static void SetSlotAutoEquipSuppressed(bool suppressed)
		{
			InventorySafety.SuppressSlotAutoEquip = suppressed;
		}

		internal static bool TryRouteHumanoidEquipToDedicatedSlot(Humanoid humanoid, ItemData item)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)humanoid != (Object)(object)localPlayer)
			{
				return false;
			}
			Inventory inventory = humanoid.GetInventory();
			if (!CanRouteEquipToDedicatedSlot(localPlayer, inventory, item))
			{
				return false;
			}
			if (TryGetCachedDedicatedSlotRouteFailure(localPlayer, inventory, item))
			{
				return false;
			}
			if (!TryFindDedicatedEquipmentSlot(localPlayer, inventory, item, out SlotDefinition slot))
			{
				CacheDedicatedSlotRouteFailure(localPlayer, inventory, item);
				return false;
			}
			if (TryEquipIntoDedicatedSlot(localPlayer, inventory, item, slot))
			{
				return true;
			}
			return false;
		}

		private static bool CanRouteEquipToDedicatedSlot(Player player, Inventory? inventory, ItemData? item)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (InventorySafety.RoutingEquipToDedicatedSlot || (Object)(object)player == (Object)null || item == null || inventory == null || player.m_isLoading)
			{
				return false;
			}
			if ((Object)(object)player != (Object)(object)Player.m_localPlayer || inventory != ((Humanoid)player).GetInventory() || !inventory.ContainsItem(item))
			{
				return false;
			}
			if (!IsUsableRegularCell(inventory, player, item.m_gridPos))
			{
				return false;
			}
			return inventory.GetItemAt(item.m_gridPos.x, item.m_gridPos.y) == item;
		}

		private static bool TryFindDedicatedEquipmentSlot(Player player, Inventory inventory, ItemData item, out SlotDefinition? slot)
		{
			slot = SlotDefinitions.FirstOrDefault((SlotDefinition s) => s.Kind == SlotKind.CustomEquipment && CanUseSpecialSlot(player, inventory, item, s));
			if (slot != null)
			{
				return true;
			}
			slot = SlotDefinitions.FirstOrDefault((SlotDefinition s) => s.Kind == SlotKind.BuiltIn && CanUseSpecialSlot(player, inventory, item, s));
			return slot != null;
		}

		private static bool TryGetCachedDedicatedSlotRouteFailure(Player player, Inventory inventory, ItemData item)
		{
			int num = ComputeDedicatedSlotRouteFailureContext(player);
			int num2 = ComputeDedicatedSlotRouteCacheItemKey(item);
			if (InventorySafety.DedicatedSlotRouteFailureCacheInventory == inventory && InventorySafety.DedicatedSlotRouteFailureCacheVersion == InventoryDefinitions.SlotDefinitionVersion && InventorySafety.DedicatedSlotRouteFailureCacheContext == num)
			{
				return InventorySafety.DedicatedSlotRouteFailureCacheItemKey == num2;
			}
			return false;
		}

		private static void CacheDedicatedSlotRouteFailure(Player player, Inventory inventory, ItemData item)
		{
			InventorySafety.DedicatedSlotRouteFailureCacheInventory = inventory;
			InventorySafety.DedicatedSlotRouteFailureCacheVersion = InventoryDefinitions.SlotDefinitionVersion;
			InventorySafety.DedicatedSlotRouteFailureCacheContext = ComputeDedicatedSlotRouteFailureContext(player);
			InventorySafety.DedicatedSlotRouteFailureCacheItemKey = ComputeDedicatedSlotRouteCacheItemKey(item);
		}

		private static int ComputeDedicatedSlotRouteFailureContext(Player player)
		{
			return (((17 * 31 + StringComparer.Ordinal.GetHashCode(GetPlayerId(player))) * 31 + InventoryDefinitions.SlotDefinitionVersion) * 31 + GetKnownMaterialHash(player)) * 31 + (ObjectDB.instance?.m_items?.Count ?? (-1));
		}

		private static int ComputeDedicatedSlotRouteCacheItemKey(ItemData item)
		{
			//IL_0016: 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)
			int num = ComputeCanAddItemCacheItemKey(item) * 31;
			SharedData shared = item.m_shared;
			int num2 = (num + ((shared != null) ? ((int)shared.m_itemType) : 0)) * 31;
			SharedData shared2 = item.m_shared;
			return ((num2 + ((shared2 != null) ? ((int)shared2.m_skillType) : 0)) * 31 + item.m_variant) * 31 + GetItemCustomDataOrderIndependentHash(item);
		}

		internal static bool TryCompletePendingSlotEquip(Humanoid humanoid, ItemData item, out bool result)
		{
			result = false;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)humanoid != (Object)(object)localPlayer || item == null || !InventorySafety.PendingSlotEquips.TryGetValue(item, out PendingSlotEquip value))
			{
				return false;
			}
			ClearSlotActionState(item);
			Inventory inventory = humanoid.GetInventory();
			if (inventory == null || !inventory.ContainsItem(item) || !value.Slot.Accepts(item))
			{
				return true;
			}
			result = TryEquipIntoDedicatedSlot(localPlayer, inventory, item, value.Slot);
			if (!result)
			{
				((Character)localPlayer).Message((MessageType)2, "$msg_cantuse", 0, (Sprite)null);
			}
			return true;
		}

		private static bool TryEquipIntoDedicatedSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			InventorySafety.RoutingEquipToDedicatedSlot = true;
			try
			{
				return TryEquipIntoSlot(player, inventory, item, slot);
			}
			finally
			{
				InventorySafety.RoutingEquipToDedicatedSlot = false;
			}
		}

		private static bool TryPlaceQuickItemIntoSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (!IsQuickSlotUnlocked(player, slot))
			{
				return false;
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory, slot);
			ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
			if (itemAt != null && itemAt != item && !TryRelocateBlockingItem(player, inventory, itemAt, item))
			{
				return false;
			}
			if (((Humanoid)player).IsItemEquiped(item))
			{
				((Humanoid)player).UnequipItem(item, true);
			}
			bool flag = false;
			if (IsInventorySlotsCustomEquipped(item))
			{
				OnCustomEquipmentCompatUnequipping(player, item);
				item.m_equipped = false;
				ClearItemSlot(item);
				((Humanoid)player).SetupEquipment();
				flag = true;
			}
			ClearItemSlot(item);
			item.m_gridPos = slotGridPos;
			if (!inventory.ContainsItem(item))
			{
				inventory.m_inventory.Add(item);
			}
			inventory.Changed();
			if (flag)
			{
				RefreshExternalEquipmentEffects(player);
			}
			return true;
		}

		internal static void UnequipInventorySlotsItem(Player player, ItemData item)
		{
			if (item != null)
			{
				if (((Humanoid)player).IsItemEquiped(item) && !IsInventorySlotsCustomEquipped(item))
				{
					((Humanoid)player).UnequipItem(item, true);
				}
				bool flag = false;
				if (IsInventorySlotsCustomEquipped(item))
				{
					OnCustomEquipmentCompatUnequipping(player, item);
					item.m_equipped = false;
					ClearItemSlot(item);
					((Humanoid)player).SetupEquipment();
					UpdateCustomEquipmentVisuals(player);
					flag = true;
				}
				if (flag | ForceClearEquipmentReference(player, item))
				{
					RefreshExternalEquipmentEffects(player);
				}
			}
		}

		private static void UnequipConflictingCustomEquipmentItems(Player player, Inventory inventory, ItemData incoming, SlotDefinition slot)
		{
			if ((Object)(object)player == (Object)null || inventory == null || incoming == null || slot.Kind != SlotKind.CustomEquipment)
			{
				return;
			}
			ItemData[] array = inventory.m_inventory.ToArray();
			foreach (ItemData val in array)
			{
				if (val != null && val != incoming && slot.Accepts(val))
				{
					string value;
					bool flag = val.m_customData.TryGetValue("InventorySlotsSlotId", out value) && string.Equals(value, slot.Id, StringComparison.OrdinalIgnoreCase);
					if (val.m_equipped || ((Humanoid)player).IsItemEquiped(val) || flag)
					{
						UnequipInventorySlotsItem(player, val);
					}
				}
			}
		}

		internal static void UnequipCustomEquipmentForDeathDrop(Player player)
		{
			if (!IsUnityNull((Object?)(object)player) && !player.m_isLoading && ((Humanoid)player).GetInventory() != null)
			{
				bool flag = false;
				ItemData[] array = GetCustomEquippedItems(player).ToArray();
				foreach (ItemData val in array)
				{
					OnCustomEquipmentCompatUnequipping(player, val);
					val.m_equipped = false;
					ClearItemSlot(val);
					flag = true;
				}
				if (flag)
				{
					UpdateCustomEquipmentVisuals(player);
					RefreshExternalEquipmentEffects(player);
				}
			}
		}

		internal static bool TryHandleRegularItemDragIntoEquipmentSlot(InventoryGui gui, InventoryGrid targetGrid, Vector2i pos, Modifier mod)
		{
			//IL_0021: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)gui == (Object)null || (Object)(object)targetGrid == (Object)null || (int)mod != 0 || (Object)(object)gui.m_dragGo == (Object)null || gui.m_dragItem == null || gui.m_dragInventory == null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null || gui.m_dragInventory != inventory || targetGrid.GetInventory() != inventory || !inventory.ContainsItem(gui.m_dragItem))
			{
				return false;
			}
			ItemData dragItem = gui.m_dragItem;
			if (!TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot) || slot.Kind == SlotKind.Quick)
			{
				return false;
			}
			if (IsJewelcraftingUtilityGemBlockedForSlot(dragItem, slot))
			{
				ShowJewelcraftingCannotEquipGemMessage((Humanoid)(object)localPlayer);
				gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
				gui.UpdateCraftingPanel(false);
				return true;
			}
			if (!slot.Accepts(dragItem))
			{
				return false;
			}
			if (!IsUsableRegularCell(inventory, localPlayer, dragItem.m_gridPos) || inventory.GetItemAt(dragItem.m_gridPos.x, dragItem.m_gridPos.y) != dragItem)
			{
				return false;
			}
			if (!TryQueueSlotEquip(localPlayer, inventory, dragItem, slot))
			{
				((Character)localPlayer).Message((MessageType)2, "$msg_cantuse", 0, (Sprite)null);
			}
			gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
			gui.UpdateCraftingPanel(false);
			return true;
		}

		internal static void TryPinInventoryItemTooltipFromSelection(InventoryGui gui, InventoryGrid grid, Vector2i pos, Modifier mod)
		{
		}

		private static bool TryQueueSlotEquip(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if ((Object)(object)player == (Object)null || inventory == null || item == null || slot == null || slot.Kind == SlotKind.Quick || !CanUseSpecialSlot(player, inventory, item, slot))
			{
				return false;
			}
			ClearSlotActionState(item);
			InventorySafety.PendingSlotEquips[item] = new PendingSlotEquip(slot, Time.time);
			((Humanoid)player).RemoveEquipAction(item);
			if (IsEquipableForInventorySlotsRouting(item) && item.m_shared.m_equipDuration > 0f)
			{
				player.QueueEquipAction(item);
			}
			else if (!((Humanoid)player).EquipItem(item, true))
			{
				ClearSlotActionState(item);
				return false;
			}
			return true;
		}

		private static bool IsEquipableForInventorySlotsRouting(ItemData? item)
		{
			if (item != null)
			{
				return item.IsEquipable();
			}
			return false;
		}

		internal static bool TryPrepareSlotItemForExternalRemoval(Player player, Inventory inventory, ItemData item, out SlotDefinition? slot)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			slot = null;
			if (!((Object)(object)player == (Object)null) && inventory != null && item != null && inventory.ContainsItem(item))
			{
				SharedData shared = item.m_shared;
				if (shared == null || !shared.m_questItem)
				{
					SlotDefinition slot2;
					bool num = TryGetSlotAtGridPos(inventory, item.m_gridPos, out slot2) && slot2.Kind != SlotKind.Quick;
					bool flag = IsInventorySlotsCustomEquipped(item);
					if (!num && !flag)
					{
						return false;
					}
					slot = slot2 ?? GetSlotFromItemMarker(item);
					if (slot == null || slot.Kind == SlotKind.Quick)
					{
						return false;
					}
					InventorySafety.SlotUnequipToInventoryRequests.Remove(item);
					UnequipInventorySlotsItem(player, item);
					return true;
				}
			}
			return false;
		}

		private static bool TryGetEquipmentSlotForItem(Player player, Inventory inventory, ItemData item, out SlotDefinition? slot)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			slot = null;
			if ((Object)(object)player == (Object)null || inventory == null || item == null || !inventory.ContainsItem(item))
			{
				return false;
			}
			SlotDefinition slot2;
			bool num = TryGetSlotAtGridPos(inventory, item.m_gridPos, out slot2) && slot2.Kind != SlotKind.Quick;
			bool flag = IsInventorySlotsCustomEquipped(item);
			if (!num && !flag)
			{
				return false;
			}
			slot = slot2 ?? GetSlotFromItemMarker(item);
			if (slot != null && slot.Kind != SlotKind.Quick)
			{
				return CanUseSpecialSlot(player, inventory, item, slot);
			}
			return false;
		}

		internal static bool TryHandleSlotItemDragOut(InventoryGui gui, InventoryGrid targetGrid, Vector2i pos, Modifier mod)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)gui == (Object)null || (Object)(object)targetGrid == (Object)null || (int)mod != 0 || (Object)(object)gui.m_dragGo == (Object)null || gui.m_dragItem == null || gui.m_dragInventory == null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null || gui.m_dragInventory != inventory || !inventory.ContainsItem(gui.m_dragItem))
			{
				return false;
			}
			ItemData dragItem = gui.m_dragItem;
			if (!TryGetEquipmentSlotForItem(localPlayer, inventory, dragItem, out SlotDefinition slot))
			{
				return false;
			}
			Inventory inventory2 = targetGrid.GetInventory();
			bool flag = inventory2 == inventory;
			if (flag)
			{
				if (TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot2) && slot2.Kind != SlotKind.Quick)
				{
					gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
					gui.UpdateCraftingPanel(false);
					return true;
				}
				if (!CanUseCell(localPlayer, inventory, dragItem, pos))
				{
					gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
					gui.UpdateCraftingPanel(false);
					return true;
				}
			}
			if (!TryQueueSlotUnequip(localPlayer, inventory, dragItem, slot, (!flag) ? PendingSlotUnequipDestination.Container : PendingSlotUnequipDestination.PlayerInventory, inventory2, pos, gui.m_dragAmount))
			{
				((Character)localPlayer).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
				gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
				gui.UpdateCraftingPanel(false);
				return true;
			}
			gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
			gui.UpdateCraftingPanel(false);
			return true;
		}

		internal static bool TryHandleSlotItemDropOutside(InventoryGui gui)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)gui == (Object)null || (Object)(object)gui.m_dragGo == (Object)null || gui.m_dragItem == null || gui.m_dragInventory == null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			ItemData dragItem = gui.m_dragItem;
			if (inventory == null || gui.m_dragInventory != inventory || !inventory.ContainsItem(dragItem))
			{
				return false;
			}
			if (!TryGetEquipmentSlotForItem(localPlayer, inventory, dragItem, out SlotDefinition slot))
			{
				return false;
			}
			if (!TryQueueSlotUnequip(localPlayer, inventory, dragItem, slot, PendingSlotUnequipDestination.DropOutside, null, dragItem.m_gridPos, gui.m_dragAmount))
			{
				gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
				gui.UpdateCraftingPanel(false);
				return true;
			}
			gui.m_moveItemEffects.Create(((Component)gui).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			gui.SetupDragItem((ItemData)null, (Inventory)null, 1);
			gui.UpdateCraftingPanel(false);
			return true;
		}

		private static bool TryQueueSlotUnequip(Player player, Inventory playerInventory, ItemData item, SlotDefinition sourceSlot, PendingSlotUnequipDestination destination, Inventory? targetInventory, Vector2i targetPos, int amount)
		{
			//IL_0049: 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_0055: 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)
			if ((Object)(object)player == (Object)null || playerInventory == null || item == null || sourceSlot == null || sourceSlot.Kind == SlotKind.Quick || !playerInventory.ContainsItem(item))
			{
				return false;
			}
			amount = Mathf.Clamp(amount, 1, item.m_stack);
			if (amount < item.m_stack)
			{
				return false;
			}
			switch (destination)
			{
			case PendingSlotUnequipDestination.PlayerInventory:
			{
				if (!CanUseCell(player, playerInventory, item, targetPos))
				{
					return false;
				}
				ItemData itemAt = playerInventory.GetItemAt(targetPos.x, targetPos.y);
				if (itemAt != null && itemAt != item)
				{
					((Character)player).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
					return false;
				}
				break;
			}
			case PendingSlotUnequipDestination.Container:
				if (targetInventory == null || targetInventory == playerInventory || !targetInventory.CanAddItem(item, amount))
				{
					return false;
				}
				break;
			}
			ClearSlotActionState(item);
			InventorySafety.PendingSlotUnequips[item] = new PendingSlotUnequip(sourceSlot, destination, targetInventory, targetPos, amount, Time.time);
			((Humanoid)player).RemoveEquipAction(item);
			if (item.m_shared.m_equipDuration > 0f)
			{
				player.QueueUnequipAction(item);
			}
			else
			{
				((Humanoid)player).UnequipItem(item, true);
			}
			return true;
		}

		internal static bool TryCompletePendingSlotUnequip(Player player, ItemData item)
		{
			//IL_0090: 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)
			if ((Object)(object)player == (Object)null || item == null || !InventorySafety.PendingSlotUnequips.TryGetValue(item, out PendingSlotUnequip value))
			{
				return false;
			}
			ClearSlotActionState(item);
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || !inventory.ContainsItem(item))
			{
				return true;
			}
			bool suppressSlotAutoEquip = InventorySafety.SuppressSlotAutoEquip;
			InventorySafety.SuppressSlotAutoEquip = true;
			bool flag;
			try
			{
				OnCustomEquipmentCompatUnequipping(player, item);
				item.m_equipped = false;
				ClearItemSlot(item);
				ForceClearEquipmentReference(player, item);
				flag = value.Destination switch
				{
					PendingSlotUnequipDestination.PlayerInventory => CompletePendingSlotUnequipToInventory(player, inventory, item, value.TargetPos), 
					PendingSlotUnequipDestination.Container => CompletePendingSlotUnequipToContainer(player, inventory, item, value.TargetInventory, value.TargetPos, value.Amount), 
					PendingSlotUnequipDestination.DropOutside => CompletePendingSlotUnequipDropOutside(player, inventory, item, value.Amount), 
					_ => false, 
				};
			}
			finally
			{
				InventorySafety.SuppressSlotAutoEquip = suppressSlotAutoEquip;
			}
			if (!flag)
			{
				RestoreSlotItemAfterFailedExternalRemoval(player, inventory, item, value.SourceSlot);
				((Character)player).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
			}
			inventory.Changed();
			RefreshExternalEquipmentEffects(player);
			RequestInventoryStateEnsure(player, InventoryStateEnsureReason.SlotAction, InventoryStateAuditLevel.SlotLight);
			return true;
		}

		private static bool CompletePendingSlotUnequipToInventory(Player player, Inventory inventory, ItemData item, Vector2i targetPos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (CanUseCell(player, inventory, item, targetPos))
			{
				ItemData itemAt = inventory.GetItemAt(targetPos.x, targetPos.y);
				if (itemAt == null || itemAt == item)
				{
					item.m_gridPos = targetPos;
					return true;
				}
			}
			return TryMoveToFirstFreeRegularCell(player, inventory, item);
		}

		private static bool CompletePendingSlotUnequipToContainer(Player player, Inventory playerInventory, ItemData item, Inventory? targetInventory, Vector2i targetPos, int amount)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (targetInventory == null || targetInventory == playerInventory || !targetInventory.CanAddItem(item, amount))
			{
				return false;
			}
			return targetInventory.MoveItemToThis(playerInventory, item, amount, targetPos.x, targetPos.y);
		}

		private static bool CompletePendingSlotUnequipDropOutside(Player player, Inventory inventory, ItemData item, int amount)
		{
			InventorySafety.HandlingSlotDropOutside = true;
			try
			{
				return ((Humanoid)player).DropItem(inventory, item, amount);
			}
			finally
			{
				InventorySafety.HandlingSlotDropOutside = false;
			}
		}

		internal static void RestoreSlotItemAfterFailedExternalRemoval(Player player, Inventory inventory, ItemData item, SlotDefinition? slot)
		{
			if (!((Object)(object)player == (Object)null) && inventory != null && item != null && slot != null && inventory.ContainsItem(item) && CanUseSpecialSlot(player, inventory, item, slot))
			{
				TryEquipIntoSlot(player, inventory, item, slot);
			}
		}

		private static bool ForceClearEquipmentReference(Player player, ItemData item)
		{
			if ((Object)(object)player == (Object)null || item == null)
			{
				return false;
			}
			bool flag = false;
			if (((Humanoid)player).m_rightItem == item)
			{
				((Humanoid)player).m_rightItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_leftItem == item)
			{
				((Humanoid)player).m_leftItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_chestItem == item)
			{
				((Humanoid)player).m_chestItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_legItem == item)
			{
				((Humanoid)player).m_legItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_ammoItem == item)
			{
				((Humanoid)player).m_ammoItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_helmetItem == item)
			{
				((Humanoid)player).m_helmetItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_shoulderItem == item)
			{
				((Humanoid)player).m_shoulderItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_utilityItem == item)
			{
				((Humanoid)player).m_utilityItem = null;
				flag = true;
			}
			if (((Humanoid)player).m_trinketItem == item)
			{
				((Humanoid)player).m_trinketItem = null;
				flag = true;
			}
			if (item.m_equipped)
			{
				item.m_equipped = false;
				flag = true;
			}
			if (HasInventorySlotsSlot(item))
			{
				OnCustomEquipmentCompatUnequipping(player, item);
				ClearItemSlot(item);
				flag = true;
			}
			if (flag)
			{
				((Humanoid)player).SetupEquipment();
			}
			return flag;
		}

		private static SlotDefinition? GetSlotFromItemMarker(ItemData item)
		{
			if (item?.m_customData == null || !item.m_customData.TryGetValue("InventorySlotsSlotId", out var id))
			{
				return null;
			}
			return SlotDefinitions.FirstOrDefault((SlotDefinition slot) => string.Equals(slot.Id, id, StringComparison.OrdinalIgnoreCase));
		}

		internal static bool CompleteSlotUnequipToInventory(Player player, ItemData item)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || item == null || !InventorySafety.SlotUnequipToInventoryRequests.Remove(item))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || !inventory.ContainsItem(item))
			{
				return false;
			}
			if (!TryGetSlotAtGridPos(inventory, item.m_gridPos, out SlotDefinition slot) || slot.Kind == SlotKind.Quick)
			{
				return false;
			}
			item.m_equipped = false;
			OnCustomEquipmentCompatUnequipping(player, item);
			ClearItemSlot(item);
			if (!TryMoveToFirstFreeRegularCell(player, inventory, item))
			{
				TryEquipIntoSlot(player, inventory, item, slot);
				((Character)player).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
				return true;
			}
			((Humanoid)player).SetupEquipment();
			inventory.Changed();
			RefreshExternalEquipmentEffects(player);
			return true;
		}

		private static void MarkItemSlot(Player player, ItemData item, SlotDefinition slot)
		{
			item.m_customData["InventorySlotsSlotId"] = slot.Id;
			item.m_customData["InventorySlotsEquippedBy"] = GetPlayerId(player);
			InvalidateCustomEquipmentProjectionCache();
		}

		internal static void ClearItemSlot(ItemData item)
		{
			if (item?.m_customData != null)
			{
				item.m_customData.Remove("InventorySlotsSlotId");
				item.m_customData.Remove("InventorySlotsEquippedBy");
				InvalidateCustomEquipmentProjectionCache();
			}
		}

		internal static void ClearSlotActionState(ItemData item)
		{
			if (item != null)
			{
				InventorySafety.PendingSlotEquips.Remove(item);
				InventorySafety.PendingSlotUnequips.Remove(item);
				InventorySafety.SlotUnequipToInventoryRequests.Remove(item);
			}
		}

		internal static void ClearCustomEquipmentState(ItemData item)
		{
			if (item != null)
			{
				OnCustomEquipmentCompatUnequipping(Player.m_localPlayer, item);
				item.m_equipped = false;
				ClearItemSlot(item);
				ClearSlotActionState(item);
				RefreshExternalEquipmentEffects(Player.m_localPlayer);
			}
		}

		internal static bool HasInventorySlotsSlot(ItemData? item)
		{
			return item?.m_customData.ContainsKey("InventorySlotsSlotId") ?? false;
		}

		internal static bool IsInventorySlotsCustomEquipped(ItemData? item)
		{
			if (item != null && item.m_equipped)
			{
				return item.m_customData.ContainsKey("InventorySlotsSlotId");
			}
			return false;
		}

		private static bool CanAutoAdoptGridSlot(ItemData item, SlotDefinition slot)
		{
			string value;
			string markedSlotId = (item.m_customData.TryGetValue("InventorySlotsSlotId", out value) ? value : null);
			return InventorySlotSafetyCore.CanAutoAdoptGridSlot(IsInventorySlotsCustomEquipped(item), markedSlotId, slot.Id);
		}

		internal static bool CanAutoPlaceItemInSpecialSlot(Player player, Inventory inventory, ItemData item)
		{
			return SlotDefinitions.Any((SlotDefinition slot) => CanAutoPlaceItemInSpecialSlot(player, inventory, item, slot));
		}

		internal static bool TryAutoPlaceItemInSpecialSlot(Player player, Inventory inventory, ItemData item)
		{
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (CanAutoPlaceItemInSpecialSlot(player, inventory, item, slotDefinition) && TryEquipIntoSlot(player, inventory, item, slotDefinition))
				{
					return true;
				}
			}
			return false;
		}

		private static bool CanAutoPlaceItemInSpecialSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			if (CanUseEmptySpecialSlot(player, inventory, item, slot))
			{
				return CanAutoAdoptGridSlot(item, slot);
			}
			return false;
		}

		internal static bool ShouldAllowHumanoidUseItem(Humanoid humanoid, Inventory inventory, ItemData item)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)humanoid != (Object)(object)localPlayer)
			{
				return true;
			}
			if (TryHandleDedicatedSlotUse(localPlayer, inventory, item, out var allowVanilla))
			{
				return allowVanilla;
			}
			if (IsEquipableForInventorySlotsRouting(item))
			{
				return true;
			}
			if (item == null)
			{
				return true;
			}
			TryRouteInventoryUseToDedicatedSlot(localPlayer, inventory, item, out var handled);
			return !handled;
		}

		internal static bool TryOverrideHumanoidEquipItem(Humanoid humanoid, ItemData item, ref bool result)
		{
			if (TryBlockJewelcraftingUtilityGemEquip(humanoid, item, ref result))
			{
				return true;
			}
			if (TryCompletePendingSlotEquip(humanoid, item, out var result2))
			{
				result = result2;
				return true;
			}
			if (TryRouteHumanoidEquipToDedicatedSlot(humanoid, item))
			{
				result = true;
				return true;
			}
			return false;
		}

		internal static void OnHumanoidIsItemEquipped(Humanoid humanoid, ItemData item, ref bool result)
		{
			if (!result && (Object)(object)humanoid == (Object)(object)Player.m_localPlayer && IsInventorySlotsCustomEquipped(item))
			{
				result = true;
			}
		}

		internal static bool PrepareHumanoidUnequipItem(Humanoid humanoid, ItemData item)
		{
			Player localPlayer = Player.m_localPlayer;
			int num;
			if ((Object)(object)humanoid == (Object)(object)localPlayer && (Object)(object)localPlayer != (Object)null && item != null)
			{
				num = (HasPendingSlotUnequipRequest(item) ? 1 : 0);
				if (num != 0)
				{
					SetSlotUnequipInProgress(inProgress: true);
				}
			}
			else
			{
				num = 0;
			}
			return (byte)num != 0;
		}

		internal static void OnHumanoidUnequipItem(Humanoid humanoid, ItemData item, bool hasPendingUnequip)
		{
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)humanoid != (Object)(object)localPlayer) && !((Object)(object)localPlayer == (Object)null) && item != null && !TryCompletePendingSlotUnequip(localPlayer, item) && !CompleteSlotUnequipToInventory(localPlayer, item) && HasInventorySlotsSlot(item))
				{
					ClearCustomEquipmentState(item);
					humanoid.SetupEquipment();
				}
			}
			finally
			{
				CompleteHumanoidUnequipItem(hasPendingUnequip);
			}
		}

		internal static void CompleteHumanoidUnequipItem(bool hasPendingUnequip)
		{
			if (hasPendingUnequip)
			{
				SetSlotUnequipInProgress(inProgress: false);
			}
		}

		internal static void OnHumanoidUnequipAllItems(Humanoid humanoid)
		{
			if (!IsLocalPlayerHumanoid(humanoid, out Player player) || (Object)(object)player == (Object)null || !ClearAllCustomEquipmentState(player))
			{
				return;
			}
			bool suppressSlotAutoEquip = InventorySafety.SuppressSlotAutoEquip;
			SetSlotAutoEquipSuppressed(suppressed: true);
			try
			{
				humanoid.UpdateEquipmentStatusEffects();
				UpdateCustomEquipmentVisuals(player);
			}
			finally
			{
				SetSlotAutoEquipSuppressed(suppressSlotAutoEquip);
			}
		}

		internal static bool PreparePlayerDeathDropUnequip(Player player)
		{
			bool num = (Object)(object)player == (Object)(object)Player.m_localPlayer;
			if (num)
			{
				ClearPendingSlotActions();
				SetSlotAutoEquipSuppressed(suppressed: true);
				UnequipCustomEquipmentForDeathDrop(player);
			}
			return num;
		}

		internal static void CompletePlayerDeathDropUnequip(bool isLocalPlayer)
		{
			if (isLocalPlayer)
			{
				SetSlotAutoEquipSuppressed(suppressed: false);
			}
		}

		private static SortKey CreateCraftingRecipeSortKey(RecipeDataPair pair)
		{
			//IL_0000: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			ItemData craftingRecipeItemData = GetCraftingRecipeItemData(pair);
			string craftingRecipeBigGroupId = GetCraftingRecipeBigGroupId(pair);
			string localizedName = ((craftingRecipeItemData?.m_shared != null) ? GetLocalizedItemName(craftingRecipeItemData) : GetCraftingRecipeDisplayName(pair));
			return CreateSortKey(craftingRecipeItemData, GetCraftingRecipeResourceTier(((RecipeDataPair)(ref pair)).Recipe), craftingRecipeBigGroupId, localizedName);
		}

		private static SortKey GetInventoryItemSortKey(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return SortKey.None;
			}
			string inventoryItemBigGroupId = GetInventoryItemBigGroupId(item);
			return CreateSortKey(item, GetInventoryItemResourceTier(item), inventoryItemBigGroupId, GetLocalizedItemName(item));
		}

		private static SortKey CreateSortKey(ItemData? item, int resourceTier, string bigGroupId, string localizedName)
		{
			int itemBigGroupRank = GetItemBigGroupRank(bigGroupId);
			int itemPredefinedGroupRank = GetItemPredefinedGroupRank(item, bigGroupId, itemBigGroupRank);
			return new SortKey(resourceTier, itemPredefinedGroupRank, itemBigGroupRank, GetCraftingEquipmentSetKey(item), GetCraftingEquipmentSlotOrder(item), localizedName);
		}

		private static void RebuildStationInputTokens(bool force = false)
		{
			ObjectDB instance = ObjectDB.instance;
			int num = ((!IsUnityNull((Object?)(object)instance) && instance.m_items != null) ? instance.m_items.Count : (-1));
			int num2 = ((!IsUnityNull((Object?)(object)instance) && instance.m_recipes != null) ? instance.m_recipes.Count : (-1));
			int num3 = ((!IsUnityNull((Object?)(object)ZNetScene.instance) && ZNetScene.instance.m_prefabs != null) ? ZNetScene.instance.m_prefabs.Count : (-1));
			if (IsUnityNull((Object?)(object)ZNetScene.instance) || ZNetScene.instance.m_prefabs == null)
			{
				bool num4 = CookingStationInputTokens.Count > 0 || CraftingRecipeFoodInputTokens.Count > 0 || CookingStationFoodInputTokens.Count > 0 || FermenterInputTokens.Count > 0 || FermenterOutputTokens.Count > 0 || FermenterFoodInputTokens.Count > 0;
				StationTokenCookingStations.Clear();
				StationTokenFermenters.Clear();
				CookingStationInputTokens.Clear();
				CraftingRecipeFoodInputTokens.Clear();
				CookingStationFoodInputTokens.Clear();
				FermenterInputTokens.Clear();
				FermenterOutputTokens.Clear();
				FermenterFoodInputTokens.Clear();
				InventoryDefinitions.StationInputTokensInitialized = false;
				InventoryDefinitions.CachedStationInputObjectDbItemCount = num;
				InventoryDefinitions.CachedStationInputPrefabCount = num3;
				InventoryDefinitions.CachedStationInputRecipeCount = num2;
				if (num4)
				{
					ClearCraftingRecipeCaches();
				}
			}
			else if (force || !InventoryDefinitions.StationInputTokensInitialized || InventoryDefinitions.CachedStationInputObjectDbItemCount != num || InventoryDefinitions.CachedStationInputPrefabCount != num3 || InventoryDefinitions.CachedStationInputRecipeCount != num2)
			{
				RebuildStationComponentCache();
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet3 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet4 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet5 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet6 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				CollectStationConversionTokens(hashSet, hashSet2, hashSet3, hashSet4, hashSet5, hashSet6);
				bool num5 = !CookingStationInputTokens.SetEquals(hashSet) || !CraftingRecipeFoodInputTokens.SetEquals(hashSet2) || !CookingStationFoodInputTokens.SetEquals(hashSet3) || !FermenterInputTokens.SetEquals(hashSet4) || !FermenterOutputTokens.SetEquals(hashSet5) || !FermenterFoodInputTokens.SetEquals(hashSet6);
				InventoryDefinitions.CachedStationInputObjectDbItemCount = num;
				InventoryDefinitions.CachedStationInputPrefabCount = num3;
				InventoryDefinitions.CachedStationInputRecipeCount = num2;
				InventoryDefinitions.StationInputTokensInitialized = true;
				if (num5)
				{
					CookingStationInputTokens.Clear();
					CookingStationInputTokens.UnionWith(hashSet);
					CraftingRecipeFoodInputTokens.Clear();
					CraftingRecipeFoodInputTokens.UnionWith(hashSet2);
					CookingStationFoodInputTokens.Clear();
					CookingStationFoodInputTokens.UnionWith(hashSet3);
					FermenterInputTokens.Clear();
					FermenterInputTokens.UnionWith(hashSet4);
					FermenterOutputTokens.Clear();
					FermenterOutputTokens.UnionWith(hashSet5);
					FermenterFoodInputTokens.Clear();
					FermenterFoodInputTokens.UnionWith(hashSet6);
					ClearCraftingRecipeCaches();
				}
			}
		}

		private static void RebuildStationComponentCache()
		{
			StationTokenCookingStations.Clear();
			StationTokenFermenters.Clear();
			if (IsUnityNull((Object?)(object)ZNetScene.instance) || ZNetScene.instance.m_prefabs == null)
			{
				return;
			}
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				if (IsUnityNull((Object?)(object)prefab))
				{
					continue;
				}
				CookingStation[] componentsInChildren = prefab.GetComponentsInChildren<CookingStation>(true);
				foreach (CookingStation val in componentsInChildren)
				{
					if (!IsUnityNull((Object?)(object)val))
					{
						StationTokenCookingStations.Add(val);
					}
				}
				Fermenter[] componentsInChildren2 = prefab.GetComponentsInChildren<Fermenter>(true);
				foreach (Fermenter val2 in componentsInChildren2)
				{
					if (!IsUnityNull((Object?)(object)val2))
					{
						StationTokenFermenters.Add(val2);
					}
				}
			}
		}

		private static void CollectStationConversionTokens(HashSet<string> cookingStationInputTokens, HashSet<string> craftingRecipeFoodInputTokens, HashSet<string> cookingStationFoodInputTokens, HashSet<string> fermenterInputTokens, HashSet<string> fermenterOutputTokens, HashSet<string> fermenterFoodInputTokens)
		{
			CollectCraftingRecipeFoodInputTokens(craftingRecipeFoodInputTokens);
			for (int num = StationTokenCookingStations.Count - 1; num >= 0; num--)
			{
				CookingStation val = StationTokenCookingStations[num];
				if (IsUnityNull((Object?)(object)val))
				{
					StationTokenCookingStations.RemoveAt(num);
				}
				else
				{
					AddStationConversionItemsWithFoodInputs((Component?)(object)val, cookingStationInputTokens, null, cookingStationFoodInputTokens);
				}
			}
			for (int num2 = StationTokenFermenters.Count - 1; num2 >= 0; num2--)
			{
				Fermenter val2 = StationTokenFermenters[num2];
				if (IsUnityNull((Object?)(object)val2))
				{
					StationTokenFermenters.RemoveAt(num2);
				}
				else
				{
					AddStationConversionItemsWithFoodInputs((Component?)(object)val2, fermenterInputTokens, fermenterOutputTokens, fermenterFoodInputTokens);
				}
			}
		}

		private static void CollectCraftingRecipeFoodInputTokens(HashSet<string> foodInputTokens)
		{
			ObjectDB instance = ObjectDB.instance;
			if (IsUnityNull((Object?)(object)instance) || instance.m_recipes == null)
			{
				return;
			}
			foreach (Recipe recipe in instance.m_recipes)
			{
				if (!((Object)(object)recipe == (Object)null) && recipe.m_resources != null && IsFoodStatOutput(recipe.m_item))
				{
					Requirement[] resources = recipe.m_resources;
					foreach (Requirement val in resources)
					{
						AddItemIdentityTokens(foodInputTokens, val.m_resItem);
					}
				}
			}
		}

		private static void AddStationConversionItemsWithFoodInputs(Component? station, HashSet<string>? inputTokens, HashSet<string>? outputTokens, HashSet<string>? foodInputTokens)
		{
			if (IsUnityNull((Object?)(object)station))
			{
				return;
			}
			FieldInfo conversionField = GetConversionField(((object)station).GetType(), "m_conversion", "conversion", "conversions", "m_conversions");
			if (conversionField == null)
			{
				return;
			}
			object value;
			try
			{
				value = conversionField.GetValue(station);
			}
			catch
			{
				return;
			}
			if (!(value is IEnumerable enumerable) || value is string)
			{
				return;
			}
			foreach (object item in enumerable)
			{
				try
				{
					ItemDrop stationConversionItemDrop = GetStationConversionItemDrop(item, "m_from", "from", "m_input", "input");
					ItemDrop stationConversionItemDrop2 = GetStationConversionItemDrop(item, "m_to", "to", "m_output", "output", "m_result", "result");
					AddItemIdentityTokens(inputTokens, stationConversionItemDrop);
					AddItemIdentityTokens(outputTokens, stationConversionItemDrop2);
					if (foodInputTokens != null && IsFoodStatOutput(stationConversionItemDrop2))
					{
						AddItemIdentityTokens(foodInputTokens, stationConversionItemDrop);
					}
				}
				catch
				{
				}
			}
		}

		private static ItemDrop? GetStationConversionItemDrop(object? conversion, params string[] fieldNames)
		{
			if (conversion == null)
			{
				return null;
			}
			FieldInfo conversionField = GetConversionField(conversion.GetType(), fieldNames);
			if (conversionField == null)
			{
				return null;
			}
			return TryGetItemDrop(conversionField.GetValue(conversion));
		}

		private static bool IsFoodStatOutput(ItemDrop? itemDrop)
		{
			ItemData val = itemDrop?.m_itemData;
			if (val?.m_shared != null)
			{
				if (!(GetFoodHealth(val) > 0f) && !(GetFoodStamina(val) > 0f))
				{
					return GetFoodEitr(val) > 0f;
				}
				return true;
			}
			return false;
		}

		private static FieldInfo? GetConversionField(Type type, params string[] names)
		{
			foreach (string name in names)
			{
				FieldInfo field = type.GetField(name, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field;
				}
			}
			return null;
		}

		private static ItemDrop? TryGetItemDrop(object? value)
		{
			ItemDrop val = (ItemDrop)((value is ItemDrop) ? value : null);
			if (val == null)
			{
				GameObject val2 = (GameObject)((value is GameObject) ? value : null);
				if (val2 == null)
				{
					Component val3 = (Component)((value is Component) ? value : null);
					if (val3 != null)
					{
						return val3.GetComponent<ItemDrop>();
					}
					return null;
				}
				return val2.GetComponent<ItemDrop>();
			}
			return val;
		}

		private static void AddItemIdentityTokens(HashSet<string>? targetTokens, ItemDrop? itemDrop)
		{
			if (targetTokens != null && !((Object)(object)itemDrop == (Object)null) && itemDrop.m_itemData?.m_shared != null)
			{
				AddStationInputToken(targetTokens, ((Object)itemDrop).name);
				AddStationInputToken(targetTokens, ((Object)(object)itemDrop.m_itemData.m_dropPrefab != (Object)null) ? ((Object)itemDrop.m_itemData.m_dropPrefab).name : "");
				AddExactStationInputToken(targetTokens, itemDrop.m_itemData.m_shared.m_name);
			}
		}

		private static void AddStationInputToken(HashSet<string> targetTokens, string? token)
		{
			if (!string.IsNullOrWhiteSpace(token))
			{
				string text = CleanPrefabName(token.Trim());
				if (!string.IsNullOrWhiteSpace(text))
				{
					targetTokens.Add(text);
				}
				string text2 = StripLocalizationToken(text);
				if (!string.IsNullOrWhiteSpace(text2))
				{
					targetTokens.Add(text2);
				}
				string text3 = NormalizeResourceToken(text);
				if (!string.IsNullOrWhiteSpace(text3))
				{
					targetTokens.Add(text3);
				}
			}
		}

		private static void AddExactStationInputToken(HashSet<string> targetTokens, string? token)
		{
			if (!string.IsNullOrWhiteSpace(token))
			{
				string text = CleanPrefabName(token.Trim());
				if (!string.IsNullOrWhiteSpace(text))
				{
					targetTokens.Add(text);
				}
			}
		}

		internal static void EnsureTombstoneContainerHeight(Container? container, bool reloadInventory, bool persistHeight)
		{
			if (!IsUnityNull((Object?)(object)container) && IsTombstoneContainer(container))
			{
				Inventory inventory = container.GetInventory();
				int num = GetFullHeightForWidth(container.m_width);
				if (inventory != null)
				{
					num = GetInventoryPreservationHeight(inventory, num);
				}
				bool flag = false;
				if (container.m_height < num)
				{
					container.m_height = num;
					flag = true;
				}
				if (inventory != null && inventory.m_height < num)
				{
					inventory.m_height = num;
					flag = true;
				}
				if (flag && reloadInventory)
				{
					container.m_lastRevision = 0u;
					container.m_lastDataString = "";
					container.Load();
				}
				if (persistHeight)
				{
					PersistContainerHeight(container, num);
				}
			}
		}

		internal static bool TombstoneCanFitInventory(TombStone tombstone, Player player)
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return true;
			}
			Inventory val = (((Object)(object)tombstone.m_container != (Object)null) ? tombstone.m_container.GetInventory() : null);
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (val == null || inventory == null)
			{
				return true;
			}
			EnsureInventoryState(player, InventoryStateEnsureReason.Tombstone);
			if (InventoryLimits.Count > 0)
			{
				EnsureInventoryLimitCountCache(inventory);
				foreach (KeyValuePair<string, int> inventoryLimit in InventoryLimits)
				{
					if (inventoryLimit.Value < 0)
					{
						continue;
					}
					long num = 0L;
					foreach (ItemData allItem in val.GetAllItems())
					{
						if (allItem?.m_shared != null && allItem.m_stack > 0 && ItemMatchesYamlReferenceToken(allItem, inventoryLimit.Key))
						{
							num += allItem.m_stack;
						}
					}
					InventorySafety.InventoryLimitCountCache.TryGetValue(inventoryLimit.Key, out var value);
					if (num > 0 && Math.Max(0L, value) + num > inventoryLimit.Value)
					{
						return false;
					}
				}
			}
			if (inventory.GetTotalWeight() + val.GetTotalWeight() > player.GetMaxCarryWeight())
			{
				return false;
			}
			HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
			List<(ItemData, int)> list = new List<(ItemData, int)>();
			foreach (ItemData allItem2 in inventory.GetAllItems())
			{
				if (allItem2 != null)
				{
					hashSet.Add(allItem2.m_gridPos);
					int num2 = allItem2.m_shared.m_maxStackSize - allItem2.m_stack;
					if (num2 > 0)
					{
						list.Add((allItem2, num2));
					}
				}
			}
			foreach (ItemData item in val.GetAllItemsInGridOrder())
			{
				if (item == null)
				{
					continue;
				}
				int num3 = Math.Max(0, item.m_stack);
				for (int i = 0; i < list.Count; i++)
				{
					if (num3 <= 0)
					{
						break;
					}
					var (val2, num4) = list[i];
					if (num4 > 0 && CanShareInventoryStack(val2, item))
					{
						int num5 = Math.Min(num4, num3);
						list[i] = (val2, num4 - num5);
						num3 -= num5;
					}
				}
				if (num3 > 0)
				{
					if (!TryFindVirtualFitCell(player, inventory, item, hashSet, out var pos))
					{
						return false;
					}
					hashSet.Add(pos);
					int num6 = Math.Max(0, item.m_shared.m_maxStackSize - num3);
					if (num6 > 0)
					{
						list.Add((item, num6));
					}
				}
			}
			return true;
		}

		internal static void CleanupTombstoneFloatingBodyForAutoPickup(TombStone? tombstone)
		{
			if (IsUnityNull((Object?)(object)tombstone) || !Player.m_enableAutoPickup)
			{
				return;
			}
			Rigidbody body = tombstone.m_body;
			if (IsUnityNull((Object?)(object)body))
			{
				return;
			}
			try
			{
				GameObject gameObject = ((Component)body).gameObject;
				GameObject gameObject2 = ((Component)tombstone).gameObject;
				Transform root = ((Component)body).transform.root;
				FloatingTerrain val = default(FloatingTerrain);
				if ((IsUnityNull((Object?)(object)root) || !((Object)(object)((Component)root).gameObject == (Object)(object)gameObject2)) && ((Component)tombstone).TryGetComponent<FloatingTerrain>(ref val))
				{
					val.m_lastHeightmap = null;
					if (!IsUnityNull((Object?)(object)gameObject))
					{
						Object.Destroy((Object)(object)gameObject);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static bool TryFindVirtualFitCell(Player player, Inventory inventory, ItemData item, HashSet<Vector2i> claimed, out Vector2i pos)
		{
			//IL_0039: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00c6: 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_00d3: 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_012b: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			if (item.m_gridPos.y >= GetFixedRegularRows() && !claimed.Contains(item.m_gridPos) && CanUseCell(player, inventory, item, item.m_gridPos))
			{
				pos = item.m_gridPos;
				return true;
			}
			foreach (SlotDefinition item2 in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind != SlotKind.Quick && CanUseSpecialSlot(player, inventory, item, slot)))
			{
				Vector2i slotGridPos = GetSlotGridPos(inventory, item2);
				if (!claimed.Contains(slotGridPos))
				{
					pos = slotGridPos;
					return true;
				}
			}
			int usableRegularRows = GetUsableRegularRows(player);
			Vector2i val = default(Vector2i);
			for (int num = 0; num < usableRegularRows; num++)
			{
				for (int num2 = 0; num2 < inventory.GetWidth(); num2++)
				{
					((Vector2i)(ref val))..ctor(num2, num);
					if (!claimed.Contains(val) && IsUsableRegularCell(inventory, player, val))
					{
						pos = val;
						return true;
					}
				}
			}
			foreach (SlotDefinition item3 in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind == SlotKind.Quick && CanUseSpecialSlot(player, inventory, item, slot)))
			{
				Vector2i slotGridPos2 = GetSlotGridPos(inventory, item3);
				if (!claimed.Contains(slotGridPos2))
				{
					pos = slotGridPos2;
					return true;
				}
			}
			pos = new Vector2i(-1, -1);
			return false;
		}

		private static bool IsTombstoneContainer(Container container)
		{
			if (!(container.m_name == "Grave") && !((Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null))
			{
				return (Object)(object)((Component)container).GetComponentInParent<TombStone>() != (Object)null;
			}
			return true;
		}

		private static void PersistContainerHeight(Container container, int height)
		{
			ZNetView nview = container.m_nview;
			if ((Object)(object)nview == (Object)null || !nview.IsValid() || !nview.IsOwner() || (Object)(object)((Component)container).GetComponent<TombStone>() == (Object)null)
			{
				return;
			}
			ZDO zDO = nview.GetZDO();
			if (zDO != null)
			{
				string name = ((object)container).GetType().Name;
				int stableHashCode = StringExtensionMethods.GetStableHashCode("HasFields" + name);
				string text = name + ".m_height";
				if (!zDO.GetBool("HasFields", false))
				{
					zDO.Set("HasFields", true);
				}
				if (!zDO.GetBool(stableHashCode, false))
				{
					zDO.Set(stableHashCode, true);
				}
				if (zDO.GetInt(text, 0) != height)
				{
					zDO.Set(text, height);
				}
			}
		}

		private static void HideVanillaTooltipVisual(GameObject? tooltipObject)
		{
			if ((Object)(object)tooltipObject == (Object)null || IsUnityNull((Object?)(object)tooltipObject))
			{
				return;
			}
			CanvasGroup component = tooltipObject.GetComponent<CanvasGroup>();
			bool num = !VanillaTooltipVisualSnapshots.ContainsKey(tooltipObject);
			if (num)
			{
				VanillaTooltipVisualSnapshots[tooltipObject] = (((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component)) ? new TooltipCanvasGroupVisualSnapshot(hadCanvasGroup: true, component.alpha, component.interactable, component.blocksRaycasts, component.ignoreParentGroups) : new TooltipCanvasGroupVisualSnapshot(hadCanvasGroup: false, 1f, interactable: true, blocksRaycasts: true, ignoreParentGroups: false));
			}
			CanvasGroup val = (((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component)) ? component : tooltipObject.AddComponent<CanvasGroup>());
			HideVanillaTooltipCanvasGroup(val, VanillaTooltipVisualSnapshots[tooltipObject]);
			if (!num)
			{
				return;
			}
			CanvasGroup[] componentsInChildren = tooltipObject.GetComponentsInChildren<CanvasGroup>(true);
			foreach (CanvasGroup val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2) && !((Object)(object)val2 == (Object)(object)val))
				{
					if (!VanillaTooltipChildCanvasGroupSnapshots.ContainsKey(val2))
					{
						VanillaTooltipChildCanvasGroupSnapshots[val2] = new TooltipCanvasGroupVisualSnapshot(hadCanvasGroup: true, val2.alpha, val2.interactable, val2.blocksRaycasts, val2.ignoreParentGroups);
					}
					HideVanillaTooltipCanvasGroup(val2, VanillaTooltipChildCanvasGroupSnapshots[val2]);
				}
			}
		}

		private static void HideVanillaTooltipCanvasGroup(CanvasGroup group, TooltipCanvasGroupVisualSnapshot snapshot)
		{
			group.alpha = 0f;
			group.interactable = false;
			group.blocksRaycasts = false;
			group.ignoreParentGroups = false;
		}

		private static void RestoreVanillaTooltipVisual(GameObject? tooltipObject)
		{
			if ((Object)(object)tooltipObject == (Object)null || IsUnityNull((Object?)(object)tooltipObject) || !VanillaTooltipVisualSnapshots.TryGetValue(tooltipObject, out var value))
			{
				return;
			}
			VanillaTooltipVisualSnapshots.Remove(tooltipObject);
			RestoreVanillaTooltipChildCanvasGroups(tooltipObject);
			CanvasGroup component = tooltipObject.GetComponent<CanvasGroup>();
			if (!((Object)(object)component == (Object)null) && !IsUnityNull((Object?)(object)component))
			{
				if (value.HadCanvasGroup)
				{
					component.alpha = value.Alpha;
					component.interactable = value.Interactable;
					component.blocksRaycasts = value.BlocksRaycasts;
					component.ignoreParentGroups = value.IgnoreParentGroups;
				}
				else
				{
					component.alpha = 1f;
					component.interactable = true;
					component.blocksRaycasts = true;
					component.ignoreParentGroups = false;
					Object.Destroy((Object)(object)component);
				}
			}
		}

		private static void RestoreVanillaTooltipChildCanvasGroups(GameObject tooltipObject)
		{
			List<CanvasGroup> list = new List<CanvasGroup>();
			foreach (CanvasGroup key in VanillaTooltipChildCanvasGroupSnapshots.Keys)
			{
				if ((Object)(object)key != (Object)null && !IsUnityNull((Object?)(object)key) && (Object)(object)((Component)key).transform != (Object)null && ((Object)(object)((Component)key).gameObject == (Object)(object)tooltipObject || ((Component)key).transform.IsChildOf(tooltipObject.transform)))
				{
					list.Add(key);
				}
			}
			foreach (CanvasGroup item in list)
			{
				TooltipCanvasGroupVisualSnapshot tooltipCanvasGroupVisualSnapshot = VanillaTooltipChildCanvasGroupSnapshots[item];
				VanillaTooltipChildCanvasGroupSnapshots.Remove(item);
				if (!((Object)(object)item == (Object)null) && !IsUnityNull((Object?)(object)item))
				{
					item.alpha = tooltipCanvasGroupVisualSnapshot.Alpha;
					item.interactable = tooltipCanvasGroupVisualSnapshot.Interactable;
					item.blocksRaycasts = tooltipCanvasGroupVisualSnapshot.BlocksRaycasts;
					item.ignoreParentGroups = tooltipCanvasGroupVisualSnapshot.IgnoreParentGroups;
				}
			}
		}

		private static void RestartInventoryContainerHoverTooltip(UITooltip? tooltip, GameObject? hovered)
		{
			if (!((Object)(object)tooltip == (Object)null) && !IsUnityNull((Object?)(object)tooltip) && !((Object)(object)hovered == (Object)null) && !IsUnityNull((Object?)(object)hovered) && hovered.activeInHierarchy && IsInventoryContainerTooltipSource(tooltip))
			{
				tooltip.OnHoverStart(hovered);
			}
		}

		private static void HideInventoryOwnedHoverTooltips()
		{
			_inventoryContainerHoverTooltipSource = null;
			_inventorySlotsOwnedHoverTooltipSource = null;
			HideInventoryContainerCustomTooltip();
			ForceHideInventorySimpleNameTooltip();
			RestoreVanillaTooltipVisual(UITooltip.m_tooltip);
		}

		private static bool SetRectLayout(RectTransform rect, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPosition, Vector2 sizeDelta)
		{
			//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_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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_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_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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//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_0079: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			bool result = false;
			Vector2 val = rect.anchorMin - anchorMin;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.anchorMin = anchorMin;
				result = true;
			}
			val = rect.anchorMax - anchorMax;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.anchorMax = anchorMax;
				result = true;
			}
			val = rect.pivot - pivot;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.pivot = pivot;
				result = true;
			}
			val = rect.anchoredPosition - anchoredPosition;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.anchoredPosition = anchoredPosition;
				result = true;
			}
			val = rect.sizeDelta - sizeDelta;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.sizeDelta = sizeDelta;
				result = true;
			}
			if (((Transform)rect).localScale != Vector3.one)
			{
				((Transform)rect).localScale = Vector3.one;
				result = true;
			}
			if (((Transform)rect).localRotation != Quaternion.identity)
			{
				((Transform)rect).localRotation = Quaternion.identity;
				result = true;
			}
			return result;
		}

		private static bool SetCenteredRectLayout(RectTransform rect, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_000b: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return SetRectLayout(rect, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), anchoredPosition, size);
		}

		private static bool SetTopLeftRectLayout(RectTransform rect, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_000b: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return SetRectLayout(rect, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f), anchoredPosition, size);
		}

		private static bool SetTopLeftRectLayout(RectTransform parent, RectTransform rect, Vector2 anchoredPosition, Vector2 size, bool setAsLastSibling = true)
		{
			//IL_001c: 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)
			bool flag = false;
			if ((Object)(object)((Transform)rect).parent != (Object)(object)parent)
			{
				((Transform)rect).SetParent((Transform)(object)parent, false);
				flag = true;
			}
			flag |= SetTopLeftRectLayout(rect, anchoredPosition, size);
			if (setAsLastSibling && flag && (Object)(object)((Transform)rect).parent != (Object)null && ((Transform)rect).GetSiblingIndex() != ((Transform)rect).parent.childCount - 1)
			{
				((Transform)rect).SetAsLastSibling();
			}
			return flag;
		}

		private static bool SetStretchRectLayout(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0048: 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)
			bool result = SetRectLayout(rect, Vector2.zero, Vector2.one, new Vector2(0.5f, 0.5f), rect.anchoredPosition, rect.sizeDelta);
			Vector2 val = rect.offsetMin - offsetMin;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.offsetMin = offsetMin;
				result = true;
			}
			val = rect.offsetMax - offsetMax;
			if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
			{
				rect.offsetMax = offsetMax;
				result = true;
			}
			return result;
		}

		private static float GetUiScrollDelta(UiScrollInputMode mode, bool allowGamepad = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			float num = Input.mouseScrollDelta.y * GetMouseUiScrollMultiplier();
			if (Mathf.Abs(num) >= 0.01f)
			{
				return num;
			}
			if (!allowGamepad || !IsGamepadUiScrollActive(out var delta))
			{
				return 0f;
			}
			if (mode == UiScrollInputMode.Continuous)
			{
				return delta * GetGamepadUiScrollSensitivity() * Time.unscaledDeltaTime;
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime < _nextGamepadUiScrollStepTime)
			{
				return 0f;
			}
			_nextGamepadUiScrollStepTime = unscaledTime + GetGamepadUiScrollRepeatDelay();
			return Mathf.Sign(delta);
		}

		private static bool IsUiScrollTargetActive(RectTransform? rect, bool allowGamepad = true)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			if (RectContainsScreenPoint(rect, GetUiMousePosition()))
			{
				return true;
			}
			if (allowGamepad)
			{
				return IsGamepadUiScrollActive();
			}
			return false;
		}

		private static Vector2 GetUiMousePosition()
		{
			//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)
			return Vector2.op_Implicit(Input.mousePosition);
		}

		private static bool IsGamepadUiScrollActive()
		{
			float delta;
			return IsGamepadUiScrollActive(out delta);
		}

		private static bool IsGamepadUiScrollActive(out float delta)
		{
			delta = 0f;
			if (_enableGamepadUiScroll == null || _enableGamepadUiScroll.Value.IsOff() || !IsGamepadActiveSafe())
			{
				_nextGamepadUiScrollStepTime = 0f;
				return false;
			}
			delta = GetGamepadUiScrollRawDelta();
			if (Mathf.Abs(delta) < GetGamepadUiScrollDeadzone())
			{
				_nextGamepadUiScrollStepTime = 0f;
				delta = 0f;
				return false;
			}
			delta = Mathf.Clamp(delta, -1f, 1f);
			return true;
		}

		private static bool IsGamepadActiveSafe()
		{
			try
			{
				return ZInput.IsGamepadActive();
			}
			catch
			{
				return false;
			}
		}

		private static float GetGamepadUiScrollRawDelta()
		{
			return (_gamepadUiScrollSource?.Value ?? GamepadUiScrollSource.RightStickY) switch
			{
				GamepadUiScrollSource.DPadVertical => GetGamepadDPadVertical(), 
				GamepadUiScrollSource.RightStickYOrDPadVertical => GetDominantGamepadScrollDelta(GetGamepadRightStickY(), GetGamepadDPadVertical()), 
				_ => GetGamepadRightStickY(), 
			};
		}

		private static float GetDominantGamepadScrollDelta(float first, float second)
		{
			if (!(Mathf.Abs(first) >= Mathf.Abs(second)))
			{
				return second;
			}
			return first;
		}

		private static float GetGamepadRightStickY()
		{
			try
			{
				return ZInput.GetJoyRightStickY(true);
			}
			catch
			{
				return 0f;
			}
		}

		private static float GetGamepadDPadVertical()
		{
			try
			{
				if (ZInput.GetButton("JoyDPadUp"))
				{
					return 1f;
				}
				if (ZInput.GetButton("JoyDPadDown"))
				{
					return -1f;
				}
			}
			catch
			{
				return 0f;
			}
			return 0f;
		}

		private static float GetMouseUiScrollMultiplier()
		{
			return Mathf.Clamp(_mouseUiScrollMultiplier?.Value ?? 1f, 0.1f, 5f);
		}

		private static float GetGamepadUiScrollSensitivity()
		{
			return Mathf.Clamp(_gamepadUiScrollSensitivity?.Value ?? 6f, 0.5f, 20f);
		}

		private static float GetGamepadUiScrollRepeatDelay()
		{
			return Mathf.Clamp(_gamepadUiScrollRepeatDelay?.Value ?? 0.18f, 0.05f, 0.75f);
		}

		private static float GetGamepadUiScrollDeadzone()
		{
			return Mathf.Clamp(_gamepadUiScrollDeadzone?.Value ?? 0.35f, 0.05f, 0.95f);
		}

		private static bool TryGetVeiledRecipesApi(out VeiledRecipesApi? api)
		{
			return TryGetCompatApi("sighsorry.VeiledRecipes", "VeiledRecipes recipe masking", CompatRuntime.VeiledRecipes, VeiledRecipesApi.TryCreate, "VeiledRecipes recipe masking compatibility disabled", out api);
		}

		private static bool IsVeiledRecipeMasked(RecipeDataPair pair)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && TryGetVeiledRecipesApi(out VeiledRecipesApi api) && api != null)
			{
				return api.ShouldMaskRecipePair(localPlayer, pair);
			}
			return false;
		}

		private static bool IsVeiledRecipePreview(RecipeDataPair pair)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null || !TryGetVeiledRecipesApi(out VeiledRecipesApi api) || api == null)
			{
				return false;
			}
			if (!api.HasUnknownRecipePreviewApi)
			{
				return api.ShouldMaskRecipePair(localPlayer, pair);
			}
			return api.IsUnknownRecipePreview(localPlayer, ((RecipeDataPair)(ref pair)).Recipe);
		}

		private static int CompareVeiledRecipeMaskGrouping(bool aIsVeiledRecipePreview, bool bIsVeiledRecipePreview)
		{
			if (!ShouldGroupVeiledRecipePreviewsBelowKnownRecipes())
			{
				return 0;
			}
			if (aIsVeiledRecipePreview != bIsVeiledRecipePreview)
			{
				if (!aIsVeiledRecipePreview)
				{
					return -1;
				}
				return 1;
			}
			return 0;
		}

		private static bool ShouldGroupVeiledRecipePreviewsBelowKnownRecipes()
		{
			if (TryGetVeiledRecipesApi(out VeiledRecipesApi api) && api != null)
			{
				return api.GroupUnknownRecipePreviewsBelowKnownRecipes;
			}
			return false;
		}

		private static string GetVeiledRecipeGroupingSignature()
		{
			if (!ShouldGroupVeiledRecipePreviewsBelowKnownRecipes())
			{
				return "veiledgroup:0";
			}
			return "veiledgroup:1";
		}

		private static bool IsVeiledRecipeRequirementKnown(Requirement requirement)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && TryGetVeiledRecipesApi(out VeiledRecipesApi api) && api != null)
			{
				return api.IsMaterialKnown(localPlayer, requirement);
			}
			return false;
		}

		private static bool KnowsVeiledRecipeStationRequirement(Recipe recipe, int quality)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && TryGetVeiledRecipesApi(out VeiledRecipesApi api) && api != null)
			{
				return api.KnowsRecipeStationRequirement(localPlayer, recipe, quality);
			}
			return false;
		}

		private static string GetVeiledRecipeUnknownNameText()
		{
			if (!TryGetVeiledRecipesApi(out VeiledRecipesApi api) || api == null)
			{
				return "???";
			}
			return api.UnknownNameText;
		}

		private static string GetVeiledRecipeUnknownDescriptionText()
		{
			if (!TryGetVeiledRecipesApi(out VeiledRecipesApi api) || api == null)
			{
				return "Not enough info";
			}
			return api.UnknownDescriptionText;
		}

		private static string GetVeiledRecipeUnknownRequirementText()
		{
			if (!TryGetVeiledRecipesApi(out VeiledRecipesApi api) || api == null)
			{
				return "?";
			}
			return api.UnknownRequirementText;
		}

		private static string GetVeiledRecipeDisplaySignature(RecipeDataPair pair)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!IsVeiledRecipeMasked(pair))
			{
				return "veiled:known";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("veiled:masked|").Append(GetVeiledRecipeUnknownNameText()).Append('|')
				.Append(GetVeiledRecipeUnknownDescriptionText())
				.Append('|')
				.Append(GetVeiledRecipeUnknownRequirementText());
			Recipe recipe = ((RecipeDataPair)(ref pair)).Recipe;
			if ((Object)(object)recipe == (Object)null)
			{
				return stringBuilder.ToString();
			}
			int num = ((((RecipeDataPair)(ref pair)).ItemData == null) ? 1 : (((RecipeDataPair)(ref pair)).ItemData.m_quality + 1));
			if (recipe.m_resources != null)
			{
				Requirement[] resources = recipe.m_resources;
				foreach (Requirement val in resources)
				{
					if (val != null && !((Object)(object)val.m_resItem == (Object)null) && val.GetAmount(num) > 0)
					{
						stringBuilder.Append('|').Append(((Object)val.m_resItem).GetInstanceID()).Append(':')
							.Append(IsVeiledRecipeRequirementKnown(val) ? '1' : '0');
					}
				}
			}
			stringBuilder.Append("|station:").Append(KnowsVeiledRecipeStationRequirement(recipe, num) ? '1' : '0');
			return stringBuilder.ToString();
		}

		private static void InitializeYamlSync()
		{
			_syncedYaml = new CustomSyncedValue<string>(ConfigSync, "InventorySlotsYaml", "");
			_syncedResourceMapYaml = new CustomSyncedValue<string>(ConfigSync, "InventorySlotsResourceMapYaml", "");
			_syncedYaml.ValueChanged += delegate
			{
				ApplyYaml(_syncedYaml.Value, fromSync: true);
			};
			_syncedResourceMapYaml.ValueChanged += delegate
			{
				ApplyResourceMapYaml(_syncedResourceMapYaml.Value, fromSync: true);
			};
			bool flag = EnsureBuiltInYamlValid();
			string text = ReadYamlFileOrDefault();
			if (ApplyYaml(text, fromSync: false))
			{
				_syncedYaml.AssignLocalValue(text);
			}
			else if (flag && ApplyYaml(DefaultYaml, fromSync: false))
			{
				_syncedYaml.AssignLocalValue(DefaultYaml);
			}
			else
			{
				_syncedYaml.AssignLocalValue("");
			}
			bool flag2 = EnsureBuiltInResourceMapYamlValid();
			string text2 = ReadResourceMapFileOrDefault();
			if (ApplyResourceMapYaml(text2, fromSync: false))
			{
				_syncedResourceMapYaml.AssignLocalValue(text2);
			}
			else if (flag2 && ApplyResourceMapYaml(DefaultResourceMapYaml, fromSync: false))
			{
				_syncedResourceMapYaml.AssignLocalValue(DefaultResourceMapYaml);
			}
			else
			{
				_syncedResourceMapYaml.AssignLocalValue("");
			}
			StartYamlWatcher();
		}

		private static bool EnsureBuiltInYamlValid()
		{
			if (InventorySlotsConfigCore.TryParseYaml(DefaultYaml, out YamlRoot _, out Exception error))
			{
				return true;
			}
			Log.LogError((object)$"Built-in InventorySlots YAML failed to parse. Falling back to built-in equipment slots only: {error}");
			_yamlConfig = new YamlRoot();
			RebuildPredefinedGroups();
			RebuildInventoryLimits();
			RebuildSlotDefinitions();
			ClearCraftingRecipeCaches();
			return false;
		}

		private static bool EnsureBuiltInResourceMapYamlValid()
		{
			if (InventorySlotsConfigCore.TryParseResourceMapYaml(DefaultResourceMapYaml, out Dictionary<string, int> _, out Exception error))
			{
				return true;
			}
			Log.LogError((object)$"Built-in ResourceMap YAML failed to parse. Falling back to no resource tiers: {error}");
			ResourceTierByToken.Clear();
			try
			{
				ClearCraftingRecipeCaches();
			}
			catch (Exception arg)
			{
				Log.LogWarning((object)$"ResourceMap fallback succeeded, but crafting cache refresh failed: {arg}");
			}
			return false;
		}

		private static void StartYamlWatcher()
		{
			StopYamlWatcher();
			Directory.CreateDirectory(ConfigDirectoryPath);
			_yamlWatcher = new FileSystemWatcher(ConfigDirectoryPath, "*.yml")
			{
				IncludeSubdirectories = false,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime)
			};
			FileSystemEventHandler value = delegate(object _, FileSystemEventArgs args)
			{
				QueueYamlReloadForFile(args.FullPath);
			};
			RenamedEventHandler value2 = delegate(object _, RenamedEventArgs args)
			{
				QueueYamlReloadForFile(args.OldFullPath);
				QueueYamlReloadForFile(args.FullPath);
			};
			ErrorEventHandler value3 = delegate
			{
				QueueYamlReload(reloadYaml: true, reloadResourceMap: true);
			};
			_yamlWatcher.Changed += value;
			_yamlWatcher.Created += value;
			_yamlWatcher.Deleted += value;
			_yamlWatcher.Renamed += value2;
			_yamlWatcher.Error += value3;
			_yamlWatcher.EnableRaisingEvents = true;
		}

		private static void StopYamlWatcher()
		{
			if (_yamlWatcher != null)
			{
				_yamlWatcher.EnableRaisingEvents = false;
				_yamlWatcher.Dispose();
				_yamlWatcher = null;
			}
		}

		private static void QueueYamlReloadForFile(string? path)
		{
			string fileName = Path.GetFileName(path);
			if (string.Equals(fileName, "InventorySlots.yml", StringComparison.OrdinalIgnoreCase))
			{
				QueueYamlReload(reloadYaml: true, reloadResourceMap: false);
			}
			else if (string.Equals(fileName, "ResourceMap.yml", StringComparison.OrdinalIgnoreCase))
			{
				QueueYamlReload(reloadYaml: false, reloadResourceMap: true);
			}
		}

		private static void QueueYamlReload(bool reloadYaml, bool reloadResourceMap)
		{
			if (!reloadYaml && !reloadResourceMap)
			{
				return;
			}
			lock (YamlReloadLock)
			{
				_yamlReloadQueued |= reloadYaml;
				_resourceMapReloadQueued |= reloadResourceMap;
				_yamlReloadAfterUtc = DateTime.UtcNow.AddMilliseconds(250.0);
			}
		}

		private static void ProcessYamlHotReload()
		{
			bool yamlReloadQueued;
			bool resourceMapReloadQueued;
			lock (YamlReloadLock)
			{
				if ((!_yamlReloadQueued && !_resourceMapReloadQueued) || DateTime.UtcNow < _yamlReloadAfterUtc)
				{
					return;
				}
				yamlReloadQueued = _yamlReloadQueued;
				resourceMapReloadQueued = _resourceMapReloadQueued;
				_yamlReloadQueued = false;
				_resourceMapReloadQueued = false;
			}
			if (CanApplyLocalYamlChanges())
			{
				if (yamlReloadQueued)
				{
					ProcessInventorySlotsYamlHotReload();
				}
				if (resourceMapReloadQueued)
				{
					ProcessResourceMapYamlHotReload();
				}
			}
		}

		private static void ProcessInventorySlotsYamlHotReload()
		{
			try
			{
				string text = ReadYamlFileOrDefault();
				if (ApplyYaml(text, fromSync: false))
				{
					_syncedYaml.AssignLocalValue(text);
					Log.LogInfo((object)"InventorySlots YAML hot-reloaded.");
				}
			}
			catch (IOException ex)
			{
				Log.LogWarning((object)("InventorySlots YAML hot reload delayed because the file is still busy: " + ex.Message));
				QueueYamlReload(reloadYaml: true, reloadResourceMap: false);
			}
			catch (UnauthorizedAccessException ex2)
			{
				Log.LogWarning((object)("InventorySlots YAML hot reload delayed because the file cannot be read yet: " + ex2.Message));
				QueueYamlReload(reloadYaml: true, reloadResourceMap: false);
			}
		}

		private static void ProcessResourceMapYamlHotReload()
		{
			try
			{
				string text = ReadResourceMapFileOrDefault();
				if (ApplyResourceMapYaml(text, fromSync: false))
				{
					_syncedResourceMapYaml.AssignLocalValue(text);
					Log.LogInfo((object)"InventorySlots ResourceMap YAML hot-reloaded.");
				}
			}
			catch (IOException ex)
			{
				Log.LogWarning((object)("ResourceMap YAML hot reload delayed because the file is still busy: " + ex.Message));
				QueueYamlReload(reloadYaml: false, reloadResourceMap: true);
			}
			catch (UnauthorizedAccessException ex2)
			{
				Log.LogWarning((object)("ResourceMap YAML hot reload delayed because the file cannot be read yet: " + ex2.Message));
				QueueYamlReload(reloadYaml: false, reloadResourceMap: true);
			}
		}

		private static bool CanApplyLocalYamlChanges()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.IsSinglePlayer)
			{
				return ConfigSync.IsSourceOfTruth;
			}
			return true;
		}

		private static string ReadYamlFileOrDefault()
		{
			if (!File.Exists(YamlFilePath))
			{
				return DefaultYaml;
			}
			return File.ReadAllText(YamlFilePath);
		}

		private static string ReadResourceMapFileOrDefault()
		{
			if (!File.Exists(ResourceMapFilePath))
			{
				return DefaultResourceMapYaml;
			}
			return File.ReadAllText(ResourceMapFilePath);
		}

		private static void EnsureDefaultYamlFiles()
		{
			Directory.CreateDirectory(ConfigDirectoryPath);
			if (!File.Exists(YamlFilePath))
			{
				File.WriteAllText(YamlFilePath, DefaultYaml);
			}
			if (!File.Exists(ResourceMapFilePath))
			{
				File.WriteAllText(ResourceMapFilePath, DefaultResourceMapYaml);
			}
		}

		private static bool ApplyYaml(string yaml, bool fromSync)
		{
			string arg = (fromSync ? "synced" : "local");
			YamlRoot yamlConfig;
			try
			{
				yamlConfig = InventorySlotsConfigCore.ParseYaml(yaml);
			}
			catch (Exception arg2)
			{
				Log.LogWarning((object)$"Failed to parse {arg} InventorySlots YAML; keeping the last stable configuration: {arg2}");
				return false;
			}
			YamlApplySnapshot snapshot = CreateYamlApplySnapshot();
			try
			{
				_yamlConfig = yamlConfig;
				RebuildPredefinedGroups();
				RebuildInventoryLimits();
				RebuildSlotDefinitions();
			}
			catch (Exception arg3)
			{
				RestoreYamlApplySnapshot(snapshot);
				Log.LogWarning((object)$"Failed to apply {arg} InventorySlots YAML; keeping the last stable configuration: {arg3}");
				return false;
			}
			try
			{
				RebuildStationInputTokens(force: true);
			}
			catch (Exception arg4)
			{
				Log.LogWarning((object)$"Applied {arg} InventorySlots YAML, but station token refresh failed: {arg4}");
			}
			try
			{
				ClearCraftingRecipeCaches();
			}
			catch (Exception arg5)
			{
				Log.LogWarning((object)$"Applied {arg} InventorySlots YAML, but crafting cache refresh failed: {arg5}");
			}
			InvalidateCraftingRecipeView();
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (!IsUnityNull((Object?)(object)localPlayer))
				{
					EnsureInventoryState(localPlayer, InventoryStateEnsureReason.YamlReload);
				}
			}
			catch (Exception arg6)
			{
				Log.LogWarning((object)$"Applied {arg} InventorySlots YAML, but player inventory reconciliation failed: {arg6}");
			}
			return true;
		}

		private static bool ApplyResourceMapYaml(string yaml, bool fromSync)
		{
			string arg = (fromSync ? "synced" : "local");
			Dictionary<string, int> dictionary;
			try
			{
				dictionary = InventorySlotsConfigCore.ParseResourceMapYaml(yaml);
			}
			catch (Exception arg2)
			{
				Log.LogWarning((object)$"Failed to parse {arg} ResourceMap YAML; keeping the last stable resource tiers: {arg2}");
				return false;
			}
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>(ResourceTierByToken, StringComparer.OrdinalIgnoreCase);
			try
			{
				ResourceTierByToken.Clear();
				foreach (KeyValuePair<string, int> item in dictionary)
				{
					ResourceTierByToken[item.Key] = item.Value;
				}
			}
			catch (Exception arg3)
			{
				ResourceTierByToken.Clear();
				foreach (KeyValuePair<string, int> item2 in dictionary2)
				{
					ResourceTierByToken[item2.Key] = item2.Value;
				}
				Log.LogWarning((object)$"Failed to apply {arg} ResourceMap YAML; keeping the last stable resource tiers: {arg3}");
				return false;
			}
			try
			{
				ClearCraftingRecipeCaches();
			}
			catch (Exception arg4)
			{
				Log.LogWarning((object)$"Applied {arg} ResourceMap YAML, but crafting cache refresh failed: {arg4}");
			}
			InvalidateCraftingRecipeView();
			return true;
		}

		private static YamlApplySnapshot CreateYamlApplySnapshot()
		{
			return new YamlApplySnapshot(_yamlConfig, SlotDefinitions.ToList(), PredefinedGroupDefinitions.ToDictionary<KeyValuePair<string, List<string>>, string, List<string>>((KeyValuePair<string, List<string>> entry) => entry.Key, (KeyValuePair<string, List<string>> entry) => entry.Value.ToList(), StringComparer.OrdinalIgnoreCase), PredefinedGroupOrder.ToList(), PredefinedGroupOrders.ToDictionary<KeyValuePair<string, List<string>>, string, List<string>>((KeyValuePair<string, List<string>> entry) => entry.Key, (KeyValuePair<string, List<string>> entry) => entry.Value.ToList(), StringComparer.OrdinalIgnoreCase));
		}

		private static void RestoreYamlApplySnapshot(YamlApplySnapshot snapshot)
		{
			_yamlConfig = snapshot.Config;
			SlotDefinitions.Clear();
			SlotDefinitions.AddRange(snapshot.SlotDefinitions);
			InvalidateSlotDefinitionCaches();
			PredefinedGroupDefinitions.Clear();
			foreach (KeyValuePair<string, List<string>> predefinedGroupDefinition in snapshot.PredefinedGroupDefinitions)
			{
				PredefinedGroupDefinitions[predefinedGroupDefinition.Key] = predefinedGroupDefinition.Value.ToList();
			}
			PredefinedGroupOrder.Clear();
			PredefinedGroupOrder.AddRange(snapshot.PredefinedGroupOrder);
			PredefinedGroupOrders.Clear();
			foreach (KeyValuePair<string, List<string>> predefinedGroupOrder in snapshot.PredefinedGroupOrders)
			{
				PredefinedGroupOrders[predefinedGroupOrder.Key] = predefinedGroupOrder.Value.ToList();
			}
			RebuildInventoryLimits();
		}

		private static void RebuildPredefinedGroups()
		{
			PredefinedGroupDefinitions.Clear();
			PredefinedGroupOrder.Clear();
			PredefinedGroupOrders.Clear();
			AddBuiltInPredefinedGroupOrders();
			ApplyYamlGroups(_yamlConfig.Groups);
		}

		private static void RebuildInventoryLimits()
		{
			InventoryLimits.Clear();
			foreach (KeyValuePair<string, int> item in InventorySlotsConfigCore.BuildInventoryLimits(_yamlConfig))
			{
				InventoryLimits[item.Key] = item.Value;
			}
			InventoryDefinitions.InventoryLimitVersion++;
			InvalidateInventoryPlacementCaches();
		}

		private static void AddBuiltInPredefinedGroupOrders()
		{
			foreach (BuiltInItemGroupSection section in ItemGroupRegistry.Sections)
			{
				AddPredefinedGroupOrder(section.Id, section.Subgroups.ToArray());
			}
			AddPredefinedGroupOrder("global", ItemGroupRegistry.GlobalSubgroupOrder().ToArray());
		}

		private static void ApplyYamlGroups(Dictionary<string, List<string>>? rawGroups)
		{
			if (rawGroups == null || rawGroups.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<string, List<string>> rawGroup in rawGroups)
			{
				string text = NormalizeGroupId(rawGroup.Key);
				if (string.IsNullOrWhiteSpace(text) || TryNormalizeGroupSectionId(rawGroup.Key, out string _))
				{
					continue;
				}
				if (IsBuiltInPredefinedGroupId(text))
				{
					Log.LogWarning((object)("InventorySlots YAML group '" + rawGroup.Key + "' conflicts with a built-in group id and was ignored. Choose a custom group name such as custom" + rawGroup.Key + "."));
				}
				else
				{
					PredefinedGroupDefinitions[text] = (from value in rawGroup.Value ?? new List<string>()
						where !string.IsNullOrWhiteSpace(value)
						select value.Trim()).ToList();
				}
			}
			foreach (KeyValuePair<string, List<string>> rawGroup2 in rawGroups)
			{
				if (TryNormalizeGroupSectionId(rawGroup2.Key, out string craftingGroupId2))
				{
					List<string> list = (from value in (rawGroup2.Value ?? new List<string>()).Where((string value) => !string.IsNullOrWhiteSpace(value)).Select(NormalizeGroupId)
						where !string.IsNullOrWhiteSpace(value)
						select value).ToList();
					if (string.Equals(craftingGroupId2, "food", StringComparison.OrdinalIgnoreCase) && !list.Contains<string>("feast", StringComparer.OrdinalIgnoreCase))
					{
						list.Add("feast");
					}
					if (list.Count > 0)
					{
						SetPredefinedGroupOrder(craftingGroupId2, list);
					}
				}
			}
		}

		private static bool TryNormalizeGroupSectionId(string? rawId, out string craftingGroupId)
		{
			craftingGroupId = "";
			if (string.IsNullOrWhiteSpace(rawId))
			{
				return false;
			}
			return ItemGroupRegistry.TryNormalizeSectionId(rawId, out craftingGroupId);
		}

		private static bool IsBuiltInPredefinedGroupId(string groupId)
		{
			return ItemGroupRegistry.IsBuiltInGroupId(groupId);
		}

		private static void SetPredefinedGroupOrder(string craftingGroupId, IEnumerable<string> groupIds)
		{
			string text = NormalizeGroupId(craftingGroupId);
			if (!string.IsNullOrWhiteSpace(text))
			{
				PredefinedGroupOrders[text] = new List<string>();
				AddPredefinedGroupOrder(text, groupIds.ToArray());
			}
		}

		private static void AddPredefinedGroupOrder(string craftingGroupId, params string[] groupIds)
		{
			string text = NormalizeGroupId(craftingGroupId);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "global";
			}
			if (!PredefinedGroupOrders.TryGetValue(text, out List<string> value))
			{
				value = new List<string>();
				PredefinedGroupOrders[text] = value;
			}
			for (int i = 0; i < groupIds.Length; i++)
			{
				string text2 = NormalizeGroupId(groupIds[i]);
				if (!string.IsNullOrWhiteSpace(text2) && !value.Contains(text2))
				{
					value.Add(text2);
					if (text == "global" && !PredefinedGroupOrder.Contains(text2))
					{
						PredefinedGroupOrder.Add(text2);
					}
				}
			}
		}

		private static void RebuildSlotDefinitions()
		{
			SlotDefinitions.Clear();
			List<YamlSlot> list = _yamlConfig.Slots ?? new List<YamlSlot>();
			SlotDefinitions.Add(new SlotDefinition("helmet", GetSlotName(list, "helmet", "Helmet"), SlotKind.BuiltIn, (ItemData? item) => item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 6));
			SlotDefinitions.Add(new SlotDefinition("chest", GetSlotName(list, "chest", "Chest"), SlotKind.BuiltIn, (ItemData? item) => item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 7));
			SlotDefinitions.Add(new SlotDefinition("legs", GetSlotName(list, "legs", "Legs"), SlotKind.BuiltIn, (ItemData? item) => item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 11));
			SlotDefinitions.Add(new SlotDefinition("cape", GetSlotName(list, "cape", "Cape"), SlotKind.BuiltIn, (ItemData? item) => item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 17));
			SlotDefinitions.Add(new SlotDefinition("utility", GetSlotName(list, "utility", "Utility"), SlotKind.BuiltIn, (ItemData? item) => item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 18 && !IsJewelcraftingDedicatedJewelryItem(item) && !IsJewelcraftingUtilityGemBlocked(item)));
			SlotDefinitions.Add(new SlotDefinition("trinket", GetSlotName(list, "trinket", "Trinket"), SlotKind.BuiltIn, (ItemData? item) => item != null && (int)(item.m_shared?.m_itemType).GetValueOrDefault() == 24));
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (YamlSlot item in list)
			{
				string id = NormalizeSlotId(item.Id);
				if (string.IsNullOrWhiteSpace(id) || IsBuiltInEquipmentSlotId(id) || ShouldSuppressYamlSlotForJewelcraftingGem(id))
				{
					continue;
				}
				if (IsJewelcraftingReservedSlotId(id))
				{
					hashSet.Add(id);
					AddJewelcraftingSlot(item, id);
				}
				else
				{
					if (TryAddBackpackCompatSlot(item, id) || TryAddMagicSupremacyCompatSlot(item, id) || SlotDefinitions.Any((SlotDefinition existing) => existing.Id == id))
					{
						continue;
					}
					List<string> items = GetSlotItems(item);
					if (items.Count != 0)
					{
						string name = (string.IsNullOrWhiteSpace(item.Name) ? id : item.Name.Trim());
						SlotDefinitions.Add(new SlotDefinition(id, name, SlotKind.CustomEquipment, (ItemData? item) => ItemMatchesSlotItems(item, items)));
					}
				}
			}
			if (!hashSet.Contains("jewelcrafting.necklace"))
			{
				AddJewelcraftingSlot(null, "jewelcrafting.necklace");
			}
			if (!hashSet.Contains("jewelcrafting.ring"))
			{
				AddJewelcraftingSlot(null, "jewelcrafting.ring");
			}
			for (int num = 0; num < GetQuickSlotCount(); num++)
			{
				int quickSlotIndex = num;
				int num2 = num + 1;
				string name2 = LocalizeUi("$inventoryslots_quick_slot_format", "Quick {index}").Replace("{index}", num2.ToString());
				SlotDefinitions.Add(new SlotDefinition($"quick{num2}", name2, SlotKind.Quick, QuickSlotAcceptsItem, quickSlotIndex));
			}
			InvalidateSlotDefinitionCaches();
			Log.LogInfo((object)$"InventorySlots slot definitions rebuilt: {SlotDefinitions.Count} special slots, {PredefinedGroupDefinitions.Count} YAML custom groups.");
		}

		private static string GetSlotName(IEnumerable<YamlSlot> slots, string id, string fallback)
		{
			YamlSlot yamlSlot = slots.FirstOrDefault((YamlSlot entry) => string.Equals(NormalizeSlotId(entry.Id), id, StringComparison.OrdinalIgnoreCase));
			if (yamlSlot != null && !string.IsNullOrWhiteSpace(yamlSlot.Name))
			{
				return yamlSlot.Name.Trim();
			}
			return fallback;
		}

		private static YamlSlot? GetYamlSlot(string id)
		{
			string normalizedId = NormalizeSlotId(id);
			return (_yamlConfig.Slots ?? new List<YamlSlot>()).FirstOrDefault((YamlSlot slot) => string.Equals(NormalizeSlotId(slot.Id), normalizedId, StringComparison.OrdinalIgnoreCase));
		}

		private static bool IsBuiltInEquipmentSlotId(string id)
		{
			switch (id)
			{
			case "helmet":
			case "chest":
			case "legs":
			case "cape":
			case "utility":
			case "trinket":
				return true;
			default:
				return false;
			}
		}

		private static bool IsJewelcraftingReservedSlotId(string id)
		{
			if (id == "jewelcrafting.ring" || id == "jewelcrafting.necklace")
			{
				return true;
			}
			return false;
		}

		private static List<string> GetSlotItems(YamlSlot? slot)
		{
			return (from value in slot?.Items ?? new List<string>()
				where !string.IsNullOrWhiteSpace(value)
				select value.Trim()).ToList();
		}

		private static string LoadDefaultYaml()
		{
			return LoadEmbeddedYaml("InventorySlots.Default.yml");
		}

		private static string LoadDefaultResourceMapYaml()
		{
			return LoadEmbeddedYaml("InventorySlots.ResourceMap.Default.yml");
		}

		private static string LoadEmbeddedYaml(string resourceName)
		{
			using Stream stream = typeof(InventorySlotsPlugin).Assembly.GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				throw new InvalidOperationException("Embedded default YAML resource '" + resourceName + "' was not found.");
			}
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		private static void RefreshItemNameTokens()
		{
			ObjectDB instance = ObjectDB.instance;
			if (IsUnityNull((Object?)(object)instance) || instance.m_items == null || (InventoryDefinitions.CachedObjectDbItemCount == instance.m_items.Count && ItemNameTokens.Count > 0))
			{
				return;
			}
			ItemNameTokens.Clear();
			InventoryDefinitions.CachedObjectDbItemCount = instance.m_items.Count;
			foreach (GameObject item in instance.m_items)
			{
				if (!IsUnityNull((Object?)(object)item))
				{
					string text = item.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_name;
					if (!string.IsNullOrWhiteSpace(text))
					{
						AddItemNameToken(((Object)item).name, text);
						AddItemNameToken(text, text);
						AddItemNameToken(StripLocalizationToken(text), text);
						AddItemNameToken(NormalizeResourceToken(((Object)item).name), text);
						AddItemNameToken(NormalizeResourceToken(text), text);
					}
				}
			}
		}

		private static void AddItemNameToken(string? token, string sharedName)
		{
			string text = CleanPrefabName(token?.Trim() ?? "");
			if (!string.IsNullOrWhiteSpace(text) && !ItemNameTokens.ContainsKey(text))
			{
				ItemNameTokens[text] = sharedName;
			}
		}

		private static bool ItemMatchesSlotItems(ItemData? item, IEnumerable<string> items)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			foreach (string item2 in items)
			{
				if (ItemMatchesYamlReferenceToken(item, item2))
				{
					return true;
				}
			}
			return false;
		}

		private static bool ItemMatchesYamlReferenceToken(ItemData item, string token)
		{
			if (string.IsNullOrWhiteSpace(token))
			{
				return false;
			}
			if (ItemMatchesExactPrefabOrName(item, token))
			{
				return true;
			}
			if (TryNormalizeGroupSectionId(token, out string craftingGroupId))
			{
				return ItemMatchesTopLevelGroup(item, craftingGroupId);
			}
			string text = NormalizeGroupId(token);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return ItemMatchesPredefinedGroup(item, text);
			}
			return false;
		}

		private static bool ItemMatchesTopLevelGroup(ItemData item, string groupId)
		{
			string text = NormalizeGroupId(groupId);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return ItemMatchesBuiltInPredefinedGroup(item, text);
			}
			return false;
		}

		private static bool ItemMatchesPredefinedGroup(ItemData? item, string groupId)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			string text = NormalizeGroupId(groupId);
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			if (PredefinedGroupDefinitions.TryGetValue(text, out List<string> value))
			{
				return value.Any((string token) => ItemMatchesExactPrefabOrName(item, token));
			}
			return ItemMatchesBuiltInPredefinedGroup(item, text);
		}

		private static bool ItemMatchesExactPrefabOrName(ItemData item, string token)
		{
			if (string.IsNullOrWhiteSpace(token))
			{
				return false;
			}
			string token2 = CleanPrefabName(token);
			if (!ItemIdentityTokenMatches(GetItemPrefabName(item), token2) && !ItemIdentityTokenMatches(GetSharedName(item), token2) && !ItemIdentityTokenMatches(StripLocalizationToken(GetSharedName(item)), token2))
			{
				return ItemMatchesKnownItemNameToken(item, token2);
			}
			return true;
		}

		private static bool ItemMatchesKnownItemNameToken(ItemData item, string token)
		{
			if (TryGetKnownItemSharedName(token, out string sharedName))
			{
				return ItemIdentityTokenMatches(GetSharedName(item), sharedName);
			}
			return false;
		}

		private static bool TryGetKnownItemSharedName(string token, out string sharedName)
		{
			if (ItemNameTokens.TryGetValue(CleanPrefabName(token), out sharedName))
			{
				return true;
			}
			string text = NormalizeResourceToken(token);
			if (!string.IsNullOrWhiteSpace(text) && ItemNameTokens.TryGetValue(text, out sharedName))
			{
				return true;
			}
			sharedName = "";
			return false;
		}

		private static bool ItemIdentityTokenMatches(string identity, string token)
		{
			string text = CleanPrefabName(identity);
			string text2 = CleanPrefabName(token);
			if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(text2))
			{
				return false;
			}
			if (string.Equals(text, text2, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string text3 = NormalizeResourceToken(text);
			string text4 = NormalizeResourceToken(text2);
			if (!string.IsNullOrWhiteSpace(text3) && !string.IsNullOrWhiteSpace(text4))
			{
				return string.Equals(text3, text4, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}
	}
	internal static class ClientStateCore
	{
		public static InventorySlotsClientState Normalize(InventorySlotsClientState? state)
		{
			if (state == null)
			{
				state = new InventorySlotsClientState();
			}
			InventorySlotsClientState inventorySlotsClientState = state;
			InventorySlotsClientInventoryState inventorySlotsClientInventoryState;
			if (inventorySlotsClientState.Inventory == null)
			{
				inventorySlotsClientInventoryState = (inventorySlotsClientState.Inventory = new InventorySlotsClientInventoryState());
			}
			inventorySlotsClientInventoryState = state.Inventory;
			if (inventorySlotsClientInventoryState.EquipmentSlotsPanelPosition == null)
			{
				InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition = (inventorySlotsClientInventoryState.EquipmentSlotsPanelPosition = new InventorySlotsClientPanelPosition(-80f, 0f));
			}
			inventorySlotsClientInventoryState = state.Inventory;
			if (inventorySlotsClientInventoryState.QuickSlotsPanelPosition == null)
			{
				InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition = (inventorySlotsClientInventoryState.QuickSlotsPanelPosition = new InventorySlotsClientPanelPosition(-80f, -552f));
			}
			inventorySlotsClientInventoryState = state.Inventory;
			if (inventorySlotsClientInventoryState.QuickSlotsHudPosition == null)
			{
				InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition = (inventorySlotsClientInventoryState.QuickSlotsHudPosition = new InventorySlotsClientPanelPosition(64f, -520f));
			}
			if (state.Inventory.QuickSlotsHudElementSpace < 1f || float.IsNaN(state.Inventory.QuickSlotsHudElementSpace) || float.IsInfinity(state.Inventory.QuickSlotsHudElementSpace))
			{
				state.Inventory.QuickSlotsHudElementSpace = 70f;
			}
			Dictionary<string, InventorySlotsClientPlayerState> dictionary = new Dictionary<string, InventorySlotsClientPlayerState>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, InventorySlotsClientPlayerState> item in state.Players ?? new Dictionary<string, InventorySlotsClientPlayerState>())
			{
				if (!string.IsNullOrWhiteSpace(item.Key))
				{
					InventorySlotsClientPlayerState inventorySlotsClientPlayerState = item.Value ?? new InventorySlotsClientPlayerState();
					InventorySlotsClientPlayerState inventorySlotsClientPlayerState2 = inventorySlotsClientPlayerState;
					if (inventorySlotsClientPlayerState2.FavoriteSlots == null)
					{
						List<InventorySlotsFavoriteSlot> list = (inventorySlotsClientPlayerState2.FavoriteSlots = new List<InventorySlotsFavoriteSlot>());
					}
					inventorySlotsClientPlayerState2 = inventorySlotsClientPlayerState;
					if (inventorySlotsClientPlayerState2.CraftingFavorites == null)
					{
						List<string> list3 = (inventorySlotsClientPlayerState2.CraftingFavorites = new List<string>());
					}
					inventorySlotsClientPlayerState2 = inventorySlotsClientPlayerState;
					if (inventorySlotsClientPlayerState2.UpgradeFavorites == null)
					{
						List<string> list3 = (inventorySlotsClientPlayerState2.UpgradeFavorites = new List<string>());
					}
					dictionary[item.Key.Trim()] = inventorySlotsClientPlayerState;
				}
			}
			state.Players = dictionary;
			return state;
		}
	}
	internal sealed class InventorySlotsFavoriteSlot
	{
		public int X { get; set; }

		public int Y { get; set; }
	}
	internal sealed class InventorySlotsClientState
	{
		public int Version { get; set; } = 1;

		public InventorySlotsClientInventoryState Inventory { get; set; } = new InventorySlotsClientInventoryState();

		public Dictionary<string, InventorySlotsClientPlayerState> Players { get; set; } = new Dictionary<string, InventorySlotsClientPlayerState>(StringComparer.OrdinalIgnoreCase);
	}
	internal sealed class InventorySlotsClientInventoryState
	{
		public int LastExpandableRows { get; set; } = 4;

		public InventorySlotsClientPanelPosition EquipmentSlotsPanelPosition { get; set; } = new InventorySlotsClientPanelPosition(-80f, 0f);

		public InventorySlotsClientPanelPosition QuickSlotsPanelPosition { get; set; } = new InventorySlotsClientPanelPosition(-80f, -552f);

		public InventorySlotsClientPanelPosition QuickSlotsHudPosition { get; set; } = new InventorySlotsClientPanelPosition(64f, -520f);

		public float QuickSlotsHudElementSpace { get; set; } = 70f;
	}
	internal sealed class InventorySlotsClientPanelPosition
	{
		public float X { get; set; }

		public float Y { get; set; }

		public InventorySlotsClientPanelPosition()
		{
		}

		public InventorySlotsClientPanelPosition(float x, float y)
		{
			X = x;
			Y = y;
		}
	}
	internal sealed class InventorySlotsClientPlayerState
	{
		public List<InventorySlotsFavoriteSlot> FavoriteSlots { get; set; } = new List<InventorySlotsFavoriteSlot>();

		public List<string> CraftingFavorites { get; set; } = new List<string>();

		public List<string> UpgradeFavorites { get; set; } = new List<string>();
	}
	[HarmonyPatch]
	internal static class CurrencyPocketOverlapDetectionInventorySlotsPatch
	{
		private static bool Prepare()
		{
			MethodBase method;
			return InventorySlotsPlugin.TryGetCurrencyPocketOverlapDetectionMethod(out method);
		}

		private static MethodBase TargetMethod()
		{
			InventorySlotsPlugin.TryGetCurrencyPocketOverlapDetectionMethod(out MethodBase method);
			return method;
		}

		[HarmonyPriority(0)]
		private static void Postfix(ref bool __result)
		{
			__result = true;
		}
	}
	internal static class ContainerActionCore
	{
		internal static int CountMovedAmount(int before, int after, int requestedAmount, bool moveSucceeded, bool useMoveSucceededFallback)
		{
			int num = Math.Max(0, before - after);
			if (!(num == 0 && moveSucceeded && useMoveSucceededFallback))
			{
				return num;
			}
			return Math.Max(0, requestedAmount);
		}

		internal static int CompareGridOrder(int leftX, int leftY, int rightX, int rightY)
		{
			int num = leftY.CompareTo(rightY);
			if (num == 0)
			{
				return leftX.CompareTo(rightX);
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnTakeAll")]
	internal static class InventoryGuiSafeTakeAllPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			if (!InventorySlotsPlugin.ShouldBlockContainerPreviewInteraction(__instance))
			{
				return !InventorySlotsPlugin.TryHandleSafeTakeAll(__instance);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnStackAll")]
	internal static class InventoryGuiPlaceStacksPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			if (!InventorySlotsPlugin.ShouldBlockContainerPreviewInteraction(__instance))
			{
				return !InventorySlotsPlugin.TryHandleVanillaPlaceStacks(__instance);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Show")]
	internal static class InventoryGuiShowValidateInventoryPatch
	{
		private static void Prefix()
		{
			InventorySlotsPlugin.BeforeRealInventoryGuiShown();
		}

		private static void Postfix()
		{
			InventorySlotsPlugin.OnInventoryGuiShow();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	internal static class InventoryGuiHideRestoreContainerPanelPatch
	{
		private static void Postfix()
		{
			InventorySlotsPlugin.OnInventoryGuiHide();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "CloseContainer")]
	internal static class InventoryGuiCloseContainerRestorePanelPatch
	{
		private static void Postfix()
		{
			InventorySlotsPlugin.OnInventoryGuiCloseContainer();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateContainer")]
	internal static class InventoryGuiUpdateContainerInventorySlotsPatch
	{
		private static bool Prefix(InventoryGui __instance, Player player)
		{
			return !InventorySlotsPlugin.TryUpdateMultiUserRemoteContainer(__instance, player);
		}

		private static void Postfix(InventoryGui __instance, Player player)
		{
			InventorySlotsPlugin.OnInventoryGuiUpdateContainer(__instance, player);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Update")]
	internal static class InventoryGuiContainerPreviewUpdatePatch
	{
		[HarmonyPriority(800)]
		private static void Prefix(InventoryGui __instance)
		{
			InventorySlotsPlugin.BeforeContainerPreviewGuiUpdate(__instance);
		}

		[HarmonyPriority(0)]
		private static void Postfix(InventoryGui __instance)
		{
			InventorySlotsPlugin.AfterContainerPreviewGuiUpdate(__instance);
		}
	}
	internal static class ContainerTransferCore
	{
		public static int Run<TContainer>(IEnumerable<TContainer?>? containers, Func<TContainer, bool> canUse, Func<TContainer, int> transfer, Action<TContainer, int>? onContainerMoved, Action? onAnyMoved) where TContainer : class
		{
			if (containers == null || canUse == null || transfer == null)
			{
				return 0;
			}
			int num = 0;
			foreach (TContainer container in containers)
			{
				if (container != null && canUse(container))
				{
					int num2 = transfer(container);
					num += num2;
					if (num2 > 0)
					{
						onContainerMoved?.Invoke(container, num2);
					}
				}
			}
			if (num > 0)
			{
				onAnyMoved?.Invoke();
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_RequestOpen")]
	internal static class ContainerRequestOpenMultiUserPatch
	{
		private static bool Prefix(Container __instance, long uid, long playerID)
		{
			return !InventorySlotsPlugin.TryHandleMultiUserContainerOpen(__instance, uid, playerID);
		}
	}
	[HarmonyPatch(typeof(Container), "StackAll")]
	internal static class ContainerStackAllFavoriteProtectionPatch
	{
		private static bool Prefix(Container __instance)
		{
			return !InventorySlotsPlugin.TryHandleContainerStackAll(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_TakeAllRespons")]
	internal static class ContainerTakeAllResponsInventorySlotsPatch
	{
		private static void Postfix(Container __instance, bool granted)
		{
			InventorySlotsPlugin.OnContainerTakeAllResponse(__instance, granted);
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	internal static class ContainerRestockHoverTextPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Container __instance, ref string __result)
		{
			InventorySlotsPlugin.AppendContainerRestockHoverText(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Container), "Interact")]
	internal static class ContainerRestockInteractPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(Container __instance, Humanoid character)
		{
			return !InventorySlotsPlugin.ShouldSuppressContainerInteractForRestock(__instance, character);
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	internal static class ContainerAwakeTombstoneHeightPatch
	{
		private static void Prefix(Container __instance)
		{
			InventorySlotsPlugin.EnsureTombstoneContainerHeight(__instance, reloadInventory: false, persistHeight: false);
		}

		private static void Postfix(Container __instance)
		{
			InventorySlotsPlugin.RegisterContainer(__instance);
			InventorySlotsPlugin.EnsureTombstoneContainerHeight(__instance, reloadInventory: false, persistHeight: true);
		}
	}
	[HarmonyPatch(typeof(Container), "OnDestroyed")]
	internal static class ContainerDestroyedInventorySlotsPatch
	{
		private static void Prefix(Container __instance)
		{
			ZNetView nview = __instance.m_nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val != null)
			{
				InventorySlotsPlugin.OnMultiUserContainerPermanentlyDestroyed(__instance, val);
			}
		}

		private static void Postfix(Container __instance)
		{
			InventorySlotsPlugin.UnregisterContainer(__instance);
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "OnZDODestroyed")]
	internal static class ContainerZdoDestroyedInventorySlotsPatch
	{
		[HarmonyPriority(800)]
		private static void Prefix(ZDO zdo)
		{
			InventorySlotsPlugin.OnMultiUserContainerZdoDestroyed(zdo);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "org.bepinex.plugins.jewelcrafting" })]
	internal static class InventoryGuiJewelcraftingPrimaryTabPreflightPatch
	{
		private static void Prefix(InventoryGui __instance)
		{
			InventorySlotsPlugin.NormalizeJewelcraftingSocketTabForPrimaryCraftingTab(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "com.maxsch.valheim.vnei", "org.bepinex.plugins.jewelcrafting", "Azumatt.Recycle_N_Reclaim" })]
	internal static class InventoryGuiCraftingPanelRedesignPatch
	{
		private static void Postfix(InventoryGui __instance)
		{
			InventorySlotsPlugin.UpdateCraftingPanelRedesign(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "org.bepinex.plugins.jewelcrafting", "Azumatt.Recycle_N_Reclaim" })]
	internal static class InventoryGuiCraftingRecipeRedesignPatch
	{
		private static void Postfix(InventoryGui __instance)
		{
			InventorySlotsPlugin.UpdateCraftingPanelRedesign(__instance, CraftingPanelUpdateReason.RecipeChanged);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnVariantSelected")]
	internal static class InventoryGuiCraftingRecipeVariantSelectedPatch
	{
		private static void Postfix(InventoryGui __instance, int index)
		{
			InventorySlotsPlugin.OnCraftingRecipeVariantSelected(__instance, index);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "org.bepinex.plugins.jewelcrafting" })]
	internal static class InventoryGuiJewelcraftingRecipeListPrimaryTabPreflightPatch
	{
		private static void Prefix(InventoryGui __instance)
		{
			InventorySlotsPlugin.NormalizeJewelcraftingSocketTabForPrimaryCraftingTab(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "com.maxsch.valheim.vnei", "org.bepinex.plugins.jewelcrafting" })]
	internal static class InventoryGuiCraftingRecipeListRedesignPatch
	{
		private static void Postfix(InventoryGui __instance)
		{
			InventorySlotsPlugin.OnCraftingRecipeListUpdated(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnCraftPressed")]
	internal static class InventoryGuiCraftingQueueStartPatch
	{
		private static void Prefix(InventoryGui __instance)
		{
			InventorySlotsPlugin.BeginCraftingInventoryLimitNotice();
			InventorySlotsPlugin.PrepareCraftingQueue(__instance);
		}

		private static void Postfix(InventoryGui __instance)
		{
			if (InventorySlotsPlugin.EndCraftingInventoryLimitNotice(showMessage: true))
			{
				InventorySlotsPlugin.ClearCraftingQueue();
			}
			InventorySlotsPlugin.ValidateCraftingQueueStarted(__instance);
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			InventorySlotsPlugin.EndCraftingInventoryLimitNotice(showMessage: false);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnCraftCancelPressed")]
	internal static class InventoryGuiCraftingQueueCancelPatch
	{
		private static void Postfix()
		{
			InventorySlotsPlugin.ClearCraftingQueue();
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class InventoryGuiUpgradeFavoriteCraftingPatch
	{
		private static void Prefix(InventoryGui __instance)
		{
			InventorySlotsPlugin.BeginCraftingInventoryLimitNotice();
			InventorySlotsPlugin.CaptureUpgradeFavoriteBeforeCrafting(__instance);
		}

		private static void Postfix(InventoryGui __instance, Player player)
		{
			InventorySlotsPlugin.RestoreUpgradeFavoriteAfterCrafting(__instance, player);
			if (InventorySlotsPlugin.EndCraftingInventoryLimitNotice(showMessage: true))
			{
				InventorySlotsPlugin.ClearCraftingQueue();
			}
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			InventorySlotsPlugin.EndCraftingInventoryLimitNotice(showMessage: false);
			return __exception;
		}
	}
	internal static class CraftingRecipeViewCore
	{
		public static int CompareWithSortKey(bool aIsFavorite, bool bIsFavorite, bool aCanCraft, bool bCanCraft, SortKey aSortKey, SortKey bSortKey, int aOriginalIndex, int bOriginalIndex, CraftingRecipeSortMode mode)
		{
			int num = CompareFavoriteAndCraftable(aIsFavorite, bIsFavorite, aCanCraft, bCanCraft);
			if (num != 0)
			{
				return num;
			}
			int num2 = SortKeyComparerCore.Compare(aSortKey, bSortKey, mode);
			if (num2 == 0)
			{
				return aOriginalIndex.CompareTo(bOriginalIndex);
			}
			return num2;
		}

		private static int CompareFavoriteAndCraftable(bool aIsFavorite, bool bIsFavorite, bool aCanCraft, bool bCanCraft)
		{
			if (aIsFavorite != bIsFavorite)
			{
				if (!aIsFavorite)
				{
					return 1;
				}
				return -1;
			}
			if (aCanCraft != bCanCraft)
			{
				if (!aCanCraft)
				{
					return 1;
				}
				return -1;
			}
			return 0;
		}
	}
	internal sealed class CraftingRecipeScrollbarMarker : MonoBehaviour
	{
		public bool Initialized { get; set; }
	}
	internal enum CraftingPanelUpdateReason
	{
		FrameTick,
		RecipeChanged,
		RecipeListChanged,
		StateChanged
	}
	internal enum CraftingTabAdapterKind
	{
		None,
		Vanilla,
		JewelcraftingSocket,
		RecycleNReclaim,
		Foreign
	}
	internal readonly struct CraftingTabAdapterState
	{
		public CraftingTabAdapterKind Kind { get; }

		public bool IsRedesign
		{
			get
			{
				CraftingTabAdapterKind kind = Kind;
				if ((uint)(kind - 1) <= 2u)
				{
					return true;
				}
				return false;
			}
		}

		public bool IsForeign => Kind == CraftingTabAdapterKind.Foreign;

		public bool IsJewelcraftingSocket => Kind == CraftingTabAdapterKind.JewelcraftingSocket;

		public bool IsRecycleNReclaim => Kind == CraftingTabAdapterKind.RecycleNReclaim;

		public bool UsesDefaultGroupRail => Kind != CraftingTabAdapterKind.RecycleNReclaim;

		public bool UsesRecycleNReclaimBottomControls => Kind == CraftingTabAdapterKind.RecycleNReclaim;

		public CraftingTabAdapterState(CraftingTabAdapterKind kind)
		{
			Kind = kind;
		}
	}
	internal static class CraftingStampMath
	{
		public static int Quantize(float value)
		{
			return (int)Math.Round(value * 1000f, MidpointRounding.AwayFromZero);
		}
	}
	internal readonly struct CraftingFrameFastPathStamp : IEquatable<CraftingFrameFastPathStamp>
	{
		public bool IsValid { get; }

		private int GuiId { get; }

		private int CraftingPanelId { get; }

		private int GridId { get; }

		private CraftingTabAdapterKind AdapterKind { get; }

		private int SelectedRecipeIndex { get; }

		private string RecipeViewSignature { get; }

		private int RecipePage { get; }

		private int GridDimension { get; }

		private int AvailabilityVersion { get; }

		private bool HasNoCraftCost { get; }

		private string PinnedTooltipGridSignature { get; }

		private int RecipeVariantVersion { get; }

		private int HoveredRecipeIndex { get; }

		private int ScreenWidth { get; }

		private int ScreenHeight { get; }

		public CraftingFrameFastPathStamp(int guiId, int craftingPanelId, int gridId, CraftingTabAdapterKind adapterKind, int selectedRecipeIndex, string recipeViewSignature, int recipePage, int gridDimension, int availabilityVersion, bool hasNoCraftCost, string pinnedTooltipGridSignature, int recipeVariantVersion, int hoveredRecipeIndex, int screenWidth, int screenHeight)
		{
			IsValid = true;
			GuiId = guiId;
			CraftingPanelId = craftingPanelId;
			GridId = gridId;
			AdapterKind = adapterKind;
			SelectedRecipeIndex = selectedRecipeIndex;
			RecipeViewSignature = recipeViewSignature ?? "";
			RecipePage = recipePage;
			GridDimension = gridDimension;
			AvailabilityVersion = availabilityVersion;
			HasNoCraftCost = hasNoCraftCost;
			PinnedTooltipGridSignature = pinnedTooltipGridSignature ?? "";
			RecipeVariantVersion = recipeVariantVersion;
			HoveredRecipeIndex = hoveredRecipeIndex;
			ScreenWidth = screenWidth;
			ScreenHeight = screenHeight;
		}

		public bool Equals(CraftingFrameFastPathStamp other)
		{
			if (IsValid == other.IsValid && GuiId == other.GuiId && CraftingPanelId == other.CraftingPanelId && GridId == other.GridId && AdapterKind == other.AdapterKind && SelectedRecipeIndex == other.SelectedRecipeIndex && string.Equals(RecipeViewSignature, other.RecipeViewSignature, StringComparison.Ordinal) && RecipePage == other.RecipePage && GridDimension == other.GridDimension && AvailabilityVersion == other.AvailabilityVersion && HasNoCraftCost == other.HasNoCraftCost && string.Equals(PinnedTooltipGridSignature, other.PinnedTooltipGridSignature, StringComparison.Ordinal) && RecipeVariantVersion == other.RecipeVariantVersion && HoveredRecipeIndex == other.HoveredRecipeIndex && ScreenWidth == other.ScreenWidth)
			{
				return ScreenHeight == other.ScreenHeight;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (int)(((((((((((((((((((((((uint)((((((((IsValid ? 1 : 0) * 397) ^ GuiId) * 397) ^ CraftingPanelId) * 397) ^ GridId) * 397) ^ (uint)AdapterKind) * 397) ^ (uint)SelectedRecipeIndex) * 397) ^ (uint)StringComparer.Ordinal.GetHashCode(RecipeViewSignature ?? "")) * 397) ^ (uint)RecipePage) * 397) ^ (uint)GridDimension) * 397) ^ (uint)AvailabilityVersion) * 397) ^ (uint)HasNoCraftCost.GetHashCode()) * 397) ^ (uint)StringComparer.Ordinal.GetHashCode(PinnedTooltipGridSignature ?? "")) * 397) ^ (uint)RecipeVariantVersion) * 397) ^ (uint)HoveredRecipeIndex) * 397) ^ (uint)ScreenWidth) * 397) ^ ScreenHeight;
		}
	}
	internal readonly struct CraftingRecipeGridStamp : IEquatable<CraftingRecipeGridStamp>
	{
		public bool IsValid { get; }

		private int Dimension { get; }

		private int PageStart { get; }

		private int SelectedIndex { get; }

		private int AvailabilityHash { get; }

		private string PinnedTooltipGridSignature { get; }

		private int ViewCount { get; }

		private int RecipeVariantVersion { get; }

		public CraftingRecipeGridStamp(int dimension, int pageStart, int selectedIndex, int availabilityHash, string pinnedTooltipGridSignature, int viewCount, int recipeVariantVersion)
		{
			IsValid = true;
			Dimension = dimension;
			PageStart = pageStart;
			SelectedIndex = selectedIndex;
			AvailabilityHash = availabilityHash;
			PinnedTooltipGridSignature = pinnedTooltipGridSignature ?? "";
			ViewCount = viewCount;
			RecipeVariantVersion = recipeVariantVersion;
		}

		public bool Equals(CraftingRecipeGridStamp other)
		{
			if (IsValid == other.IsValid && Dimension == other.Dimension && PageStart == other.PageStart && SelectedIndex == other.SelectedIndex && AvailabilityHash == other.AvailabilityHash && string.Equals(PinnedTooltipGridSignature, other.PinnedTooltipGridSignature, StringComparison.Ordinal) && ViewCount == other.ViewCount)
			{
				return RecipeVariantVersion == other.RecipeVariantVersion;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((((((((IsValid ? 1 : 0) * 397) ^ Dimension) * 397) ^ PageStart) * 397) ^ SelectedIndex) * 397) ^ AvailabilityHash) * 397) ^ StringComparer.Ordinal.GetHashCode(PinnedTooltipGridSignature ?? "")) * 397) ^ ViewCount) * 397) ^ RecipeVariantVersion;
		}
	}
	internal readonly struct CraftingRecipeScrollbarStamp : IEquatable<CraftingRecipeScrollbarStamp>
	{
		public bool IsValid { get; }

		private int PageCount { get; }

		private int RecipePage { get; }

		private bool Visible { get; }

		private int GridX { get; }

		private int GridY { get; }

		public CraftingRecipeScrollbarStamp(int pageCount, int recipePage, bool visible, float gridX, float gridY)
		{
			IsValid = true;
			PageCount = pageCount;
			RecipePage = recipePage;
			Visible = visible;
			GridX = CraftingStampMath.Quantize(gridX);
			GridY = CraftingStampMath.Quantize(gridY);
		}

		public bool Equals(CraftingRecipeScrollbarStamp other)
		{
			if (IsValid == other.IsValid && PageCount == other.PageCount && RecipePage == other.RecipePage && Visible == other.Visible && GridX == other.GridX)
			{
				return GridY == other.GridY;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((((IsValid ? 1 : 0) * 397) ^ PageCount) * 397) ^ RecipePage) * 397) ^ Visible.GetHashCode()) * 397) ^ GridX) * 397) ^ GridY;
		}
	}
	internal readonly struct CraftingGroupRailStamp : IEquatable<CraftingGroupRailStamp>
	{
		public bool IsValid { get; }

		private int CraftingPanelId { get; }

		private int GridId { get; }

		private int GridX { get; }

		private int GridY { get; }

		private string SelectedGroupId { get; }

		private int FavoritesVersion { get; }

		private int IconBackgroundAlpha { get; }

		private string AvailabilitySignature { get; }

		private string SelectableGroupIdsSignature { get; }

		public CraftingGroupRailStamp(int craftingPanelId, int gridId, float gridX, float gridY, string selectedGroupId, int favoritesVersion, float iconBackgroundAlpha, string availabilitySignature, string selectableGroupIdsSignature)
		{
			IsValid = true;
			CraftingPanelId = craftingPanelId;
			GridId = gridId;
			GridX = CraftingStampMath.Quantize(gridX);
			GridY = CraftingStampMath.Quantize(gridY);
			SelectedGroupId = selectedGroupId ?? "";
			FavoritesVersion = favoritesVersion;
			IconBackgroundAlpha = CraftingStampMath.Quantize(iconBackgroundAlpha);
			AvailabilitySignature = availabilitySignature ?? "";
			SelectableGroupIdsSignature = selectableGroupIdsSignature ?? "";
		}

		public bool Equals(CraftingGroupRailStamp other)
		{
			if (IsValid == other.IsValid && CraftingPanelId == other.CraftingPanelId && GridId == other.GridId && GridX == other.GridX && GridY == other.GridY && string.Equals(SelectedGroupId, other.SelectedGroupId, StringComparison.Ordinal) && FavoritesVersion == other.FavoritesVersion && IconBackgroundAlpha == other.IconBackgroundAlpha && string.Equals(AvailabilitySignature, other.AvailabilitySignature, StringComparison.Ordinal))
			{
				return string.Equals(SelectableGroupIdsSignature, other.SelectableGroupIdsSignature, StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((((((((((((IsValid ? 1 : 0) * 397) ^ CraftingPanelId) * 397) ^ GridId) * 397) ^ GridX) * 397) ^ GridY) * 397) ^ StringComparer.Ordinal.GetHashCode(SelectedGroupId ?? "")) * 397) ^ FavoritesVersion) * 397) ^ IconBackgroundAlpha) * 397) ^ StringComparer.Ordinal.GetHashCode(AvailabilitySignature ?? "")) * 397) ^ StringComparer.Ordinal.GetHashCode(SelectableGroupIdsSignature ?? "");
		}
	}
	internal readonly struct CraftingSearchInputStamp : IEquatable<CraftingSearchInputStamp>
	{
		public bool IsValid { get; }

		private int CraftingPanelId { get; }

		private int InputId { get; }

		private int PositionX { get; }

		private int PositionY { get; }

		private int SizeX { get; }

		private int SizeY { get; }

		private string SearchQuery { get; }

		private int LocalizationVersion { get; }

		private bool Focused { get; }

		private int TabImageId { get; }

		private int TabSpriteId { get; }

		private int TabMaterialId { get; }

		public CraftingSearchInputStamp(int craftingPanelId, int inputId, float positionX, float positionY, float sizeX, float sizeY, string searchQuery, int localizationVersion, bool focused, int tabImageId, int tabSpriteId, int tabMaterialId)
		{
			IsValid = true;
			CraftingPanelId = craftingPanelId;
			InputId = inputId;
			PositionX = CraftingStampMath.Quantize(positionX);
			PositionY = CraftingStampMath.Quantize(positionY);
			SizeX = CraftingStampMath.Quantize(sizeX);
			SizeY = CraftingStampMath.Quantize(sizeY);
			SearchQuery = searchQuery ?? "";
			LocalizationVersion = localizationVersion;
			Focused = focused;
			TabImageId = tabImageId;
			TabSpriteId = tabSpriteId;
			TabMaterialId = tabMaterialId;
		}

		public bool Equals(CraftingSearchInputStamp other)
		{
			if (IsValid == other.IsValid && CraftingPanelId == other.CraftingPanelId && InputId == other.InputId && PositionX == other.PositionX && PositionY == other.PositionY && SizeX == other.SizeX && SizeY == other.SizeY && string.Equals(SearchQuery, other.SearchQuery, StringComparison.Ordinal) && LocalizationVersion == other.LocalizationVersion && Focused == other.Focused && TabImageId == other.TabImageId && TabSpriteId == other.TabSpriteId)
			{
				return TabMaterialId == other.TabMaterialId;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((((((((((((((((((IsValid ? 1 : 0) * 397) ^ CraftingPanelId) * 397) ^ InputId) * 397) ^ PositionX) * 397) ^ PositionY) * 397) ^ SizeX) * 397) ^ SizeY) * 397) ^ StringComparer.Ordinal.GetHashCode(SearchQuery ?? "")) * 397) ^ LocalizationVersion) * 397) ^ Focused.GetHashCode()) * 397) ^ TabImageId) * 397) ^ TabSpriteId) * 397) ^ TabMaterialId;
		}
	}
	internal readonly struct CraftingSortModeButtonsStamp : IEquatable<CraftingSortModeButtonsStamp>
	{
		public bool IsValid { get; }

		private int CraftingPanelId { get; }

		private int GroupId { get; }

		private int PositionX { get; }

		private int PositionY { get; }

		private int SizeX { get; }

		private int SizeY { get; }

		private int ButtonSize { get; }

		private CraftingRecipeSortMode Mode { get; }

		private int LocalizationVersion { get; }

		private int TabImageId { get; }

		private int TabSpriteId { get; }

		private int TabMaterialId { get; }

		public CraftingSortModeButtonsStamp(int craftingPanelId, int groupId, float positionX, float positionY, float sizeX, float sizeY, float buttonSize, CraftingRecipeSortMode mode, int localizationVersion, int tabImageId, int tabSpriteId, int tabMaterialId)
		{
			IsValid = true;
			CraftingPanelId = craftingPanelId;
			GroupId = groupId;
			PositionX = CraftingStampMath.Quantize(positionX);
			PositionY = CraftingStampMath.Quantize(positionY);
			SizeX = CraftingStampMath.Quantize(sizeX);
			SizeY = CraftingStampMath.Quantize(sizeY);
			ButtonSize = CraftingStampMath.Quantize(buttonSize);
			Mode = mode;
			LocalizationVersion = localizationVersion;
			TabImageId = tabImageId;
			TabSpriteId = tabSpriteId;
			TabMaterialId = tabMaterialId;
		}

		public bool Equals(CraftingSortModeButtonsStamp other)
		{
			if (IsValid == other.IsValid && CraftingPanelId == other.CraftingPanelId && GroupId == other.GroupId && PositionX == other.PositionX && PositionY == other.PositionY && SizeX == other.SizeX && SizeY == other.SizeY && ButtonSize == other.ButtonSize && Mode == other.Mode && LocalizationVersion == other.LocalizationVersion && TabImageId == other.TabImageId && TabSpriteId == other.TabSpriteId)
			{
				return TabMaterialId == other.TabMaterialId;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (int)(((((((((uint)((((((((((((((((IsValid ? 1 : 0) * 397) ^ CraftingPanelId) * 397) ^ GroupId) * 397) ^ PositionX) * 397) ^ PositionY) * 397) ^ SizeX) * 397) ^ SizeY) * 397) ^ ButtonSize) * 397) ^ (uint)Mode) * 397) ^ (uint)LocalizationVersion) * 397) ^ (uint)TabImageId) * 397) ^ (uint)TabSpriteId) * 397) ^ TabMaterialId;
		}
	}
	internal readonly struct CraftingStatusHudStamp : IEquatable<CraftingStatusHudStamp>
	{
		public bool IsValid { get; }

		private int CraftingPanelId { get; }

		private int GridId { get; }

		private int PositionX { get; }

		private int PositionY { get; }

		private int SizeX { get; }

		private int SizeY { get; }

		private string Warning { get; }

		public CraftingStatusHudStamp(int craftingPanelId, int gridId, float positionX, float positionY, float sizeX, float sizeY, string warning)
		{
			IsValid = true;
			CraftingPanelId = craftingPanelId;
			GridId = gridId;
			PositionX = CraftingStampMath.Quantize(positionX);
			PositionY = CraftingStampMath.Quantize(positionY);
			SizeX = CraftingStampMath.Quantize(sizeX);
			SizeY = CraftingStampMath.Quantize(sizeY);
			Warning = warning ?? "";
		}

		public bool Equals(CraftingStatusHudStamp other)
		{
			if (IsValid == other.IsValid && CraftingPanelId == other.CraftingPanelId && GridId == other.GridId && PositionX == other.PositionX && PositionY == other.PositionY && SizeX == other.SizeX && SizeY == other.SizeY)
			{
				return string.Equals(Warning, other.Warning, StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((((((((IsValid ? 1 : 0) * 397) ^ CraftingPanelId) * 397) ^ GridId) * 397) ^ PositionX) * 397) ^ PositionY) * 397) ^ SizeX) * 397) ^ SizeY) * 397) ^ StringComparer.Ordinal.GetHashCode(Warning ?? "");
		}
	}
	internal readonly struct CraftingTextStamp : IEquatable<CraftingTextStamp>
	{
		public bool IsValid { get; }

		private string Scope { get; }

		private string Text { get; }

		private string ChildSignature { get; }

		private int FontSizeMax { get; }

		public CraftingTextStamp(string scope, string text, string childSignature = "", float fontSizeMax = 0f)
		{
			IsValid = true;
			Scope = scope ?? "";
			Text = text ?? "";
			ChildSignature = childSignature ?? "";
			FontSizeMax = CraftingStampMath.Quantize(fontSizeMax);
		}

		public bool Equals(CraftingTextStamp other)
		{
			if (IsValid == other.IsValid && string.Equals(Scope, other.Scope, StringComparison.Ordinal) && string.Equals(Text, other.Text, StringComparison.Ordinal) && string.Equals(ChildSignature, other.ChildSignature, StringComparison.Ordinal))
			{
				return FontSizeMax == other.FontSizeMax;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((IsValid ? 1 : 0) * 397) ^ StringComparer.Ordinal.GetHashCode(Scope ?? "")) * 397) ^ StringComparer.Ordinal.GetHashCode(Text ?? "")) * 397) ^ StringComparer.Ordinal.GetHashCode(ChildSignature ?? "")) * 397) ^ FontSizeMax;
		}
	}
	internal readonly struct CraftingTextColorStamp : IEquatable<CraftingTextColorStamp>
	{
		public bool IsValid { get; }

		private bool Interactable { get; }

		private int ColorR { get; }

		private int ColorG { get; }

		private int ColorB { get; }

		private int ColorA { get; }

		private string ChildSignature { get; }

		public CraftingTextColorStamp(bool interactable, float colorR, float colorG, float colorB, float colorA, string childSignature)
		{
			IsValid = true;
			Interactable = interactable;
			ColorR = CraftingStampMath.Quantize(colorR);
			ColorG = CraftingStampMath.Quantize(colorG);
			ColorB = CraftingStampMath.Quantize(colorB);
			ColorA = CraftingStampMath.Quantize(colorA);
			ChildSignature = childSignature ?? "";
		}

		public bool Equals(CraftingTextColorStamp other)
		{
			if (IsValid == other.IsValid && Interactable == other.Interactable && ColorR == other.ColorR && ColorG == other.ColorG && ColorB == other.ColorB && ColorA == other.ColorA)
			{
				return string.Equals(ChildSignature, other.ChildSignature, StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((((((IsValid ? 1 : 0) * 397) ^ Interactable.GetHashCode()) * 397) ^ ColorR) * 397) ^ ColorG) * 397) ^ ColorB) * 397) ^ ColorA) * 397) ^ StringComparer.Ordinal.GetHashCode(ChildSignature ?? "");
		}
	}
	internal readonly struct CraftingSimpleTooltipStamp : IEquatable<CraftingSimpleTooltipStamp>
	{
		public bool IsValid { get; }

		private string Topic { get; }

		private string Text { get; }

		public CraftingSimpleTooltipStamp(string topic, string text)
		{
			IsValid = true;
			Topic = topic ?? "";
			Text = text ?? "";
		}

		public bool Equals(CraftingSimpleTooltipStamp other)
		{
			if (IsValid == other.IsValid && string.Equals(Topic, other.Topic, StringComparison.Ordinal))
			{
				return string.Equals(Text, other.Text, StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((IsValid ? 1 : 0) * 397) ^ StringComparer.Ordinal.GetHashCode(Topic ?? "")) * 397) ^ StringComparer.Ordinal.GetHashCode(Text ?? "");
		}
	}
	[HarmonyPatch(typeof(Player), "UnequipDeathDropItems")]
	internal static class PlayerUnequipDeathDropItemsInventorySlotsPatch
	{
		private static void Prefix(Player __instance, out bool __state)
		{
			__state = InventorySlotsPlugin.PreparePlayerDeathDropUnequip(__instance);
		}

		private static void Finalizer(bool __state)
		{
			InventorySlotsPlugin.CompletePlayerDeathDropUnequip(__state);
		}
	}
	[HarmonyPatch(typeof(Player), "CreateTombStone")]
	internal static class PlayerCreateTombStoneKeepOnDeathPatch
	{
		private static void Prefix(Player __instance, out InventorySlotsPlugin.TombStonePreparationState __state)
		{
			__state = InventorySlotsPlugin.PrepareCreateTombStone(__instance);
		}

		private static void Postfix(Player __instance, InventorySlotsPlugin.TombStonePreparationState __state)
		{
			InventorySlotsPlugin.CompleteCreateTombStone(__instance, __state);
		}

		private static void Finalizer(Player __instance, InventorySlotsPlugin.TombStonePreparationState __state)
		{
			InventorySlotsPlugin.CompleteCreateTombStone(__instance, __state);
		}
	}
	[HarmonyPatch(typeof(TombStone), "Interact")]
	internal static class TombStoneInteractHeightPatch
	{
		private static void Prefix(TombStone __instance, bool hold)
		{
			InventorySlotsPlugin.OnTombStoneInteract(__instance, hold);
		}
	}
	[HarmonyPatch(typeof(TombStone), "EasyFitInInventory")]
	internal static class TombStoneEasyFitInInventoryPatch
	{
		private static bool Prefix(TombStone __instance, Player player, ref bool __result)
		{
			return InventorySlotsPlugin.TryOverrideTombStoneEasyFit(__instance, player, ref __result);
		}

		private static void Postfix(Player player)
		{
			InventorySlotsPlugin.OnTombStoneInventoryStateChanged(player);
		}
	}
	[HarmonyPatch(typeof(TombStone), "OnTakeAllSuccess")]
	internal static class TombStoneOnTakeAllSuccessPatch
	{
		private static void Postfix(TombStone __instance)
		{
			InventorySlotsPlugin.OnTombStoneTakeAllSuccess(__instance);
		}
	}
	[HarmonyPatch(typeof(UITooltip), "OnHoverStart")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "randyknapp.mods.epicloot" })]
	internal static class UITooltipOnHoverStartHideTooltipFromEpicLootPatch
	{
		private static void Postfix(GameObject go)
		{
			InventorySlotsPlugin.HideTooltipFromEpicLootOnHoverPostfix(go);
		}
	}
	[HarmonyPatch(typeof(UITooltip), "OnHoverStart")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot" })]
	internal static class UITooltipOnHoverStartRestoreTooltipAfterEpicLootPatch
	{
		private static void Postfix()
		{
			InventorySlotsPlugin.RestoreTooltipAfterEpicLootOnHoverPostfix();
		}
	}
	[HarmonyPatch]
	internal static class EpicLootPatchOnHoverFixScrollbarInventorySlotsPatch
	{
		private static bool Prepare()
		{
			if (InventorySlotsPlugin.IsEpicLootLoadedForPatches())
			{
				return AccessTools.Method("EpicLoot.PatchOnHoverFix:Postfix", new Type[1] { typeof(GameObject) }, (Type[])null) != null;
			}
			return false;
		}

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method("EpicLoot.PatchOnHoverFix:Postfix", new Type[1] { typeof(GameObject) }, (Type[])null);
		}

		private static bool Prefix(GameObject go)
		{
			return InventorySlotsPlugin.ShouldRunEpicLootOnHoverPostfix(go);
		}
	}
	[HarmonyPatch]
	internal static class EpicLootPatchOnHoverFixComparisonInventorySlotsPatch
	{
		private static bool Prepare()
		{
			if (InventorySlotsPlugin.IsEpicLootLoadedForPatches())
			{
				return AccessTools.Method("EpicLoot.PatchOnHoverFix:AddComparisonTooltip", (Type[])null, (Type[])null) != null;
			}
			return false;
		}

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method("EpicLoot.PatchOnHoverFix:AddComparisonTooltip", (Type[])null, (Type[])null);
		}

		private static bool Prefix()
		{
			return InventorySlotsPlugin.ShouldRunEpicLootComparisonTooltipPatch();
		}
	}
	[HarmonyPatch]
	internal static class EpicLootPatchOnHoverFixAddScrollbarInventorySlotsPatch
	{
		private static bool Prepare()
		{
			if (InventorySlotsPlugin.IsEpicLootLoadedForPatches())
			{
				return AccessTools.Method("EpicLoot.PatchOnHoverFix:AddScrollbar", new Type[2]
				{
					typeof(GameObject),
					typeof(RectTransform)
				}, (Type[])null) != null;
			}
			return false;
		}

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method("EpicLoot.PatchOnHoverFix:AddScrollbar", new Type[2]
			{
				typeof(GameObject),
				typeof(RectTransform)
			}, (Type[])null);
		}

		private static bool Prefix(GameObject tooltipObject, RectTransform hoverTransform)
		{
			return InventorySlotsPlugin.ShouldRunEpicLootAddScrollbarPatch(tooltipObject, hoverTransform);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UpdateEquipmentStatusEffects")]
	internal static class HumanoidUpdateEquipmentStatusEffectsPatch
	{
		private static void Prefix(Humanoid __instance)
		{
			InventorySlotsPlugin.PrepareCustomEquipmentProjection(__instance);
		}

		private static void Postfix(Humanoid __instance)
		{
			InventorySlotsPlugin.ApplyPreparedCustomEquipmentStatusEffects(__instance);
		}

		private static void Finalizer()
		{
			InventorySlotsPlugin.ClearPreparedCustomEquipmentStatusEffects();
		}
	}
	[HarmonyPatch(typeof(SEMan), "RemoveStatusEffect", new Type[]
	{
		typeof(int),
		typeof(bool)
	})]
	internal static class SEManRemoveStatusEffectInventorySlotsPatch
	{
		private static void Prefix(SEMan __instance, ref int nameHash)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null && InventorySlotsPlugin.ShouldPreventCustomEquipmentStatusRemoval(__instance, nameHash))
			{
				nameHash = 0;
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "GetEquipmentWeight")]
	internal static class HumanoidGetEquipmentWeightPatch
	{
		private static void Postfix(Humanoid __instance, ref float __result)
		{
			if (InventorySlotsPlugin.IsLocalPlayerHumanoid(__instance, out Player player) && (Object)(object)player != (Object)null)
			{
				__result += InventorySlotsPlugin.GetProjectedCustomEquipmentWeight(player);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetEquipmentEitrRegenModifier")]
	internal static class PlayerGetEquipmentEitrRegenModifierPatch
	{
		private static void Postfix(Player __instance, ref float __result)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				__result += InventorySlotsPlugin.GetProjectedCustomEquipmentEitrRegenModifier(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetBodyArmor")]
	internal static class PlayerGetBodyArmorInventorySlotsPatch
	{
		private static void Postfix(Player __instance, ref float __result)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				__result += InventorySlotsPlugin.GetCustomEquipmentArmor(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "ApplyArmorDamageMods")]
	internal static class PlayerApplyArmorDamageModsInventorySlotsPatch
	{
		private static void Postfix(Player __instance, ref DamageModifiers mods)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				InventorySlotsPlugin.ApplyCustomEquipmentDamageModifiers(__instance, ref mods);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
	internal static class HumanoidUpdateEquipmentPatch
	{
		private static void Postfix(Humanoid __instance, float dt)
		{
			if (InventorySlotsPlugin.IsLocalPlayerHumanoid(__instance, out Player player) && (Object)(object)player != (Object)null)
			{
				InventorySlotsPlugin.DrainProjectedCustomEquipmentDurability(__instance, player, dt);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "GetSetCount")]
	internal static class HumanoidGetSetCountPatch
	{
		private static void Postfix(Humanoid __instance, string setName, ref int __result)
		{
			if (InventorySlotsPlugin.IsLocalPlayerHumanoid(__instance, out Player player) && (Object)(object)player != (Object)null)
			{
				__result += InventorySlotsPlugin.GetProjectedCustomEquipmentSetCount(player, setName);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateModifiers")]
	internal static class PlayerUpdateModifiersPatch
	{
		private static void Postfix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && Player.s_equipmentModifierSourceFields != null)
			{
				InventorySlotsPlugin.ApplyProjectedEquipmentModifierValues(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UseItem", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData),
		typeof(bool)
	})]
	internal static class HumanoidUseItemRouteToDedicatedSlotPatch
	{
		private static bool Prefix(Humanoid __instance, Inventory inventory, ItemData item)
		{
			return InventorySlotsPlugin.ShouldAllowHumanoidUseItem(__instance, inventory, item);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem", new Type[]
	{
		typeof(ItemData),
		typeof(bool)
	})]
	internal static class HumanoidEquipItemRouteToDedicatedSlotPatch
	{
		private static bool Prefix(Humanoid __instance, ItemData item, ref bool __result)
		{
			return !InventorySlotsPlugin.TryOverrideHumanoidEquipItem(__instance, item, ref __result);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "IsItemEquiped")]
	internal static class HumanoidIsItemEquipedPatch
	{
		private static void Postfix(Humanoid __instance, ItemData item, ref bool __result)
		{
			InventorySlotsPlugin.OnHumanoidIsItemEquipped(__instance, item, ref __result);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
	internal static class HumanoidUnequipItemPatch
	{
		private static void Prefix(Humanoid __instance, ItemData item, out bool __state)
		{
			__state = InventorySlotsPlugin.PrepareHumanoidUnequipItem(__instance, item);
		}

		private static void Postfix(Humanoid __instance, ItemData item, bool __state)
		{
			InventorySlotsPlugin.OnHumanoidUnequipItem(__instance, item, __state);
		}

		private static void Finalizer(bool __state)
		{
			InventorySlotsPlugin.CompleteHumanoidUnequipItem(__state);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UnequipAllItems")]
	internal static class HumanoidUnequipAllItemsPatch
	{
		private static void Postfix(Humanoid __instance)
		{
			InventorySlotsPlugin.OnHumanoidUnequipAllItems(__instance);
		}
	}
	internal enum FoodStat
	{
		None,
		Health,
		Stamina,
		Eitr
	}
	internal static class FoodStatCore
	{
		public static bool TryGetDominant(float health, float stamina, float eitr, out FoodStat stat)
		{
			stat = FoodStat.None;
			if (health <= 0f && stamina <= 0f && eitr <= 0f)
			{
				return false;
			}
			if (health >= stamina && health >= eitr)
			{
				stat = FoodStat.Health;
				return true;
			}
			if (stamina >= health && stamina >= eitr)
			{
				stat = FoodStat.Stamina;
				return true;
			}
			if (eitr >= health && eitr >= stamina)
			{
				stat = FoodStat.Eitr;
				return true;
			}
			return false;
		}
	}
	internal enum HoverTooltipSourceKind
	{
		None,
		InventoryContainer,
		InventorySlotsCrafting,
		VneiCrafting
	}
	internal static class HoverTooltipSourceCore
	{
		public static HoverTooltipSourceKind Classify(bool inventoryContainer, bool inventorySlotsCrafting, bool vneiCrafting)
		{
			if (inventoryContainer)
			{
				return HoverTooltipSourceKind.InventoryContainer;
			}
			if (vneiCrafting)
			{
				return HoverTooltipSourceKind.VneiCrafting;
			}
			if (!inventorySlotsCrafting)
			{
				return HoverTooltipSourceKind.None;
			}
			return HoverTooltipSourceKind.InventorySlotsCrafting;
		}

		public static bool UsesInventorySlotsOwnedHoverTooltip(HoverTooltipSourceKind kind)
		{
			return kind == HoverTooltipSourceKind.VneiCrafting;
		}

		public static bool SuppressesVanillaHoverStart(HoverTooltipSourceKind kind)
		{
			return kind == HoverTooltipSourceKind.VneiCrafting;
		}

		public static bool SuppressesVanillaLateUpdate(HoverTooltipSourceKind kind)
		{
			return kind == HoverTooltipSourceKind.VneiCrafting;
		}

		public static bool UsesCraftingHoverTooltipBackgroundAlpha(HoverTooltipSourceKind kind)
		{
			if (kind != HoverTooltipSourceKind.VneiCrafting)
			{
				return kind == HoverTooltipSourceKind.InventorySlotsCrafting;
			}
			return true;
		}

		public static bool SuppressesEpicLootTooltipLayout(HoverTooltipSourceKind kind)
		{
			if (kind != HoverTooltipSourceKind.VneiCrafting)
			{
				return kind == HoverTooltipSourceKind.InventorySlotsCrafting;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Hud), "SetHealthBarSize")]
	internal static class HudHealthBarLengthScalingPatch
	{
		private static void Prefix(ref float size)
		{
			InventorySlotsPlugin.ApplyHudHealthBarLengthScaling(ref size);
		}
	}
	[HarmonyPatch(typeof(Hud), "SetStaminaBarSize")]
	internal static class HudStaminaBarLengthScalingPatch
	{
		private static void Prefix(ref float size)
		{
			InventorySlotsPlugin.ApplyHudStaminaBarLengthScaling(ref size);
		}
	}
	[HarmonyPatch(typeof(Hud), "SetEitrBarSize")]
	internal static class HudEitrBarLengthScalingPatch
	{
		private static void Prefix(ref float size)
		{
			InventorySlotsPlugin.ApplyHudEitrBarLengthScaling(ref size);
		}
	}
	[HarmonyPatch(typeof(Hud), "SetAdrenalineBarSize")]
	internal static class HudAdrenalineBarLengthScalingPatch
	{
		private static void Prefix(ref float size)
		{
			InventorySlotsPlugin.ApplyHudAdrenalineBarLengthScaling(ref size);
		}
	}
	[HarmonyPatch(typeof(Hud), "UpdateFood")]
	internal static class HudFoodBarLengthScalingPatch
	{
		private static void Postfix(Hud __instance, Player player)
		{
			InventorySlotsPlugin.ApplyHudFoodBarLengthScaling(__instance, player);
		}
	}
	internal static class InventoryActionCellPolicyCore
	{
		internal static bool CanFavoriteSlot(InventoryCellKind kind)
		{
			if (kind == InventoryCellKind.RegularUnlocked || kind == InventoryCellKind.Hotbar || kind == InventoryCellKind.Quick)
			{
				return true;
			}
			return false;
		}

		internal static bool CanUseContainerActionSource(InventoryCellKind kind, bool includeHotbar)
		{
			if (kind != InventoryCellKind.RegularUnlocked)
			{
				if (includeHotbar)
				{
					return kind == InventoryCellKind.Hotbar;
				}
				return false;
			}
			return true;
		}

		internal static bool CanUseFavoriteRestockTarget(InventoryCellKind kind)
		{
			if (kind == InventoryCellKind.RegularUnlocked || kind == InventoryCellKind.Hotbar || kind == InventoryCellKind.Quick)
			{
				return true;
			}
			return false;
		}

		internal static bool CanTrashSlot(InventoryCellKind kind)
		{
			return kind == InventoryCellKind.RegularUnlocked;
		}
	}
	internal enum InventoryCellKind
	{
		Outside,
		RegularUnlocked,
		RegularLocked,
		Hotbar,
		ExternalReserved,
		Equipment,
		EquipmentLocked,
		CustomEquipment,
		Quick,
		QuickLocked
	}
	[HarmonyPatch(typeof(Chat), "HasFocus")]
	internal static class ChatHasFocusInventorySlotsInputPatch
	{
		private static void Postfix(ref bool __result)
		{
			__result = __result || InventorySlotsPlugin.IsCraftingSearchFocused();
		}
	}
	[HarmonyPatch(typeof(Player), "UseHotbarItem")]
	internal static class PlayerUseHotbarItemQuickSlotModifierPatch
	{
		private static bool Prefix(Player __instance, int index)
		{
			return !InventorySlotsPlugin.ShouldSuppressVanillaHotbarItemUse(__instance, index);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
	internal static class InventoryGuiDragSlotItemOutPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_002b: 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_0035: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (InventorySlotsPlugin.ShouldBlockContainerPreviewInteraction(__instance))
			{
				return false;
			}
			if (InventorySlotsPlugin.IsMultiUserContainerInteractionPending(__instance, grid, item, pos))
			{
				return false;
			}
			if ((int)mod == 3 && InventorySlotsPlugin.TryHandleMultiUserContainerDropSelectedItem(__instance, grid, item, pos))
			{
				return false;
			}
			InventorySlotsPlugin.TryPinInventoryItemTooltipFromSelection(__instance, grid, pos, mod);
			if (!InventorySlotsPlugin.TryHandleRegularItemDragIntoEquipmentSlot(__instance, grid, pos, mod))
			{
				return !InventorySlotsPlugin.TryHandleSlotItemDragOut(__instance, grid, pos, mod);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnRightClickItem")]
	internal static class InventoryGuiContainerPreviewRightClickPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos)
		{
			//IL_000d: 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 (InventorySlotsPlugin.ShouldBlockContainerPreviewInteraction(__instance))
			{
				return false;
			}
			if (InventorySlotsPlugin.IsMultiUserContainerInteractionPending(__instance, grid, item, pos))
			{
				return false;
			}
			return !InventorySlotsPlugin.TryHandleMultiUserContainerRightClick(__instance, grid, item, pos);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "SetupDragItem")]
	internal static class InventoryGuiContainerPreviewDragPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			return !InventorySlotsPlugin.ShouldBlockContainerPreviewInteraction(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnDropOutside")]
	internal static class InventoryGuiDropSlotItemOutsidePatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			if (InventorySlotsPlugin.ShouldBlockContainerPreviewInteraction(__instance) || InventorySlotsPlugin.TryHandleMultiUserContainerDropOutside(__instance))
			{
				return false;
			}
			return !InventorySlotsPlugin.TryHandleSlotItemDropOutside(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "OnLeftClick")]
	internal static class InventoryGridFavoriteLeftClickPatch
	{
		private static bool Prefix(InventoryGrid __instance, UIInputHandler clickHandler)
		{
			return InventorySlotsPlugin.HandleFavoriteClick(__instance, clickHandler, leftClick: true);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "OnRightClick")]
	internal static class InventoryGridFavoriteRightClickPatch
	{
		private static bool Prefix(InventoryGrid __instance, UIInputHandler element)
		{
			return InventorySlotsPlugin.HandleFavoriteClick(__instance, element, leftClick: false);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateInventory")]
	internal static class InventoryGuiUpdateInventoryPatch
	{
		private static void Postfix(InventoryGrid ___m_playerGrid, Player player)
		{
			InventorySlotsPlugin.OnInventoryGuiUpdateInventory(___m_playerGrid, player);
		}
	}
	[HarmonyPatch(typeof(Player), "Awake")]
	internal static class PlayerAwakePatch
	{
		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerAwake(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class PlayerOnSpawnedPatch
	{
		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerSpawned(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "Load")]
	internal static class PlayerLoadPatch
	{
		private static void Prefix(Player __instance, out bool __state)
		{
			__state = InventorySlotsPlugin.BeginPlayerInventoryLoad(__instance);
		}

		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerLoaded(__instance);
		}

		private static Exception? Finalizer(Player __instance, bool __state, Exception __exception)
		{
			InventorySlotsPlugin.EndPlayerInventoryLoad(__instance, __state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Player), "Save")]
	internal static class PlayerSavePatch
	{
		private static void Prefix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerSaving(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "ResetCharacter")]
	internal static class PlayerResetCharacterInventorySlotsPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerProgressionReset(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "ResetCharacterKnownItems")]
	internal static class PlayerResetCharacterKnownItemsInventorySlotsPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerProgressionReset(__instance);
		}
	}
	[HarmonyPatch(typeof(Game), "SpawnPlayer")]
	internal static class GameSpawnPlayerFinalizeInventorySlotsPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix()
		{
			InventorySlotsPlugin.OnGameSpawnPlayer();
		}
	}
	[HarmonyPatch(typeof(Player), "OnInventoryChanged")]
	internal static class PlayerInventoryChangedPatch
	{
		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerInventoryChanged(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "AddKnownItem")]
	internal static class PlayerAddKnownItemInventorySlotsPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(Player __instance)
		{
			return !InventorySlotsPlugin.ShouldSuppressKnownItemRediscovery(__instance);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "SetupEquipment")]
	internal static class HumanoidSetupEquipmentValidateInventoryPatch
	{
		private static void Postfix(Humanoid __instance)
		{
			InventorySlotsPlugin.OnHumanoidSetupEquipment(__instance);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
	internal static class HumanoidSetupVisEquipmentCustomVisualsPatch
	{
		private static void Postfix(Humanoid __instance, VisEquipment visEq, bool isRagdoll)
		{
			InventorySlotsPlugin.OnHumanoidSetupVisEquipment(__instance, isRagdoll);
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
	internal static class VisEquipmentUpdateEquipmentVisualsInventorySlotsPatch
	{
		private static void Postfix(VisEquipment __instance)
		{
			InventorySlotsPlugin.UpdateCustomEquipmentVisualsFromZdo(__instance);
		}
	}
	[HarmonyPatch(typeof(Inventory), "Load", new Type[] { typeof(ZPackage) })]
	internal static class InventoryLoadValidateInventorySlotsPatch
	{
		private static void Prefix(Inventory __instance, out bool __state)
		{
			__state = InventorySlotsPlugin.BeginInventoryLoad(__instance);
		}

		[HarmonyPriority(0)]
		private static void Postfix(Inventory __instance)
		{
			InventorySlotsPlugin.OnInventoryLoaded(__instance);
		}

		private static Exception? Finalizer(Inventory __instance, bool __state, Exception __exception)
		{
			InventorySlotsPlugin.EndInventoryLoad(__instance, __state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Inventory), "Load", new Type[] { typeof(ZPackage) })]
	internal static class InventoryLoadMultiUserContainerDragSafetyPatch
	{
		[HarmonyPriority(800)]
		private static void Postfix(Inventory __instance)
		{
			InventorySlotsPlugin.OnMultiUserContainerInventoryLoaded(__instance);
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveAll")]
	internal static class InventoryMoveAllPatch
	{
		private static void Postfix(Inventory __instance, Inventory fromInventory)
		{
			InventorySlotsPlugin.OnInventoryMoveAll(__instance, fromInventory);
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveInventoryToGrave")]
	internal static class InventoryMoveInventoryToGravePatch
	{
		private static void Prefix(Inventory __instance, Inventory original)
		{
			InventorySlotsPlugin.OnInventoryMoveInventoryToGrave(__instance, original);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "DropItem")]
	internal static class HumanoidDropInventorySlotsItemPatch
	{
		private static void Prefix(Humanoid __instance, Inventory inventory, ItemData item, int amount, out SlotDefinition? __state)
		{
			__state = InventorySlotsPlugin.PrepareHumanoidDropInventorySlotsItem(__instance, inventory, item, amount);
		}

		private static void Postfix(Humanoid __instance, Inventory inventory, ItemData item, bool __result, SlotDefinition? __state)
		{
			InventorySlotsPlugin.RestoreHumanoidDropInventorySlotsItem(__instance, inventory, item, __result, __state);
		}
	}
	[HarmonyPatch(typeof(Inventory), "FindEmptySlot")]
	internal static class InventoryFindEmptySlotPatch
	{
		private static bool Prefix(Inventory __instance, ref Vector2i __result)
		{
			return InventorySlotsPlugin.TryOverrideFindEmptySlot(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "FindFreeStackItem")]
	internal static class InventoryFindFreeStackItemPatch
	{
		private static bool Prefix(Inventory __instance, string name, int quality, float worldLevel, ref ItemData? __result)
		{
			return InventorySlotsPlugin.TryOverrideFindFreeStackItem(__instance, name, quality, worldLevel, ref __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "GetEmptySlots")]
	internal static class InventoryGetEmptySlotsPatch
	{
		private static bool Prefix(Inventory __instance, ref int __result)
		{
			return InventorySlotsPlugin.TryOverrideGetEmptySlots(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "HaveEmptySlot")]
	internal static class InventoryHaveEmptySlotPatch
	{
		private static bool Prefix(Inventory __instance, ref bool __result)
		{
			return InventorySlotsPlugin.TryOverrideHaveEmptySlot(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "CanAddItem", new Type[]
	{
		typeof(ItemData),
		typeof(int)
	})]
	internal static class InventoryCanAddItemPatch
	{
		private static bool Prefix(Inventory __instance, ItemData item, int stack, ref bool __result)
		{
			return InventorySlotsPlugin.TryOverrideCanAddItem(__instance, item, stack, ref __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[] { typeof(ItemData) })]
	internal static class InventoryAddItemDataPatch
	{
		private static bool Prefix(Inventory __instance, ItemData item, ref bool __result, out bool __state)
		{
			__state = false;
			if (!InventorySlotsPlugin.TryValidatePlayerInventoryLimit(__instance, item, item.m_stack, ref __result))
			{
				return false;
			}
			__state = InventorySlotsPlugin.BeginInventoryAddItemDataStackLookup(item);
			bool num = InventorySlotsPlugin.TryPreserveLoadedSlotTailItem(__instance, item, ref __result);
			if (!num)
			{
				InventorySlotsPlugin.EndInventoryAddItemDataStackLookup(__state);
				__state = false;
			}
			return num;
		}

		private static void Postfix(Inventory __instance, ItemData item, ref bool __result)
		{
			InventorySlotsPlugin.OnInventoryAddItemData(__instance, item, ref __result);
		}

		private static Exception? Finalizer(bool __state, Exception __exception)
		{
			InventorySlotsPlugin.EndInventoryAddItemDataStackLookup(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(int),
		typeof(int)
	})]
	internal static class InventoryAddItemXyPatch
	{
		private static bool Prefix(Inventory __instance, ref bool __result, ItemData item, int amount, ref int x, ref int y)
		{
			int amount2 = Math.Min(Math.Max(0, amount), Math.Max(0, item.m_stack));
			if (!InventorySlotsPlugin.TryValidatePlayerInventoryLimit(__instance, item, amount2, ref __result))
			{
				return false;
			}
			return InventorySlotsPlugin.TryValidatePlayerInventoryInsert(__instance, item, ref x, ref y, ref __result);
		}

		private static void Postfix(Inventory __instance, ItemData item, int x, int y, bool __result)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			InventorySlotsPlugin.OnPlayerInventoryItemPlaced(__instance, item, new Vector2i(x, y), __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
	{
		typeof(ItemData),
		typeof(Vector2i)
	})]
	internal static class InventoryAddItemPosPatch
	{
		private static bool Prefix(Inventory __instance, ref bool __result, ItemData item, ref Vector2i pos)
		{
			if (!InventorySlotsPlugin.TryValidatePlayerInventoryLimit(__instance, item, item.m_stack, ref __result))
			{
				return false;
			}
			return InventorySlotsPlugin.TryValidatePlayerInventoryInsert(__instance, item, ref pos, ref __result);
		}

		private static void Postfix(Inventory __instance, ItemData item, Vector2i pos, bool __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			InventorySlotsPlugin.OnPlayerInventoryItemPlaced(__instance, item, pos, __result);
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData),
		typeof(int),
		typeof(int),
		typeof(int)
	})]
	internal static class InventoryMoveItemToThisPatch
	{
		private static bool Prefix(Inventory __instance, ref bool __result, Inventory fromInventory, ItemData item, int amount, ref int x, ref int y, out bool __state)
		{
			__state = false;
			if (InventorySlotsPlugin.TryRouteMultiUserContainerPositionalMove(__instance, fromInventory, item, amount, x, y, out var result))
			{
				__state = true;
				__result = result;
				return false;
			}
			return InventorySlotsPlugin.TryValidatePlayerInventoryMoveItemToThis(__instance, ref __result, fromInventory, item, amount, ref x, ref y);
		}

		private static void Postfix(Inventory __instance, bool __result, ItemData item, int x, int y, bool __state)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!__state)
			{
				InventorySlotsPlugin.OnPlayerInventoryItemPlaced(__instance, item, new Vector2i(x, y), __result);
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData)
	})]
	internal static class InventoryMoveItemToThisAutoPatch
	{
		private static bool Prefix(Inventory __instance, Inventory fromInventory, ItemData item)
		{
			return !InventorySlotsPlugin.TryRouteMultiUserContainerAutoMove(__instance, fromInventory, item);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup", new Type[]
	{
		typeof(GameObject),
		typeof(bool),
		typeof(bool)
	})]
	internal static class HumanoidPickupInventoryLimitPatch
	{
		private static void Postfix(Humanoid __instance, GameObject go, bool __result)
		{
			InventorySlotsPlugin.OnHumanoidPickupResult(__instance, go, __result);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "DropItem")]
	internal static class InventoryGridDropItemPatch
	{
		private static bool Prefix(InventoryGrid __instance, Inventory fromInventory, ItemData item, int amount, Vector2i pos, ref bool __result)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (InventorySlotsPlugin.TryRouteMultiUserContainerDropItem(__instance, fromInventory, item, amount, pos, out var result))
			{
				__result = result;
				return false;
			}
			return InventorySlotsPlugin.ShouldAllowInventoryGridDropItem(__instance, item, pos);
		}
	}
	internal enum InventoryPlacementScope
	{
		General,
		Container,
		LocalPlayer,
		LoadPreservation
	}
	internal static class InventoryPlacementPolicyCore
	{
		public static bool TrySelectAutomaticPlacementCell(int inventoryWidth, int rowCount, bool preferHotbar, Func<int, int, bool> isAllowed, Func<int, int, bool> isOccupied, out InventorySlotSafetyCore.GridCell cell)
		{
			int width = Math.Max(1, inventoryWidth);
			int num = Math.Max(0, rowCount);
			if (preferHotbar)
			{
				if (TrySelectFirstFreeCellInRows(width, 0, Math.Min(1, num), isAllowed, isOccupied, out cell))
				{
					return true;
				}
				return TrySelectFirstFreeCellInRows(width, 1, num, isAllowed, isOccupied, out cell);
			}
			if (TrySelectFirstFreeCellInRows(width, 1, num, isAllowed, isOccupied, out cell))
			{
				return true;
			}
			return TrySelectFirstFreeCellInRows(width, 0, Math.Min(1, num), isAllowed, isOccupied, out cell);
		}

		public static int CountTopFirstPolicyEmptyCells(int inventoryWidth, int rowCount, Func<int, int, bool> isAllowed, Func<int, int, bool> isOccupied)
		{
			int num = Math.Max(1, inventoryWidth);
			int num2 = Math.Max(0, rowCount);
			int num3 = 0;
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < num; j++)
				{
					if (isAllowed(j, i) && !isOccupied(j, i))
					{
						num3++;
					}
				}
			}
			return num3;
		}

		public static bool CanAcceptInventoryLimit(long currentAmount, int incomingAmount, int maxAmount)
		{
			if (incomingAmount <= 0 || maxAmount < 0)
			{
				return true;
			}
			return Math.Max(0L, currentAmount) + incomingAmount <= maxAmount;
		}

		private static bool TrySelectFirstFreeCellInRows(int width, int startRow, int endRow, Func<int, int, bool> isAllowed, Func<int, int, bool> isOccupied, out InventorySlotSafetyCore.GridCell cell)
		{
			for (int i = startRow; i < endRow; i++)
			{
				for (int j = 0; j < width; j++)
				{
					if (isAllowed(j, i) && !isOccupied(j, i))
					{
						cell = new InventorySlotSafetyCore.GridCell(j, i);
						return true;
					}
				}
			}
			cell = new InventorySlotSafetyCore.GridCell(-1, -1);
			return false;
		}
	}
	internal sealed class QuickHudSlotMarker : MonoBehaviour
	{
		public int Index { get; set; }

		public Image? DurabilityFill { get; set; }

		public GameObject? DurabilityObject { get; set; }

		public TMP_Text? BindingText { get; set; }

		public string TooltipSignature { get; set; } = "";

		public string TooltipTopic { get; set; } = "";

		public string TooltipText { get; set; } = "";

		public string LayoutSignature { get; set; } = "";

		public string BindingSignature { get; set; } = "";

		public int TooltipHash { get; set; }
	}
	internal static class InventorySlotSafetyCore
	{
		public readonly struct GridCell
		{
			public int X { get; }

			public int Y { get; }

			public GridCell(int x, int y)
			{
				X = x;
				Y = y;
			}
		}

		public enum KeepOnDeathRestorePlan
		{
			OriginalSlot,
			EmptyQuickSlot,
			EmptySameSpecialKindSlot,
			OriginalCell,
			FirstFreeRegularCell,
			EmptyNonQuickSpecialSlot,
			PreserveWithoutOverwriting
		}

		public readonly struct KeepOnDeathRestoreOptions
		{
			public bool WasSpecialSlot { get; }

			public bool WasQuickSlot { get; }

			public bool OriginalSlotAvailable { get; }

			public bool EmptyQuickSlotAvailable { get; }

			public bool EmptySameSpecialKindSlotAvailable { get; }

			public bool OriginalCellAvailable { get; }

			public bool FreeRegularCellAvailable { get; }

			public bool EmptyNonQuickSpecialSlotAvailable { get; }

			public KeepOnDeathRestoreOptions(bool wasSpecialSlot, bool wasQuickSlot, bool originalSlotAvailable, bool emptyQuickSlotAvailable, bool emptySameSpecialKindSlotAvailable, bool originalCellAvailable, bool freeRegularCellAvailable, bool emptyNonQuickSpecialSlotAvailable)
			{
				WasSpecialSlot = wasSpecialSlot;
				WasQuickSlot = wasQuickSlot;
				OriginalSlotAvailable = originalSlotAvailable;
				EmptyQuickSlotAvailable = emptyQuickSlotAvailable;
				EmptySameSpecialKindSlotAvailable = emptySameSpecialKindSlotAvailable;
				OriginalCellAvailable = originalCellAvailable;
				FreeRegularCellAvailable = freeRegularCellAvailable;
				EmptyNonQuickSpecialSlotAvailable = emptyNonQuickSpecialSlotAvailable;
			}
		}

		public static bool CanAutoAdoptGridSlot(bool isInventorySlotsCustomEquipped, string? markedSlotId, string candidateSlotId)
		{
			if (!isInventorySlotsCustomEquipped)
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(markedSlotId))
			{
				return true;
			}
			string a = markedSlotId.Trim();
			string b = ((candidateSlotId == null) ? "" : candidateSlotId.Trim());
			return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
		}

		public static KeepOnDeathRestorePlan SelectKeepOnDeathRestorePlan(KeepOnDeathRestoreOptions options)
		{
			if (options.WasSpecialSlot)
			{
				if (options.OriginalSlotAvailable)
				{
					return KeepOnDeathRestorePlan.OriginalSlot;
				}
				if (options.WasQuickSlot && options.EmptyQuickSlotAvailable)
				{
					return KeepOnDeathRestorePlan.EmptyQuickSlot;
				}
				if (!options.WasQuickSlot && options.EmptySameSpecialKindSlotAvailable)
				{
					return KeepOnDeathRestorePlan.EmptySameSpecialKindSlot;
				}
			}
			if (options.OriginalCellAvailable)
			{
				return KeepOnDeathRestorePlan.OriginalCell;
			}
			if (!options.WasQuickSlot)
			{
				if (options.FreeRegularCellAvailable)
				{
					return KeepOnDeathRestorePlan.FirstFreeRegularCell;
				}
				if (options.EmptyNonQuickSpecialSlotAvailable)
				{
					return KeepOnDeathRestorePlan.EmptyNonQuickSpecialSlot;
				}
			}
			else if (options.FreeRegularCellAvailable)
			{
				return KeepOnDeathRestorePlan.FirstFreeRegularCell;
			}
			return KeepOnDeathRestorePlan.PreserveWithoutOverwriting;
		}

		public static int ResolveQuickSlotProgressionResetRows(int configuredRows, int naturallyUnlockedRows, Func<int, bool> tryClearRow)
		{
			int num = Math.Max(0, configuredRows);
			int num2 = ((num != 0) ? Math.Max(1, Math.Min(num, naturallyUnlockedRows)) : 0);
			for (int num3 = num; num3 > num2; num3--)
			{
				if (!tryClearRow(num3))
				{
					return num3;
				}
			}
			return num2;
		}

		public static GridCell SelectNonOverlappingPreservationCell(int inventoryWidth, int inventoryHeight, GridCell preferredCell, Func<int, int, bool> isOccupied)
		{
			int num = Math.Max(1, inventoryWidth);
			int num2 = Math.Max(0, inventoryHeight);
			if (preferredCell.X >= 0 && preferredCell.X < num && preferredCell.Y >= 0 && !isOccupied(preferredCell.X, preferredCell.Y))
			{
				return preferredCell;
			}
			int num3 = Math.Max(0, num2);
			for (int i = num3; i < num3 + num2 + 32; i++)
			{
				for (int j = 0; j < num; j++)
				{
					if (!isOccupied(j, i))
					{
						return new GridCell(j, i);
					}
				}
			}
			return new GridCell((preferredCell.X >= 0) ? ((preferredCell.X >= num) ? (num - 1) : preferredCell.X) : 0, num3 + num2 + 32);
		}

		public static bool IsInventorySlotsTailCell(int inventoryWidth, int fixedRegularRows, GridCell cell)
		{
			int num = Math.Max(1, inventoryWidth);
			int num2 = Math.Max(0, fixedRegularRows);
			if (cell.X >= 0 && cell.X < num)
			{
				return cell.Y >= num2;
			}
			return false;
		}

		public static bool TrySelectLoadPreservationTailCell(int inventoryWidth, int inventoryHeight, int fixedRegularRows, GridCell requestedCell, Func<int, int, bool> isOccupied, out GridCell selectedCell)
		{
			selectedCell = new GridCell(-1, -1);
			if (!IsInventorySlotsTailCell(inventoryWidth, fixedRegularRows, requestedCell))
			{
				return false;
			}
			selectedCell = SelectNonOverlappingPreservationCell(inventoryWidth, inventoryHeight, requestedCell, isOccupied);
			return true;
		}

		public static bool TrySelectFirstFreeCell(int inventoryWidth, int rowCount, Func<int, int, bool> isAllowed, Func<int, int, bool> isOccupied, out GridCell cell)
		{
			int num = Math.Max(1, inventoryWidth);
			int num2 = Math.Max(0, rowCount);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < num; j++)
				{
					if (isAllowed(j, i) && !isOccupied(j, i))
					{
						cell = new GridCell(j, i);
						return true;
					}
				}
			}
			cell = new GridCell(-1, -1);
			return false;
		}
	}
	public static class InventorySlotsApi
	{
		public static bool TryGetCustomEquippedItem(Player player, Func<ItemData?, bool> predicate, out ItemData? item)
		{
			return InventorySlotsPlugin.TryGetCustomEquippedItemForApi(player, predicate, out item);
		}

		public static bool TryGetCustomEquipmentVisualRoots(VisEquipment visEquipment, ItemData item, List<GameObject> roots)
		{
			return InventorySlotsPlugin.TryGetCustomEquipmentVisualRootsForApi(visEquipment, item, roots);
		}
	}
	internal static class InventorySlotsConfigCore
	{
		public static YamlRoot ParseYaml(string yaml)
		{
			if (string.IsNullOrWhiteSpace(yaml))
			{
				return new YamlRoot();
			}
			YamlRoot obj = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build().Deserialize<YamlRoot>(yaml) ?? new YamlRoot();
			List<YamlSlot> slots = obj.Slots;
			if (slots != null && slots.Any((YamlSlot slot) => slot == null))
			{
				throw new InvalidDataException("Slots cannot contain null entries.");
			}
			BuildInventoryLimits(obj);
			return obj;
		}

		public static bool TryParseYaml(string yaml, out YamlRoot config, out Exception? error)
		{
			try
			{
				config = ParseYaml(yaml);
				error = null;
				return true;
			}
			catch (Exception ex)
			{
				config = new YamlRoot();
				error = ex;
				return false;
			}
		}

		public static Dictionary<string, int> ParseResourceMapYaml(string yaml)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrWhiteSpace(yaml))
			{
				return dictionary;
			}
			YamlStream yamlStream = new YamlStream();
			using (StringReader input = new StringReader(yaml))
			{
				yamlStream.Load(input);
			}
			if (yamlStream.Documents.Count != 1)
			{
				throw new InvalidDataException("ResourceMap.yml must contain exactly one YAML document.");
			}
			YamlMappingNode obj = (yamlStream.Documents[0].RootNode as YamlMappingNode) ?? throw new InvalidDataException("ResourceMap.yml root must be a mapping of tier names to material lists.");
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			int num = 0;
			foreach (KeyValuePair<YamlNode, YamlNode> child in obj.Children)
			{
				if (!(child.Key is YamlScalarNode yamlScalarNode) || string.IsNullOrWhiteSpace(yamlScalarNode.Value))
				{
					throw new InvalidDataException("ResourceMap.yml contains an empty or structured tier name.");
				}
				string text = yamlScalarNode.Value.Trim();
				if (!hashSet.Add(text))
				{
					throw new InvalidDataException("ResourceMap.yml tier '" + text + "' is duplicated with different casing.");
				}
				foreach (YamlNode child2 in ((child.Value as YamlSequenceNode) ?? throw new InvalidDataException("ResourceMap.yml tier '" + text + "' must contain a YAML sequence.")).Children)
				{
					if (!(child2 is YamlScalarNode yamlScalarNode2) || string.IsNullOrWhiteSpace(yamlScalarNode2.Value))
					{
						throw new InvalidDataException("ResourceMap.yml tier '" + text + "' contains an empty or structured material.");
					}
					string text2 = NormalizeResourceToken(yamlScalarNode2.Value);
					if (string.IsNullOrWhiteSpace(text2))
					{
						throw new InvalidDataException("ResourceMap.yml tier '" + text + "' contains a material with no usable token.");
					}
					if (!dictionary.ContainsKey(text2))
					{
						dictionary[text2] = num;
					}
				}
				num++;
			}
			return dictionary;
		}

		public static bool TryParseResourceMapYaml(string yaml, out Dictionary<string, int> resourceTiers, out Exception? error)
		{
			try
			{
				resourceTiers = ParseResourceMapYaml(yaml);
				error = null;
				return true;
			}
			catch (Exception ex)
			{
				resourceTiers = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				error = ex;
				return false;
			}
		}

		public static Dictionary<string, int> BuildInventoryLimits(YamlRoot config)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, int> item in config?.InventoryLimits ?? new Dictionary<string, int>())
			{
				string text = item.Key?.Trim() ?? "";
				if (string.IsNullOrWhiteSpace(text))
				{
					throw new InvalidDataException("InventoryLimits contains an empty target.");
				}
				if (item.Value < 0)
				{
					throw new InvalidDataException("Inventory limit '" + text + "' cannot be negative.");
				}
				if (dictionary.ContainsKey(text))
				{
					throw new InvalidDataException("Inventory limit '" + text + "' is duplicated with different casing.");
				}
				dictionary[text] = item.Value;
			}
			return dictionary;
		}

		public static string CleanPrefabName(string name)
		{
			if (!string.IsNullOrWhiteSpace(name))
			{
				return name.Replace("(Clone)", "").Trim();
			}
			return "";
		}

		public static string StripLocalizationToken(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "";
			}
			string text = value.Trim();
			if (!text.StartsWith("$item_", StringComparison.OrdinalIgnoreCase))
			{
				return text.TrimStart(new char[1] { '$' });
			}
			return text.Substring("$item_".Length);
		}

		public static string NormalizeSlotId(string? id)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				return "";
			}
			return new string((from ch in id.Trim()
				where char.IsLetterOrDigit(ch) || ch == '_' || ch == '-' || ch == '.'
				select ch).ToArray()).ToLowerInvariant();
		}

		public static string NormalizeGroupId(string? id)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				return "";
			}
			return new string(id.Trim().Where(char.IsLetterOrDigit).ToArray()).ToLowerInvariant();
		}

		public static string NormalizeResourceToken(string? token)
		{
			if (string.IsNullOrWhiteSpace(token))
			{
				return "";
			}
			string text = CleanPrefabName(token.Trim());
			if (text.StartsWith("$item_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("$item_".Length);
			}
			else if (text.StartsWith("$", StringComparison.Ordinal))
			{
				text = text.Substring(1);
			}
			return new string(text.Where(char.IsLetterOrDigit).Select(char.ToLowerInvariant).ToArray());
		}
	}
	internal enum SlotKind
	{
		BuiltIn,
		CustomEquipment,
		Quick
	}
	internal enum PendingSlotUnequipDestination
	{
		PlayerInventory,
		Container,
		DropOutside
	}
	internal enum PlayerStatPanelKind
	{
		Armor,
		Between,
		Synergy,
		Weight,
		QuickStackMiniButton
	}
	internal sealed class SlotDefinition
	{
		private readonly Func<ItemData?, bool> _accepts;

		public string Id { get; }

		public string Name { get; }

		public SlotKind Kind { get; }

		public int QuickSlotIndex { get; }

		public SlotDefinition(string id, string name, SlotKind kind, Func<ItemData?, bool> accepts, int quickSlotIndex = -1)
		{
			Id = id;
			Name = name;
			Kind = kind;
			_accepts = accepts;
			QuickSlotIndex = quickSlotIndex;
		}

		public bool Accepts(ItemData? item)
		{
			return _accepts(item);
		}
	}
	internal sealed class PendingSlotEquip
	{
		public SlotDefinition Slot { get; }

		public float CreatedAt { get; }

		public PendingSlotEquip(SlotDefinition slot, float createdAt)
		{
			Slot = slot;
			CreatedAt = createdAt;
		}
	}
	internal sealed class PendingSlotUnequip
	{
		public SlotDefinition SourceSlot { get; }

		public PendingSlotUnequipDestination Destination { get; }

		public Inventory? TargetInventory { get; }

		public Vector2i TargetPos { get; }

		public int Amount { get; }

		public float CreatedAt { get; }

		public PendingSlotUnequip(SlotDefinition sourceSlot, PendingSlotUnequipDestination destination, Inventory? targetInventory, Vector2i targetPos, int amount, float createdAt)
		{
			//IL_001c: 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)
			SourceSlot = sourceSlot;
			Destination = destination;
			TargetInventory = targetInventory;
			TargetPos = targetPos;
			Amount = amount;
			CreatedAt = createdAt;
		}
	}
	internal sealed class InventoryPanelDragMarker : MonoBehaviour
	{
		public string PanelName { get; set; } = "";

		public bool Initialized { get; set; }
	}
	internal sealed class InventoryActionButtonMarker : MonoBehaviour
	{
		public bool Initialized { get; set; }

		public bool AutoSizeInitialized { get; set; }

		public string LabelSignature { get; set; } = "";
	}
	internal sealed class PinnedTooltipPanelUiCache : MonoBehaviour
	{
		public Image? Background { get; set; }

		public TMP_Text? BodyText { get; set; }

		public RectTransform? TextScrollView { get; set; }

		public RectTransform? TextViewport { get; set; }

		public RectTransform? TextContent { get; set; }

		public ScrollRect? TextScrollRect { get; set; }

		public Scrollbar? TextScrollbar { get; set; }

		public float TextWidth { get; set; }

		public float TextContentHeight { get; set; }

		public float TextViewportHeight { get; set; }

		public float TextTopReserved { get; set; }

		public float TextBottomReserved { get; set; }

		public bool TextHasViewportCap { get; set; }

		public string BackgroundSignature { get; set; } = "";

		public string TextLayoutSignature { get; set; } = "";

		public string TextRepairSignature { get; set; } = "";
	}
	internal sealed class JewelcraftingTooltipLayoutCache : MonoBehaviour
	{
		public string Signature { get; set; } = "";

		public string NativeComponentSignature { get; set; } = "";

		public string ItemPrefabName { get; set; } = "";

		public string ItemSharedName { get; set; } = "";

		public int ItemVariant { get; set; } = -1;

		public bool Visible { get; set; }

		public bool HasResolvedSocketGems { get; set; }

		public int RowlessRefreshAttempts { get; set; }

		public Transform? SourceRowsRoot { get; set; }

		public Transform? SourceInteract { get; set; }

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

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

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

		public ContentSizeFitter[] NativeContentSizeFitters { get; set; } = Array.Empty<ContentSizeFitter>();
	}
	internal sealed class InventoryGridElementUiCache : MonoBehaviour
	{
		public TMP_Text? BindingText { get; set; }

		public string BindingSignature { get; set; } = "";

		public string EquipmentTooltipSignature { get; set; } = "";

		public RectTransform? FavoriteBorder { get; set; }

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

		public RectTransform? PinnedTooltipMarker { get; set; }

		public TMP_Text? PinnedTooltipText { get; set; }
	}
	internal sealed class RectTransformSnapshot
	{
		private readonly Transform _parent;

		private readonly int _siblingIndex;

		private readonly Vector2 _anchorMin;

		private readonly Vector2 _anchorMax;

		private readonly Vector2 _pivot;

		private readonly Vector2 _sizeDelta;

		private readonly Vector2 _anchoredPosition;

		private readonly Vector2 _offsetMin;

		private readonly Vector2 _offsetMax;

		private readonly Vector3 _localPosition;

		private readonly Quaternion _localRotation;

		private readonly Vector3 _localScale;

		public RectTransform Rect { get; }

		public RectTransformSnapshot(RectTransform rect)
		{
			//IL_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Rect = rect;
			_parent = ((Transform)rect).parent;
			_siblingIndex = ((Transform)rect).GetSiblingIndex();
			_anchorMin = rect.anchorMin;
			_anchorMax = rect.anchorMax;
			_pivot = rect.pivot;
			_sizeDelta = rect.sizeDelta;
			_anchoredPosition = rect.anchoredPosition;
			_offsetMin = rect.offsetMin;
			_offsetMax = rect.offsetMax;
			_localPosition = ((Transform)rect).localPosition;
			_localRotation = ((Transform)rect).localRotation;
			_localScale = ((Transform)rect).localScale;
		}

		public void Restore()
		{
			//IL_004e: 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_0070: 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_0092: 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_00b4: 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_00d6: 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)
			if (!((Object)(object)Rect == (Object)null))
			{
				if ((Object)(object)_parent != (Object)null && (Object)(object)((Transform)Rect).parent != (Object)(object)_parent)
				{
					((Transform)Rect).SetParent(_parent, false);
				}
				Rect.anchorMin = _anchorMin;
				Rect.anchorMax = _anchorMax;
				Rect.pivot = _pivot;
				Rect.sizeDelta = _sizeDelta;
				Rect.anchoredPosition = _anchoredPosition;
				Rect.offsetMin = _offsetMin;
				Rect.offsetMax = _offsetMax;
				((Transform)Rect).localPosition = _localPosition;
				((Transform)Rect).localRotation = _localRotation;
				((Transform)Rect).localScale = _localScale;
				if ((Object)(object)_parent != (Object)null)
				{
					((Transform)Rect).SetSiblingIndex(Mathf.Clamp(_siblingIndex, 0, _parent.childCount - 1));
				}
			}
		}
	}
	internal sealed class MovedPlayerStatPanel
	{
		private readonly Transform _parent;

		private readonly int _siblingIndex;

		private readonly Vector2 _anchorMin;

		private readonly Vector2 _anchorMax;

		private readonly Vector2 _pivot;

		private readonly Vector2 _sizeDelta;

		private readonly Vector2 _anchoredPosition;

		private readonly Vector2 _offsetMin;

		private readonly Vector2 _offsetMax;

		private readonly Vector3 _localPosition;

		private readonly Quaternion _localRotation;

		private readonly Vector3 _localScale;

		public PlayerStatPanelKind Kind { get; set; }

		public int SortOrder { get; set; }

		public RectTransform Rect { get; }

		public MovedPlayerStatPanel(PlayerStatPanelKind kind, RectTransform rect, int sortOrder)
		{
			//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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_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_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_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)
			Kind = kind;
			SortOrder = sortOrder;
			Rect = rect;
			_parent = ((Transform)rect).parent;
			_siblingIndex = ((Transform)rect).GetSiblingIndex();
			_anchorMin = rect.anchorMin;
			_anchorMax = rect.anchorMax;
			_pivot = rect.pivot;
			_sizeDelta = rect.sizeDelta;
			_anchoredPosition = rect.anchoredPosition;
			_offsetMin = rect.offsetMin;
			_offsetMax = rect.offsetMax;
			_localPosition = ((Transform)rect).localPosition;
			_localRotation = ((Transform)rect).localRotation;
			_localScale = ((Transform)rect).localScale;
		}

		public void Restore()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_009e: 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_00c0: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Rect == (Object)null) && !((Object)(object)_parent == (Object)null))
			{
				((Transform)Rect).SetParent(_parent, false);
				((Transform)Rect).SetSiblingIndex(Mathf.Clamp(_siblingIndex, 0, _parent.childCount - 1));
				Rect.anchorMin = _anchorMin;
				Rect.anchorMax = _anchorMax;
				Rect.pivot = _pivot;
				Rect.sizeDelta = _sizeDelta;
				Rect.anchoredPosition = _anchoredPosition;
				Rect.offsetMin = _offsetMin;
				Rect.offsetMax = _offsetMax;
				((Transform)Rect).localPosition = _localPosition;
				((Transform)Rect).localRotation = _localRotation;
				((Transform)Rect).localScale = _localScale;
			}
		}
	}
	internal sealed class CraftingRecipeGridCell
	{
		public GameObject Go { get; }

		public int SlotIndex { get; }

		public RectTransform Rect { get; }

		public Image? Background { get; }

		public Color OriginalBackgroundColor { get; }

		public Image? Icon { get; }

		public TMP_Text? Amount { get; }

		public TMP_Text? Quality { get; }

		public GameObject? Selected { get; }

		public GameObject? Equipped { get; }

		public GameObject? Queued { get; }

		public GameObject? NoTeleport { get; }

		public Image? Food { get; }

		public GameObject? Durability { get; }

		public UITooltip Tooltip { get; }

		public UIInputHandler Input { get; }

		public CraftingRecipeGridMarker Marker { get; }

		public CraftingRecipeGridCell(GameObject go, int slotIndex)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_004d: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			Go = go;
			SlotIndex = slotIndex;
			Rect = (RectTransform)go.transform;
			Background = go.GetComponent<Image>();
			OriginalBackgroundColor = (((Object)(object)Background != (Object)null) ? ((Graphic)Background).color : Color.white);
			Transform obj = go.transform.Find("icon");
			Icon = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			Transform obj2 = go.transform.Find("amount");
			Amount = ((obj2 != null) ? ((Component)obj2).GetComponent<TMP_Text>() : null);
			Transform obj3 = go.transform.Find("quality");
			Quality = ((obj3 != null) ? ((Component)obj3).GetComponent<TMP_Text>() : null);
			Transform obj4 = go.transform.Find("selected");
			Selected = ((obj4 != null) ? ((Component)obj4).gameObject : null);
			Transform obj5 = go.transform.Find("equiped");
			Equipped = ((obj5 != null) ? ((Component)obj5).gameObject : null);
			Transform obj6 = go.transform.Find("queued");
			Queued = ((obj6 != null) ? ((Component)obj6).gameObject : null);
			Transform obj7 = go.transform.Find("noteleport");
			NoTeleport = ((obj7 != null) ? ((Component)obj7).gameObject : null);
			Transform obj8 = go.transform.Find("foodicon");
			Food = ((obj8 != null) ? ((Component)obj8).GetComponent<Image>() : null);
			Transform obj9 = go.transform.Find("durability");
			Durability = ((obj9 != null) ? ((Component)obj9).gameObject : null);
			Tooltip = go.GetComponent<UITooltip>() ?? go.AddComponent<UITooltip>();
			Input = go.GetComponent<UIInputHandler>() ?? go.AddComponent<UIInputHandler>();
			Marker = go.GetComponent<CraftingRecipeGridMarker>() ?? go.AddComponent<CraftingRecipeGridMarker>();
		}
	}
	internal sealed class CraftingRecipeGridMarker : MonoBehaviour
	{
		public int Index { get; set; }

		public UITooltip? Tooltip { get; set; }

		public bool Initialized { get; set; }
	}
	internal sealed class CraftingPinnedTooltipMarkerState : MonoBehaviour
	{
		public string LayoutSignature { get; set; } = "";
	}
	internal sealed class CraftingRequirementUiMarker : MonoBehaviour
	{
		public string ChildSignature { get; set; } = "";

		public string LayoutSignature { get; set; } = "";

		public string AmountSignature { get; set; } = "";

		public Transform? Name { get; set; }

		public RectTransform? Icon { get; set; }

		public Image? IconImage { get; set; }

		public RectTransform? Amount { get; set; }

		public TMP_Text? AmountText { get; set; }

		public RectTransform? Hitbox { get; set; }

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

		public string CompetingTooltipSignature { get; set; } = "";

		public UITooltip[] CompetingTooltips { get; set; } = Array.Empty<UITooltip>();
	}
	internal sealed class CraftingTextCacheState : MonoBehaviour
	{
		public string ChildSignature { get; set; } = "";

		public CraftingTextStamp LastTextStamp { get; set; }

		public CraftingTextColorStamp LastColorStamp { get; set; }

		public string ProgressBaseLabel { get; set; } = "";

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

		public Text[] LegacyTexts { get; set; } = Array.Empty<Text>();
	}
	internal sealed class CraftingTooltipState : MonoBehaviour
	{
		public CraftingSimpleTooltipStamp Stamp { get; set; }
	}
	internal readonly struct CraftingHoverTooltipContent
	{
		public string Topic { get; }

		public string Body { get; }

		public CraftingHoverTooltipContent(string topic, string body)
		{
			Topic = topic;
			Body = body;
		}
	}
	internal sealed class CraftingRecipeStyleButtonMarker : MonoBehaviour
	{
		public InventoryGui? Gui { get; set; }

		public int Index { get; set; } = -1;
	}
	internal sealed class CraftingRecipeViewEntry
	{
		public int OriginalIndex { get; }

		public RecipeDataPair Pair { get; }

		public bool IsFavorite { get; }

		public SortKey SortKey { get; }

		public bool IsVeiledRecipeMasked { get; }

		public bool IsVeiledRecipePreview { get; }

		public CraftingRecipeViewEntry(int originalIndex, RecipeDataPair pair, bool isFavorite, SortKey sortKey, bool isVeiledRecipeMasked, bool isVeiledRecipePreview)
		{
			//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)
			OriginalIndex = originalIndex;
			Pair = pair;
			IsFavorite = isFavorite;
			SortKey = sortKey;
			IsVeiledRecipeMasked = isVeiledRecipeMasked;
			IsVeiledRecipePreview = isVeiledRecipePreview;
		}
	}
	internal readonly struct CraftingRecipePairCacheKey : IEquatable<CraftingRecipePairCacheKey>
	{
		public int RecipeId { get; }

		public string ItemKey { get; }

		public bool IsValid => RecipeId != 0;

		public CraftingRecipePairCacheKey(Recipe? recipe, string itemKey)
		{
			RecipeId = (((Object)(object)recipe != (Object)null) ? ((Object)recipe).GetInstanceID() : 0);
			ItemKey = itemKey ?? "";
		}

		public bool Equals(CraftingRecipePairCacheKey other)
		{
			if (RecipeId == other.RecipeId)
			{
				return string.Equals(ItemKey, other.ItemKey, StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (RecipeId * 397) ^ StringComparer.Ordinal.GetHashCode(ItemKey);
		}
	}
	internal readonly struct CraftingTabRowBounds
	{
		public float Left { get; }

		public float Right { get; }

		public float Top { get; }

		public float Bottom { get; }

		public float Height => Mathf.Max(1f, Top - Bottom);

		public CraftingTabRowBounds(float left, float right, float top, float bottom)
		{
			Left = left;
			Right = right;
			Top = top;
			Bottom = bottom;
		}
	}
	internal sealed class CraftingRecipeGroupFilter
	{
		private readonly Func<ItemData, bool> _matches;

		private readonly Func<InventoryGui, Sprite?>? _iconGetter;

		private readonly string _iconPrefab;

		private readonly int _skillIcon;

		public string Id { get; }

		public string Category { get; }

		public string Tooltip { get; }

		public string Label => Id switch
		{
			"favorite" => "Favor", 
			"melee" => "Melee", 
			"ranged" => "Range", 
			"magic" => "Magic", 
			"armor" => "Equip", 
			"food" => "Food", 
			"consumable" => "Use", 
			"meadbase" => "Base", 
			"tool" => "Tool", 
			"misc" => "Misc", 
			_ => Id, 
		};

		public CraftingRecipeGroupFilter(string id, string category, string tooltip, Func<ItemData, bool> matches, string iconPrefab = "", int skillIcon = -1, Func<InventoryGui, Sprite?>? iconGetter = null)
		{
			Id = id;
			Category = category;
			Tooltip = tooltip;
			_matches = matches;
			_iconPrefab = iconPrefab;
			_skillIcon = skillIcon;
			_iconGetter = iconGetter;
		}

		public bool Matches(ItemData item)
		{
			return _matches(item);
		}

		public Sprite? GetIcon(InventoryGui gui)
		{
			Sprite val = _iconGetter?.Invoke(gui);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (_skillIcon >= 0)
			{
				val = InventorySlotsPlugin.GetSkillIcon(_skillIcon);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return InventorySlotsPlugin.GetItemPrefabIcon(_iconPrefab);
		}
	}
	internal sealed class CraftingRecipeGroupPanel
	{
		public RectTransform Rect { get; }

		public Image? Background { get; }

		public CraftingRecipeGroupPanel(RectTransform rect)
		{
			Rect = rect;
			Background = ((Component)rect).GetComponent<Image>();
		}
	}
	internal sealed class CraftingRecipeGroupButton
	{
		public GameObject Go { get; }

		public RectTransform Rect { get; }

		public Image? Background { get; }

		public Image? Icon { get; }

		public Image? ActiveOverlay { get; }

		public UITooltip Tooltip { get; }

		public UIInputHandler Input { get; }

		public CraftingGroupButtonMarker Marker { get; }

		public CraftingRecipeGroupButton(GameObject go)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			Go = go;
			Rect = (RectTransform)go.transform;
			Background = go.GetComponent<Image>();
			Transform obj = go.transform.Find("icon");
			Icon = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			Tooltip = go.GetComponent<UITooltip>() ?? go.AddComponent<UITooltip>();
			Input = go.GetComponent<UIInputHandler>() ?? go.AddComponent<UIInputHandler>();
			Marker = go.GetComponent<CraftingGroupButtonMarker>() ?? go.AddComponent<CraftingGroupButtonMarker>();
			ActiveOverlay = EnsureActiveOverlay(Rect);
		}

		private static Image EnsureActiveOverlay(RectTransform parent)
		{
			//IL_0047: 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_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_0090: 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)
			Transform val = ((Transform)parent).Find("InventorySlots_CraftingGroupActive");
			RectTransform val2 = (RectTransform)((!((Object)(object)val != (Object)null)) ? ((object)new GameObject("InventorySlots_CraftingGroupActive", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>()) : ((object)(RectTransform)val));
			if ((Object)(object)((Transform)val2).parent != (Object)(object)parent)
			{
				((Transform)val2).SetParent((Transform)(object)parent, false);
			}
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			Image component = ((Component)val2).GetComponent<Image>();
			component.sprite = InventorySlotsPlugin.GetSolidUiSprite();
			((Graphic)component).raycastTarget = false;
			((Component)val2).gameObject.SetActive(false);
			return component;
		}
	}
	internal sealed class CraftingGroupButtonMarker : MonoBehaviour
	{
		public string FilterId { get; set; } = "";

		public bool Initialized { get; set; }
	}
	internal static class KeyboardShortcutExtensions
	{
		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(IsShortcutKeyHeld);
			}
			return false;
		}

		public static string GetDisplayText(this KeyboardShortcut shortcut)
		{
			//IL_0002: 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)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return "";
			}
			IEnumerable<string> values = from part in ((KeyboardShortcut)(ref shortcut)).Modifiers.Select(GetShortcutKeyDisplayText).Concat(new string[1] { GetShortcutKeyDisplayText(((KeyboardShortcut)(ref shortcut)).MainKey) })
				where !string.IsNullOrWhiteSpace(part)
				select part;
			return string.Join(" + ", values);
		}

		public static string GetCompactDisplayText(this KeyboardShortcut shortcut)
		{
			//IL_0002: 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)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return "";
			}
			IEnumerable<string> values = from part in ((KeyboardShortcut)(ref shortcut)).Modifiers.Select(GetCompactShortcutKeyDisplayText).Concat(new string[1] { GetCompactShortcutKeyDisplayText(((KeyboardShortcut)(ref shortcut)).MainKey) })
				where !string.IsNullOrWhiteSpace(part)
				select part;
			return string.Join("+", values);
		}

		public static string GetDisplayText(this KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetShortcutKeyDisplayText(key);
		}

		public static string GetCompactDisplayText(this KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetCompactShortcutKeyDisplayText(key);
		}

		private static bool IsShortcutKeyHeld(KeyCode key)
		{
			//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_0024: Expected I4, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			switch (key - 303)
			{
			case 4:
			case 5:
				return Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
			case 2:
			case 3:
				return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
			case 0:
			case 1:
				return Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
			default:
				return Input.GetKey(key);
			}
		}

		private unsafe static string GetShortcutKeyDisplayText(KeyCode key)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected I4, but got Unknown
			//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)
			//IL_004f: Expected I4, but got Unknown
			if ((int)key != 0)
			{
				switch (key - 303)
				{
				default:
					return (key - 323) switch
					{
						0 => "Mouse1", 
						1 => "Mouse2", 
						2 => "Mouse3", 
						3 => "Mouse4", 
						4 => "Mouse5", 
						5 => "Mouse6", 
						6 => "Mouse7", 
						_ => ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString(), 
					};
				case 4:
				case 5:
					return "Alt";
				case 2:
				case 3:
					return "Ctrl";
				case 0:
				case 1:
					return "Shift";
				}
			}
			return "";
		}

		private unsafe static string GetCompactShortcutKeyDisplayText(KeyCode key)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Invalid comparison between Unknown and I4
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Invalid comparison between Unknown and I4
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			//IL_0060: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected I4, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Invalid comparison between Unknown and I4
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Invalid comparison between Unknown and I4
			//IL_0168: 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_0190: Expected I4, but got Unknown
			//IL_0107: 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_0137: Expected I4, but got Unknown
			//IL_00d1: 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_00f2: Expected I4, but got Unknown
			//IL_008a: 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_00b7: Expected I4, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			string text = ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString();
			if (text.StartsWith("Alpha", StringComparison.Ordinal))
			{
				return text.Substring("Alpha".Length);
			}
			if (text.StartsWith("Keypad", StringComparison.Ordinal))
			{
				return "Num" + text.Substring("Keypad".Length);
			}
			if ((int)key <= 47)
			{
				if ((int)key <= 13)
				{
					if ((int)key == 0)
					{
						return "";
					}
					if ((int)key == 8)
					{
						return "Bksp";
					}
					if ((int)key == 13)
					{
						return "Enter";
					}
				}
				else
				{
					if ((int)key == 27)
					{
						return "Esc";
					}
					if ((int)key == 32)
					{
						return "Spc";
					}
					switch (key - 39)
					{
					case 8:
						return "/";
					case 0:
						return "'";
					case 5:
						return ",";
					case 7:
						return ".";
					case 6:
						return "-";
					}
				}
			}
			else if ((int)key <= 96)
			{
				if ((int)key == 59)
				{
					return ";";
				}
				if ((int)key == 61)
				{
					return "=";
				}
				switch (key - 91)
				{
				case 0:
					return "[";
				case 2:
					return "]";
				case 5:
					return "`";
				case 1:
					return "\\";
				}
			}
			else if ((int)key <= 281)
			{
				if ((int)key == 127)
				{
					return "Del";
				}
				switch (key - 273)
				{
				case 4:
					return "Ins";
				case 7:
					return "PgUp";
				case 8:
					return "PgDn";
				case 3:
					return "Left";
				case 2:
					return "Right";
				case 0:
					return "Up";
				case 1:
					return "Down";
				}
			}
			else
			{
				switch (key - 301)
				{
				default:
					switch (key - 323)
					{
					case 0:
						return "M1";
					case 1:
						return "M2";
					case 2:
						return "M3";
					case 3:
						return "M4";
					case 4:
						return "M5";
					case 5:
						return "M6";
					case 6:
						return "M7";
					}
					break;
				case 6:
				case 7:
					return "Alt";
				case 4:
				case 5:
					return "Ctrl";
				case 2:
				case 3:
					return "Shift";
				case 0:
					return "Caps";
				case 1:
					break;
				}
			}
			return text;
		}
	}
	internal static class ToggleExtensions
	{
		public static bool IsOn(this InventorySlotsPlugin.Toggle value)
		{
			return value == InventorySlotsPlugin.Toggle.On;
		}

		public static bool IsOff(this InventorySlotsPlugin.Toggle value)
		{
			return value == InventorySlotsPlugin.Toggle.Off;
		}
	}
	internal sealed class InventorySlotsSimpleTooltipHover : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		private string _topic = "";

		private string _text = "";

		private bool _hovering;

		public void Configure(string topic, string text)
		{
			_topic = topic ?? "";
			_text = text ?? "";
			((Behaviour)this).enabled = !string.IsNullOrWhiteSpace(_topic) || !string.IsNullOrWhiteSpace(_text);
			if (!((Behaviour)this).enabled && _hovering)
			{
				_hovering = false;
				InventorySlotsPlugin.HideSimpleNameTooltip(this);
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (((Behaviour)this).enabled)
			{
				_hovering = true;
				InventorySlotsPlugin.ShowSimpleNameTooltip(this, _topic, _text);
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if (_hovering)
			{
				_hovering = false;
				InventorySlotsPlugin.HideSimpleNameTooltip(this);
			}
		}

		private void Update()
		{
			if (_hovering)
			{
				InventorySlotsPlugin.ShowSimpleNameTooltip(this, _topic, _text);
			}
		}

		private void OnDisable()
		{
			if (_hovering)
			{
				_hovering = false;
				InventorySlotsPlugin.HideSimpleNameTooltip(this);
			}
		}
	}
	internal sealed class InventorySlotsTooltipDisplayData : MonoBehaviour
	{
		public string RouteToken { get; private set; } = "";

		public string DisplayTopic { get; private set; } = "";

		public string DisplayText { get; private set; } = "";

		public bool HasDisplayData { get; private set; }

		public void Configure(string routeToken, string displayTopic, string displayText)
		{
			RouteToken = routeToken ?? "";
			DisplayTopic = displayTopic ?? "";
			DisplayText = displayText ?? "";
			HasDisplayData = !string.IsNullOrWhiteSpace(DisplayTopic) || !string.IsNullOrWhiteSpace(DisplayText);
		}
	}
	internal sealed class YamlRoot
	{
		[YamlMember(Alias = "Groups", ApplyNamingConventions = false)]
		public Dictionary<string, List<string>> Groups { get; set; } = new Dictionary<string, List<string>>();

		[YamlMember(Alias = "InventoryLimits", ApplyNamingConventions = false)]
		public Dictionary<string, int> InventoryLimits { get; set; } = new Dictionary<string, int>();

		[YamlMember(Alias = "KeepOnDeath", ApplyNamingConventions = false)]
		public List<string> KeepOnDeath { get; set; } = new List<string>();

		[YamlMember(Alias = "QuickSlots", ApplyNamingConventions = false)]
		public List<string> QuickSlots { get; set; } = new List<string>();

		[YamlMember(Alias = "Slots", ApplyNamingConventions = false)]
		public List<YamlSlot> Slots { get; set; } = new List<YamlSlot>();
	}
	internal sealed class YamlSlot
	{
		public string Id { get; set; } = "";

		public string Name { get; set; } = "";

		public List<string> Items { get; set; } = new List<string>();
	}
	internal sealed class InventoryTrashButtonMarker : MonoBehaviour
	{
		public Image? Icon { get; set; }

		public bool TextSuppressed { get; set; }

		public string LayoutSignature { get; set; } = "";

		public bool LastCanTrash { get; set; }

		public bool HasVisualState { get; set; }
	}
	[HarmonyPatch(typeof(InventoryGui), "Update")]
	internal static class InventoryGuiTrashConfirmInputPatch
	{
		private static void Postfix()
		{
			InventorySlotsPlugin.UpdateInventoryTrashConfirmDialogInput();
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
	internal static class InventoryGridDominantFoodIconColorPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(InventoryGrid __instance)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = __instance.m_inventory;
			if (inventory == null || __instance.m_elements == null)
			{
				return;
			}
			int width = inventory.GetWidth();
			if (width <= 0)
			{
				return;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem == null || !InventorySlotsPlugin.TryGetDominantFoodStat(allItem, out var stat))
				{
					continue;
				}
				int num = allItem.m_gridPos.y * width + allItem.m_gridPos.x;
				if (num >= 0 && num < __instance.m_elements.Count)
				{
					Element val = __instance.m_elements[num];
					if (!((Object)(object)val?.m_food == (Object)null))
					{
						((Behaviour)val.m_food).enabled = true;
						Image food = val.m_food;
						((Graphic)food).color = (Color)(stat switch
						{
							FoodStat.Health => __instance.m_foodHealthColor, 
							FoodStat.Stamina => __instance.m_foodStaminaColor, 
							FoodStat.Eitr => __instance.m_foodEitrColor, 
							_ => ((Graphic)val.m_food).color, 
						});
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(KeyHints), "Awake")]
	internal static class KeyHintsFavoriteHintAwakePatch
	{
		private static void Postfix(KeyHints __instance)
		{
			InventorySlotsPlugin.UpdateFavoriteKeyHint(__instance);
		}
	}
	[HarmonyPatch(typeof(KeyHints), "UpdateHints")]
	internal static class KeyHintsFavoriteHintUpdatePatch
	{
		private static void Postfix(KeyHints __instance)
		{
			InventorySlotsPlugin.UpdateFavoriteKeyHint(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Update")]
	[HarmonyBefore(new string[] { "org.bepinex.plugins.jewelcrafting" })]
	internal static class InventoryGuiJewelcraftingInventorySlotsSocketContainerPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			return !InventorySlotsPlugin.TryOpenJewelcraftingSocketContainerFromInventorySlotsSlot(__instance);
		}
	}
	[HarmonyPatch(typeof(UITooltip), "OnHoverStart")]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot", "org.bepinex.plugins.jewelcrafting", "Azumatt.TooltipExpansion" })]
	internal static class UITooltipNullPrefabGuardPatch
	{
		private static bool Prefix(UITooltip __instance)
		{
			return InventorySlotsPlugin.ShouldAllowTooltipHoverStart(__instance);
		}

		private static void Postfix(UITooltip __instance)
		{
			InventorySlotsPlugin.EnsureInventoryContainerHoverTooltipScroll(__instance);
			InventorySlotsPlugin.UpdateInventorySlotsOwnedHoverTooltip(__instance, resetScroll: true, handleWheel: false);
		}
	}
	[HarmonyPatch(typeof(UITooltip), "LateUpdate")]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot", "org.bepinex.plugins.jewelcrafting", "Azumatt.TooltipExpansion" })]
	internal static class UITooltipInventoryContainerBackgroundAlphaPatch
	{
		private static bool Prefix(UITooltip __instance)
		{
			return InventorySlotsPlugin.ShouldAllowTooltipLateUpdate(__instance);
		}

		private static void Postfix(UITooltip __instance)
		{
			if ((Object)(object)UITooltip.m_current == (Object)(object)__instance && !InventorySlotsPlugin.ShouldUpdateInventorySlotsOwnedHoverTooltip(__instance))
			{
				InventorySlotsPlugin.UpdateInventoryContainerHoverTooltipScroll(__instance);
			}
			if (InventorySlotsPlugin.ShouldUpdateInventorySlotsOwnedHoverTooltip(__instance))
			{
				InventorySlotsPlugin.UpdateInventorySlotsOwnedHoverTooltip(__instance, resetScroll: false, handleWheel: true);
			}
		}

		private static Exception? Finalizer(UITooltip __instance, Exception __exception)
		{
			if (__exception == null)
			{
				return null;
			}
			if (!InventorySlotsPlugin.TryRecoverInventorySlotsTooltipLateUpdateException(__instance, __exception))
			{
				return __exception;
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(UITooltip), "OnPointerExit")]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot", "org.bepinex.plugins.jewelcrafting", "Azumatt.TooltipExpansion" })]
	internal static class UITooltipInventorySlotsOwnedHoverTooltipExitPatch
	{
		private static void Postfix(UITooltip __instance)
		{
			InventorySlotsPlugin.EndInventoryContainerHoverTooltipOwnership(__instance);
			InventorySlotsPlugin.EndInventorySlotsOwnedHoverTooltip(__instance);
		}
	}
	[HarmonyPatch(typeof(UITooltip), "HideTooltip")]
	internal static class UITooltipInventoryContainerCustomTooltipHidePatch
	{
		private static void Postfix()
		{
			InventorySlotsPlugin.OnVanillaTooltipHidden();
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip")]
	[HarmonyBefore(new string[] { "randyknapp.mods.epicloot" })]
	internal static class InventoryGridCreateItemTooltipEpicLootUiScopeStartPatch
	{
		private static void Prefix(InventoryGrid __instance)
		{
			InventorySlotsPlugin.BeginEpicLootInventoryGridTooltipUiPatchScope(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip")]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot" })]
	internal static class InventoryGridCreateItemTooltipEpicLootUiScopeEndPatch
	{
		private static void Postfix(InventoryGrid __instance)
		{
			InventorySlotsPlugin.EndEpicLootInventoryGridTooltipUiPatchScope(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip")]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot", "org.bepinex.plugins.jewelcrafting", "Azumatt.TooltipExpansion", "kg.ValheimEnchantmentSystem" })]
	internal static class InventoryGridCreateItemTooltipEmptyTextFallbackPatch
	{
		private static void Postfix(InventoryGrid __instance, ItemData item, UITooltip tooltip)
		{
			InventorySlotsPlugin.RegisterInventoryGridItemTooltip(__instance, item, tooltip);
			InventorySlotsPlugin.EnsureInventoryGridItemTooltipText(item, tooltip);
		}
	}
	internal sealed class BuiltInItemGroupSection
	{
		public string YamlName { get; }

		public string Id { get; }

		public string Tab { get; }

		public string Label { get; }

		public string IconPrefab { get; }

		public IReadOnlyList<string> Subgroups { get; }

		public BuiltInItemGroupSection(string yamlName, string id, string tab, string label, string iconPrefab, params string[] subgroups)
		{
			YamlName = yamlName;
			Id = id;
			Tab = tab;
			Label = label;
			IconPrefab = iconPrefab;
			Subgroups = subgroups;
		}
	}
	internal static class ItemGroupRegistry
	{
		public static readonly IReadOnlyList<BuiltInItemGroupSection> Sections = new List<BuiltInItemGroupSection>
		{
			new BuiltInItemGroupSection("Melee", "melee", "Combat", "Melee", "AxeStone", "sword", "axe", "club", "knife", "spear", "polearm", "fists", "shield", "pickaxe", "tool"),
			new BuiltInItemGroupSection("Ranged", "ranged", "Combat", "Range", "Bow", "bow", "arrow", "crossbow", "bolt", "ammo", "bomb"),
			new BuiltInItemGroupSection("Magic", "magic", "Combat", "Magic", "Eitr", "elementalmagic", "bloodmagic"),
			new BuiltInItemGroupSection("Equipment", "armor", "Equipment", "Equipment", "HelmetLeather", "helmet", "chest", "legs", "cape", "utility", "trinket"),
			new BuiltInItemGroupSection("Food", "food", "Equipment", "Food", "CookedMeat", "healthfood", "staminafood", "eitrfood", "feast"),
			new BuiltInItemGroupSection("Consumable", "consumable", "Equipment", "Consumable", "MeadHealthMinor", "mead", "potion"),
			new BuiltInItemGroupSection("Meadbase", "meadbase", "Crafting", "Base", "MeadBaseHealthMinor", "meadbase"),
			new BuiltInItemGroupSection("Misc", "misc", "Crafting", "Misc", "Dandelion", "trophy", "valuable")
		};

		private static readonly HashSet<string> BuiltInGroupIds = new HashSet<string>(new string[3] { "all", "favorite", "equipment" }.Concat(Sections.Select((BuiltInItemGroupSection section) => section.Id)).Concat(Sections.SelectMany((BuiltInItemGroupSection section) => section.Subgroups)).Select(InventorySlotsConfigCore.NormalizeGroupId), StringComparer.OrdinalIgnoreCase);

		public static bool TryNormalizeSectionId(string? rawId, out string sectionId)
		{
			sectionId = "";
			if (string.IsNullOrWhiteSpace(rawId))
			{
				return false;
			}
			string trimmed = rawId.Trim();
			BuiltInItemGroupSection builtInItemGroupSection = Sections.FirstOrDefault((BuiltInItemGroupSection candidate) => string.Equals(candidate.YamlName, trimmed, StringComparison.Ordinal));
			if (builtInItemGroupSection == null)
			{
				return false;
			}
			sectionId = builtInItemGroupSection.Id;
			return true;
		}

		public static bool IsBuiltInGroupId(string groupId)
		{
			return BuiltInGroupIds.Contains(InventorySlotsConfigCore.NormalizeGroupId(groupId));
		}

		public static IEnumerable<string> GlobalSubgroupOrder()
		{
			return new string[1] { "favorite" }.Concat(Sections.SelectMany((BuiltInItemGroupSection section) => section.Subgroups)).Distinct<string>(StringComparer.OrdinalIgnoreCase);
		}
	}
	[HarmonyPatch]
	internal static class JewelcraftingApiIsJewelryEquippedInventorySlotsPatch
	{
		private static bool Prepare()
		{
			MethodBase method;
			return InventorySlotsPlugin.TryGetJewelcraftingApiIsJewelryEquippedMethod(out method);
		}

		private static MethodBase TargetMethod()
		{
			InventorySlotsPlugin.TryGetJewelcraftingApiIsJewelryEquippedMethod(out MethodBase method);
			return method;
		}

		private static void Postfix(Player player, string prefabName, ref bool __result)
		{
			if (!__result)
			{
				__result = InventorySlotsPlugin.IsJewelcraftingJewelryEquipped(player, prefabName);
			}
		}
	}
	internal sealed class PinnedGemIconTooltipTarget : MonoBehaviour
	{
		public string DisplayName { get; private set; } = "";

		public void SetDisplayName(string displayName)
		{
			DisplayName = displayName ?? "";
			((Behaviour)this).enabled = !string.IsNullOrWhiteSpace(DisplayName);
		}
	}
	internal sealed class PinnedGemIconTooltipPanelHitTester : MonoBehaviour
	{
		private readonly List<PinnedGemIconTooltipTarget> _targets = new List<PinnedGemIconTooltipTarget>();

		private PinnedGemIconTooltipTarget? _hoveredTarget;

		private RectTransform? _rectTransform;

		private Canvas? _canvas;

		private Camera? _camera;

		private bool _targetsDirty = true;

		public void InvalidateTargets()
		{
			_targetsDirty = true;
			_canvas = null;
			_camera = null;
		}

		private void Update()
		{
			PinnedGemIconTooltipTarget pinnedGemIconTooltipTarget = FindHoveredTarget();
			if ((Object)(object)pinnedGemIconTooltipTarget != (Object)null)
			{
				_hoveredTarget = pinnedGemIconTooltipTarget;
				InventorySlotsPlugin.ShowPinnedGemNameTooltip(this, pinnedGemIconTooltipTarget.DisplayName);
			}
			else if ((Object)(object)_hoveredTarget != (Object)null)
			{
				_hoveredTarget = null;
				InventorySlotsPlugin.HidePinnedGemNameTooltip(this);
			}
		}

		private void OnEnable()
		{
			InvalidateTargets();
		}

		private void OnTransformChildrenChanged()
		{
			_targetsDirty = true;
		}

		private void OnDisable()
		{
			if ((Object)(object)_hoveredTarget != (Object)null)
			{
				_hoveredTarget = null;
				InventorySlotsPlugin.HidePinnedGemNameTooltip(this);
			}
		}

		private PinnedGemIconTooltipTarget? FindHoveredTarget()
		{
			if (_rectTransform == null)
			{
				ref RectTransform? rectTransform = ref _rectTransform;
				Transform transform = ((Component)this).transform;
				rectTransform = (RectTransform?)(object)((transform is RectTransform) ? transform : null);
			}
			if ((Object)(object)_rectTransform == (Object)null || !RectTransformContainsMouse(_rectTransform))
			{
				return null;
			}
			RefreshTargetsIfNeeded();
			for (int i = 0; i < _targets.Count; i++)
			{
				PinnedGemIconTooltipTarget pinnedGemIconTooltipTarget = _targets[i];
				if (!((Object)(object)pinnedGemIconTooltipTarget == (Object)null) && ((Behaviour)pinnedGemIconTooltipTarget).isActiveAndEnabled && !string.IsNullOrWhiteSpace(pinnedGemIconTooltipTarget.DisplayName))
				{
					Transform transform2 = ((Component)pinnedGemIconTooltipTarget).transform;
					RectTransform val = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
					if ((Object)(object)val != (Object)null && RectTransformContainsMouse(val))
					{
						return pinnedGemIconTooltipTarget;
					}
				}
			}
			return null;
		}

		private void RefreshTargetsIfNeeded()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (_targetsDirty)
			{
				_targets.Clear();
				((Component)this).GetComponentsInChildren<PinnedGemIconTooltipTarget>(false, _targets);
				_canvas = ((Component)this).GetComponentInParent<Canvas>();
				_camera = (((Object)(object)_canvas != (Object)null && (int)_canvas.renderMode != 0) ? _canvas.worldCamera : null);
				_targetsDirty = false;
			}
		}

		private bool RectTransformContainsMouse(RectTransform rect)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_canvas == (Object)null)
			{
				_canvas = ((Component)this).GetComponentInParent<Canvas>();
				_camera = (((Object)(object)_canvas != (Object)null && (int)_canvas.renderMode != 0) ? _canvas.worldCamera : null);
			}
			return RectTransformUtility.RectangleContainsScreenPoint(rect, Vector2.op_Implicit(Input.mousePosition), _camera);
		}
	}
	internal static class JewelcraftingTooltipCore
	{
		public const int MaxRowlessRefreshAttempts = 3;

		public static bool ShouldRefreshNativeTooltip(string? previousSignature, string? nextSignature, bool previousVisible, bool previousHadSocketRows, int previousRowlessRefreshAttempts)
		{
			if (!string.Equals(previousSignature ?? "", nextSignature ?? "", StringComparison.Ordinal))
			{
				return true;
			}
			if (!previousVisible)
			{
				return true;
			}
			if (!previousHadSocketRows)
			{
				return previousRowlessRefreshAttempts < 3;
			}
			return false;
		}

		public static bool HasVisibleText(string? text)
		{
			return !string.IsNullOrWhiteSpace(StripRichText(text));
		}

		public static string BuildNativeTooltipUpdateSignature(bool showInteract, bool advancedPressed, bool prophecyPressed, int localizationVersion, string? equipmentSignature, string? openSocketSignature)
		{
			return string.Join("|", showInteract, advancedPressed, prophecyPressed, localizationVersion, equipmentSignature ?? "", openSocketSignature ?? "");
		}

		public static string StripRichText(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			int num = 0;
			char[] array = new char[text.Length];
			int length = 0;
			foreach (char c in text)
			{
				switch (c)
				{
				case '<':
					num++;
					continue;
				case '>':
					if (num > 0)
					{
						num--;
						continue;
					}
					break;
				}
				if (num == 0)
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class JewelcraftingSourceRowUiCache : MonoBehaviour
	{
		public string ChildSignature { get; set; } = "";

		public TMP_Text? Text { get; set; }

		public Image? BorderImage { get; set; }

		public Image? GemImage { get; set; }
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGamepad")]
	internal static class InventoryGridMultiUserContainerGamepadBarrierPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(InventoryGrid __instance)
		{
			return !InventorySlotsPlugin.ShouldBlockMultiUserContainerGamepadInput(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateInventory")]
	internal static class InventoryGridMultiUserContainerProjectionPatch
	{
		private sealed class ProjectionState
		{
			public Inventory? RealInventory { get; set; }

			public bool Restored { get; set; }
		}

		[HarmonyPriority(800)]
		private static void Prefix(ref Inventory inventory, out ProjectionState __state)
		{
			__state = new ProjectionState();
			if (InventorySlotsPlugin.TryGetMultiUserContainerProjection(inventory, out Inventory projection))
			{
				__state.RealInventory = inventory;
				inventory = projection;
			}
		}

		[HarmonyPriority(0)]
		private static void Postfix(InventoryGrid __instance, ProjectionState __state)
		{
			RestoreRealInventory(__instance, __state);
		}

		private static Exception? Finalizer(InventoryGrid __instance, ProjectionState __state, Exception? __exception)
		{
			RestoreRealInventory(__instance, __state);
			return __exception;
		}

		private static void RestoreRealInventory(InventoryGrid grid, ProjectionState state)
		{
			if (!state.Restored && state.RealInventory != null)
			{
				InventorySlotsPlugin.RestoreMultiUserContainerGridInventory(grid, state.RealInventory);
				state.Restored = true;
			}
		}
	}
	internal sealed class MultiUserContainerItemSnapshot
	{
		[StructLayout(LayoutKind.Explicit)]
		private struct SingleBits
		{
			[FieldOffset(0)]
			private float _value;

			[FieldOffset(0)]
			private int _bits;

			public static int GetBits(float value)
			{
				SingleBits singleBits = new SingleBits
				{
					_value = value
				};
				return singleBits._bits;
			}
		}

		private readonly ReadOnlyCollection<KeyValuePair<string, string>> _customData;

		public string? PrefabName { get; }

		public int Quality { get; }

		public int Variant { get; }

		public int WorldLevel { get; }

		public long CrafterId { get; }

		public string? CrafterName { get; }

		public float Durability { get; }

		public int DurabilityBits { get; }

		public bool PickedUp { get; }

		public int Stack { get; }

		public IReadOnlyList<KeyValuePair<string, string>> CustomData => _customData;

		public MultiUserContainerItemSnapshot(string? prefabName, int quality, int variant, int worldLevel, long crafterId, string? crafterName, float durability, bool pickedUp, int stack, IEnumerable<KeyValuePair<string, string>>? customData)
		{
			PrefabName = prefabName;
			Quality = quality;
			Variant = variant;
			WorldLevel = worldLevel;
			CrafterId = crafterId;
			CrafterName = crafterName;
			Durability = durability;
			DurabilityBits = SingleBits.GetBits(durability);
			PickedUp = pickedUp;
			Stack = stack;
			List<KeyValuePair<string, string>> list = ((customData == null) ? new List<KeyValuePair<string, string>>() : new List<KeyValuePair<string, string>>(customData));
			list.Sort(CompareCustomData);
			_customData = list.AsReadOnly();
		}

		private static int CompareCustomData(KeyValuePair<string, string> left, KeyValuePair<string, string> right)
		{
			int num = string.CompareOrdinal(left.Key, right.Key);
			if (num == 0)
			{
				return string.CompareOrdinal(left.Value, right.Value);
			}
			return num;
		}
	}
	internal static class MultiUserContainerTransferCore
	{
		public static bool MatchesExpectedStackState(int expectedStack, int? actualStack)
		{
			if (expectedStack >= 0)
			{
				if (expectedStack != 0)
				{
					return actualStack == expectedStack;
				}
				return !actualStack.HasValue;
			}
			return false;
		}

		public static bool IsExactMatch(MultiUserContainerItemSnapshot? expected, MultiUserContainerItemSnapshot? actual, int requiredStack)
		{
			if (expected == null || actual == null || requiredStack <= 0 || expected.Stack < requiredStack || actual.Stack < requiredStack)
			{
				return false;
			}
			if (!string.Equals(expected.PrefabName, actual.PrefabName, StringComparison.Ordinal) || expected.Quality != actual.Quality || expected.Variant != actual.Variant || expected.WorldLevel != actual.WorldLevel || expected.CrafterId != actual.CrafterId || !string.Equals(expected.CrafterName, actual.CrafterName, StringComparison.Ordinal) || expected.DurabilityBits != actual.DurabilityBits || expected.PickedUp != actual.PickedUp || expected.CustomData.Count != actual.CustomData.Count)
			{
				return false;
			}
			for (int i = 0; i < expected.CustomData.Count; i++)
			{
				KeyValuePair<string, string> keyValuePair = expected.CustomData[i];
				KeyValuePair<string, string> keyValuePair2 = actual.CustomData[i];
				if (!string.Equals(keyValuePair.Key, keyValuePair2.Key, StringComparison.Ordinal) || !string.Equals(keyValuePair.Value, keyValuePair2.Value, StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal sealed class MyLittleUICraftingObjectMarker : MonoBehaviour
	{
	}
	internal sealed class InventoryPinnedTooltipInputMarker : MonoBehaviour
	{
		public bool HoverInitialized { get; set; }
	}
	internal sealed class InventoryPinnedTooltipGridMarker : MonoBehaviour
	{
		public int ElementListId { get; set; }

		public int ElementCount { get; set; }

		public int FirstElementId { get; set; }

		public int LastElementId { get; set; }
	}
	[HarmonyPatch]
	internal static class RecycleNReclaimNativePanelUpdatedInventorySlotsPatch
	{
		private const string RecycleNReclaimGuid = "Azumatt.Recycle_N_Reclaim";

		private const string StationRecyclingTabHolderTypeName = "Recycle_N_Reclaim.GamePatches.UI.StationRecyclingTabHolder";

		private static MethodBase? TargetMethod()
		{
			if (!TryGetTargetMethod(out MethodBase method))
			{
				return null;
			}
			return method;
		}

		private static bool Prepare()
		{
			MethodBase method;
			return TryGetTargetMethod(out method);
		}

		private static bool TryGetTargetMethod(out MethodBase? method)
		{
			method = null;
			if (!Chainloader.PluginInfos.TryGetValue("Azumatt.Recycle_N_Reclaim", out var value) || (Object)(object)value.Instance == (Object)null)
			{
				return false;
			}
			method = ((object)value.Instance).GetType().Assembly.GetType("Recycle_N_Reclaim.GamePatches.UI.StationRecyclingTabHolder")?.GetMethod("UpdateCraftingPanel", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			return method != null;
		}

		private static void Postfix()
		{
			InventorySlotsPlugin.OnRecycleNReclaimNativePanelUpdated();
		}
	}
	internal static class RestockTargetLimitCore
	{
		public static Dictionary<string, int> Parse(string? raw)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrWhiteSpace(raw))
			{
				return dictionary;
			}
			foreach (string item in SplitEntries(raw))
			{
				string text = StripInlineComment(item).Trim();
				if (text.Length == 0)
				{
					continue;
				}
				int num = FindSeparator(text);
				if (num > 0 && num < text.Length - 1)
				{
					string text2 = InventorySlotsConfigCore.NormalizeResourceToken(text.Substring(0, num));
					string s = text.Substring(num + 1).Trim();
					if (text2.Length != 0 && int.TryParse(s, out var result))
					{
						dictionary[text2] = Math.Max(0, result);
					}
				}
			}
			return dictionary;
		}

		public static int ResolveTargetStackLimit(Dictionary<string, int>? limits, IEnumerable<string?> lookupTokens, int itemMaxStack)
		{
			int num = Math.Max(0, itemMaxStack);
			if (num == 0 || limits == null || limits.Count == 0)
			{
				return num;
			}
			foreach (string lookupToken in lookupTokens)
			{
				string text = InventorySlotsConfigCore.NormalizeResourceToken(lookupToken);
				if (text.Length > 0 && limits.TryGetValue(text, out var value))
				{
					return Math.Min(num, Math.Max(0, value));
				}
			}
			return num;
		}

		private static IEnumerable<string> SplitEntries(string raw)
		{
			return raw.Replace("\r", "\n").Split(new char[3] { '\n', ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
		}

		private static string StripInlineComment(string entry)
		{
			int num = entry.IndexOf('#');
			if (num < 0)
			{
				return entry;
			}
			return entry.Substring(0, num);
		}

		private static int FindSeparator(string entry)
		{
			int num = entry.IndexOf(':');
			int num2 = entry.IndexOf('=');
			if (num < 0)
			{
				return num2;
			}
			if (num2 < 0)
			{
				return num;
			}
			return Math.Min(num, num2);
		}
	}
	internal sealed class ScrollableTooltipBodyState
	{
		public RectTransform? ScrollView { get; set; }

		public RectTransform? Viewport { get; set; }

		public RectTransform? Content { get; set; }

		public ScrollRect? ScrollRect { get; set; }

		public Scrollbar? Scrollbar { get; set; }

		public TMP_Text? Text { get; set; }

		public RectTransformSnapshot? TextOriginalSnapshot { get; set; }
	}
	internal readonly struct ScrollableTooltipBodyLayoutResult
	{
		public float ScrollOffset { get; }

		public float MaxScroll { get; }

		public bool NeedsScroll { get; }

		public ScrollableTooltipBodyLayoutResult(float scrollOffset, float maxScroll, bool needsScroll)
		{
			ScrollOffset = scrollOffset;
			MaxScroll = maxScroll;
			NeedsScroll = needsScroll;
		}
	}
	internal static class ScrollableTooltipBody
	{
		private static readonly Color DefaultHandleColor = new Color(1f, 0.78f, 0.38f, 0.75f);

		private static readonly Color DefaultScrollbarBackgroundColor = new Color(0f, 0f, 0f, 0.18f);

		public static RectTransform Ensure(RectTransform panel, TMP_Text text, ScrollableTooltipBodyState state, Sprite? sprite, float scrollSensitivity, bool scrollRectEnabled, bool inertia, bool handleRaycastTarget, bool scrollbarRaycastTarget)
		{
			state.ScrollView = EnsureChildRect(panel, state.ScrollView, "TextScrollView", typeof(RectTransform), typeof(Image), typeof(ScrollRect));
			state.Viewport = EnsureChildRect(state.ScrollView, state.Viewport, "Viewport", typeof(RectTransform), typeof(Image), typeof(RectMask2D));
			state.Content = EnsureChildRect(state.Viewport, state.Content, "Content", typeof(RectTransform));
			ConfigureTransparentImage(state.ScrollView, sprite);
			ConfigureTransparentImage(state.Viewport, sprite);
			if ((Object)(object)((Component)state.Viewport).GetComponent<RectMask2D>() == (Object)null)
			{
				((Component)state.Viewport).gameObject.AddComponent<RectMask2D>();
			}
			state.ScrollRect = ((Component)state.ScrollView).GetComponent<ScrollRect>() ?? ((Component)state.ScrollView).gameObject.AddComponent<ScrollRect>();
			((Behaviour)state.ScrollRect).enabled = scrollRectEnabled;
			state.ScrollRect.horizontal = false;
			state.ScrollRect.vertical = true;
			state.ScrollRect.movementType = (MovementType)2;
			state.ScrollRect.inertia = inertia;
			state.ScrollRect.scrollSensitivity = scrollSensitivity;
			state.ScrollRect.viewport = state.Viewport;
			state.ScrollRect.content = state.Content;
			RectTransform rectTransform = text.rectTransform;
			int num;
			if (!IsNull((Object?)(object)state.Text))
			{
				num = (((Object)(object)state.Text != (Object)(object)text) ? 1 : 0);
				if (num == 0)
				{
					goto IL_01b7;
				}
			}
			else
			{
				num = 1;
			}
			state.TextOriginalSnapshot = null;
			goto IL_01b7;
			IL_01b7:
			if ((num != 0 || state.TextOriginalSnapshot == null) && (Object)(object)((Transform)rectTransform).parent != (Object)(object)state.Content)
			{
				state.TextOriginalSnapshot = new RectTransformSnapshot(rectTransform);
			}
			state.Text = text;
			if ((Object)(object)((Transform)rectTransform).parent != (Object)(object)state.Content)
			{
				((Transform)rectTransform).SetParent((Transform)(object)state.Content, false);
			}
			((Behaviour)text).enabled = true;
			((Component)text).gameObject.SetActive(true);
			((Graphic)text).raycastTarget = false;
			text.overflowMode = (TextOverflowModes)0;
			text.textWrappingMode = (TextWrappingModes)1;
			EnsureScrollbar(panel, state, sprite, handleRaycastTarget, scrollbarRaycastTarget);
			return state.Content;
		}

		public static void Restore(ScrollableTooltipBodyState state)
		{
			//IL_00b6: 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)
			bool flag = false;
			RectTransform val = null;
			if (!IsNull((Object?)(object)state.Text) && state.TextOriginalSnapshot != null)
			{
				state.TextOriginalSnapshot.Restore();
				flag = true;
				Transform parent = ((Transform)state.Text.rectTransform).parent;
				val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			}
			if (!flag && !IsNull((Object?)(object)state.Text) && !IsNull((Object?)(object)state.ScrollView))
			{
				Transform parent2 = ((Transform)state.ScrollView).parent;
				RectTransform val2 = (RectTransform)(object)((parent2 is RectTransform) ? parent2 : null);
				if (val2 != null)
				{
					RectTransform rectTransform = state.Text.rectTransform;
					int siblingIndex = ((Transform)state.ScrollView).GetSiblingIndex();
					if ((Object)(object)((Transform)rectTransform).parent != (Object)(object)val2)
					{
						((Transform)rectTransform).SetParent((Transform)(object)val2, false);
					}
					((Transform)rectTransform).SetSiblingIndex(Mathf.Clamp(siblingIndex, 0, ((Transform)val2).childCount - 1));
					((Transform)rectTransform).localScale = Vector3.one;
					((Transform)rectTransform).localRotation = Quaternion.identity;
					val = val2;
				}
			}
			if (!IsNull((Object?)(object)state.Text))
			{
				((Behaviour)state.Text).enabled = true;
				((Component)state.Text).gameObject.SetActive(true);
			}
			if (!IsNull((Object?)(object)state.ScrollRect))
			{
				((Behaviour)state.ScrollRect).enabled = false;
				state.ScrollRect.verticalScrollbar = null;
			}
			if (!IsNull((Object?)(object)state.Scrollbar))
			{
				((Component)state.Scrollbar).gameObject.SetActive(false);
				((Behaviour)state.Scrollbar).enabled = false;
			}
			if (!IsNull((Object?)(object)state.ScrollView))
			{
				((Component)state.ScrollView).gameObject.SetActive(false);
			}
			if (!IsNull((Object?)(object)val))
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val);
			}
			state.Text = null;
			state.TextOriginalSnapshot = null;
		}

		public static ScrollableTooltipBodyLayoutResult LayoutPixelScroll(ScrollableTooltipBodyState state, TMP_Text text, float textWidth, float horizontalPadding, float top, float viewportHeight, float contentHeight, float scrollOffset, float scrollbarOutsideOffset, float scrollbarWidth, bool enableScrollRectWhenNeeded)
		{
			//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_0086: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00d7: 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_00ed: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_017d: 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_01a7: 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_01c0: 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_01d6: 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_023b: Expected O, but got Unknown
			if (IsNull((Object?)(object)state.ScrollView) || IsNull((Object?)(object)state.Viewport) || IsNull((Object?)(object)state.Content))
			{
				return new ScrollableTooltipBodyLayoutResult(0f, 0f, needsScroll: false);
			}
			RectTransform? scrollView = state.ScrollView;
			scrollView.anchorMin = new Vector2(0f, 1f);
			scrollView.anchorMax = new Vector2(1f, 1f);
			scrollView.pivot = new Vector2(0.5f, 1f);
			scrollView.anchoredPosition = new Vector2(0f, 0f - top);
			scrollView.sizeDelta = new Vector2((0f - horizontalPadding) * 2f, viewportHeight);
			((Transform)scrollView).localScale = Vector3.one;
			((Transform)scrollView).localRotation = Quaternion.identity;
			RectTransform? viewport = state.Viewport;
			viewport.anchorMin = Vector2.zero;
			viewport.anchorMax = Vector2.one;
			viewport.offsetMin = Vector2.zero;
			viewport.offsetMax = Vector2.zero;
			((Transform)viewport).localScale = Vector3.one;
			((Transform)viewport).localRotation = Quaternion.identity;
			RectTransform content = state.Content;
			content.anchorMin = new Vector2(0f, 1f);
			content.anchorMax = new Vector2(0f, 1f);
			content.pivot = new Vector2(0f, 1f);
			content.sizeDelta = new Vector2(textWidth, contentHeight);
			RectTransform rectTransform = text.rectTransform;
			if ((Object)(object)((Transform)rectTransform).parent != (Object)(object)content)
			{
				((Transform)rectTransform).SetParent((Transform)(object)content, false);
			}
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = Vector2.zero;
			rectTransform.sizeDelta = new Vector2(textWidth, contentHeight);
			((Transform)rectTransform).localScale = Vector3.one;
			((Transform)rectTransform).localRotation = Quaternion.identity;
			float num = Mathf.Max(0f, contentHeight - viewportHeight);
			scrollOffset = Mathf.Clamp(scrollOffset, 0f, num);
			bool flag = num > 1f;
			ApplyPixelScrollPosition(state, scrollOffset, num);
			if (!IsNull((Object?)(object)state.Scrollbar))
			{
				LayoutFloatingScrollbar((RectTransform)((Component)state.Scrollbar).transform, scrollbarOutsideOffset, scrollbarWidth, top, viewportHeight);
				((Component)state.Scrollbar).gameObject.SetActive(flag);
				((Behaviour)state.Scrollbar).enabled = flag;
				state.Scrollbar.size = (flag ? Mathf.Clamp01(viewportHeight / contentHeight) : 1f);
			}
			if (!IsNull((Object?)(object)state.ScrollRect))
			{
				((Behaviour)state.ScrollRect).enabled = enableScrollRectWhenNeeded && flag;
				state.ScrollRect.verticalScrollbar = (flag ? state.Scrollbar : null);
				state.ScrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)(!flag);
			}
			return new ScrollableTooltipBodyLayoutResult(scrollOffset, num, flag);
		}

		public static void ApplyPixelScrollPosition(ScrollableTooltipBodyState state, float scrollOffset, float maxScroll)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsNull((Object?)(object)state.Content))
			{
				state.Content.anchoredPosition = new Vector2(0f, scrollOffset);
				if (!IsNull((Object?)(object)state.Scrollbar))
				{
					state.Scrollbar.value = ((maxScroll > 1f) ? (1f - Mathf.Clamp01(scrollOffset / maxScroll)) : 1f);
				}
			}
		}

		public static void LayoutStretchScrollbar(RectTransform rect, float outsideOffset, float width, float topReserved, float bottomReserved)
		{
			//IL_000b: 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_0035: 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_0053: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(1f, 0f);
			rect.anchorMax = new Vector2(1f, 1f);
			rect.pivot = new Vector2(0f, 0.5f);
			rect.offsetMin = new Vector2(outsideOffset, bottomReserved);
			rect.offsetMax = new Vector2(outsideOffset + width, 0f - topReserved);
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		public static ScrollableTooltipBodyState FromPinnedCache(PinnedTooltipPanelUiCache cache)
		{
			return new ScrollableTooltipBodyState
			{
				ScrollView = cache.TextScrollView,
				Viewport = cache.TextViewport,
				Content = cache.TextContent,
				ScrollRect = cache.TextScrollRect,
				Scrollbar = cache.TextScrollbar
			};
		}

		public static void ApplyToPinnedCache(ScrollableTooltipBodyState state, PinnedTooltipPanelUiCache cache)
		{
			cache.TextScrollView = state.ScrollView;
			cache.TextViewport = state.Viewport;
			cache.TextContent = state.Content;
			cache.TextScrollRect = state.ScrollRect;
			cache.TextScrollbar = state.Scrollbar;
		}

		private static void EnsureScrollbar(RectTransform panel, ScrollableTooltipBodyState state, Sprite? sprite, bool handleRaycastTarget, bool scrollbarRaycastTarget)
		{
			//IL_0048: 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_005e: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00e9: 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)
			RectTransform val = EnsureScrollbarRect(panel, state.Scrollbar);
			state.Scrollbar = ((Component)val).GetComponent<Scrollbar>() ?? ((Component)val).gameObject.AddComponent<Scrollbar>();
			RectTransform obj = EnsureChildRect(val, null, "Sliding Area", typeof(RectTransform));
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			RectTransform val2 = EnsureChildRect(obj, null, "Handle", typeof(RectTransform), typeof(Image));
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			Image val3 = ((Component)val2).GetComponent<Image>() ?? ((Component)val2).gameObject.AddComponent<Image>();
			val3.sprite = sprite;
			((Graphic)val3).color = DefaultHandleColor;
			((Graphic)val3).raycastTarget = handleRaycastTarget;
			state.Scrollbar.handleRect = val2;
			((Selectable)state.Scrollbar).targetGraphic = (Graphic)(object)val3;
			state.Scrollbar.direction = (Direction)2;
			Image obj2 = ((Component)val).GetComponent<Image>() ?? ((Component)val).gameObject.AddComponent<Image>();
			obj2.sprite = sprite;
			((Graphic)obj2).color = DefaultScrollbarBackgroundColor;
			((Graphic)obj2).raycastTarget = scrollbarRaycastTarget;
			((Component)state.Scrollbar).gameObject.SetActive(false);
			if (!IsNull((Object?)(object)state.ScrollRect))
			{
				state.ScrollRect.verticalScrollbar = state.Scrollbar;
				state.ScrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)1;
			}
		}

		private static RectTransform EnsureScrollbarRect(RectTransform parent, Scrollbar? current)
		{
			//IL_00a8: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((!IsNull((Object?)(object)current)) ? /*isinst with value type is only supported in some contexts*/: null);
			if (!IsNull((Object?)(object)val) && (Object)(object)((Transform)val).parent == (Object)(object)parent)
			{
				((Component)val).gameObject.SetActive(true);
				return val;
			}
			Transform val2 = ((Transform)parent).Find("TextScrollbar");
			RectTransform val3 = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<RectTransform>() : null);
			if (IsNull((Object?)(object)val3))
			{
				val3 = new GameObject("TextScrollbar", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Scrollbar)
				}).GetComponent<RectTransform>();
			}
			((Transform)val3).SetParent((Transform)(object)parent, false);
			((Transform)val3).localScale = Vector3.one;
			((Transform)val3).localRotation = Quaternion.identity;
			((Component)val3).gameObject.SetActive(true);
			return val3;
		}

		private static RectTransform EnsureChildRect(RectTransform parent, RectTransform? current, string name, params Type[] components)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!IsNull((Object?)(object)current) && (Object)(object)((Transform)current).parent == (Object)(object)parent)
			{
				((Component)current).gameObject.SetActive(true);
				return current;
			}
			Transform val = ((Transform)parent).Find(name);
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if (IsNull((Object?)(object)val2))
			{
				val2 = new GameObject(name, components).GetComponent<RectTransform>();
			}
			((Transform)val2).SetParent((Transform)(object)parent, false);
			((Transform)val2).localScale = Vector3.one;
			((Transform)val2).localRotation = Quaternion.identity;
			((Component)val2).gameObject.SetActive(true);
			return val2;
		}

		private static void ConfigureTransparentImage(RectTransform rect, Sprite? sprite)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Image obj = ((Component)rect).GetComponent<Image>() ?? ((Component)rect).gameObject.AddComponent<Image>();
			obj.sprite = sprite;
			((Graphic)obj).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)obj).raycastTarget = false;
		}

		private static void LayoutFloatingScrollbar(RectTransform rect, float outsideOffset, float width, float top, float viewportHeight)
		{
			//IL_000b: 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_0035: 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_0051: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(1f, 1f);
			rect.anchorMax = new Vector2(1f, 1f);
			rect.pivot = new Vector2(0f, 1f);
			rect.anchoredPosition = new Vector2(outsideOffset, 0f - top);
			rect.sizeDelta = new Vector2(width, viewportHeight);
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		private static bool IsNull(Object? obj)
		{
			return obj == (Object)null;
		}
	}
	internal sealed class SimpleTooltipOwnershipCore
	{
		public object? Owner { get; private set; }

		public bool Visible { get; private set; }

		public void Show(object owner)
		{
			Owner = owner;
			Visible = true;
		}

		public bool Hide(object owner)
		{
			if (!Visible || Owner != owner)
			{
				return false;
			}
			ForceHide();
			return true;
		}

		public void ForceHide()
		{
			Owner = null;
			Visible = false;
		}
	}
	[Serializable]
	internal sealed class InventorySlotsBackup
	{
		public int version { get; set; }

		public string date { get; set; } = "";

		public string worldName { get; set; } = "";

		public int nrOfItems { get; set; }

		public int width { get; set; }

		public int height { get; set; }

		public int fixedRegularRows { get; set; }

		public int fullHeight { get; set; }

		public string inventoryBase64 { get; set; } = "";
	}
	internal static class SortKeyComparerCore
	{
		public static int Compare(SortKey a, SortKey b, CraftingRecipeSortMode mode)
		{
			if (ShouldClusterEquipmentSets(mode) && a.ResourceTier == b.ResourceTier && a.HasSet && b.HasSet)
			{
				int num = string.Compare(a.SetKey, b.SetKey, StringComparison.OrdinalIgnoreCase);
				if (num != 0)
				{
					return num;
				}
				int num2 = a.EquipmentSlotOrder.CompareTo(b.EquipmentSlotOrder);
				if (num2 != 0)
				{
					return num2;
				}
			}
			int num3 = ((mode == CraftingRecipeSortMode.GroupThenTier) ? CompareGroupThenTier(a, b) : CompareTierThenGroup(a, b));
			if (num3 != 0)
			{
				return num3;
			}
			num3 = a.SetBucket.CompareTo(b.SetBucket);
			if (num3 != 0)
			{
				return num3;
			}
			num3 = string.Compare(a.SetKey, b.SetKey, StringComparison.OrdinalIgnoreCase);
			if (num3 != 0)
			{
				return num3;
			}
			num3 = a.EquipmentSlotOrder.CompareTo(b.EquipmentSlotOrder);
			if (num3 != 0)
			{
				return num3;
			}
			return string.Compare(a.LocalizedName, b.LocalizedName, StringComparison.OrdinalIgnoreCase);
		}

		private static bool ShouldClusterEquipmentSets(CraftingRecipeSortMode mode)
		{
			return mode == CraftingRecipeSortMode.TierThenGroup;
		}

		private static int CompareTierThenGroup(SortKey a, SortKey b)
		{
			int num = b.ResourceTier.CompareTo(a.ResourceTier);
			if (num != 0)
			{
				return num;
			}
			num = a.BigGroupRank.CompareTo(b.BigGroupRank);
			if (num != 0)
			{
				return num;
			}
			return a.GroupRank.CompareTo(b.GroupRank);
		}

		private static int CompareGroupThenTier(SortKey a, SortKey b)
		{
			int num = a.BigGroupRank.CompareTo(b.BigGroupRank);
			if (num != 0)
			{
				return num;
			}
			num = a.GroupRank.CompareTo(b.GroupRank);
			if (num != 0)
			{
				return num;
			}
			return b.ResourceTier.CompareTo(a.ResourceTier);
		}
	}
	internal enum CraftingRecipeSortMode
	{
		TierThenGroup,
		GroupThenTier
	}
	internal sealed class SortKey
	{
		public static readonly SortKey None = new SortKey(0, int.MaxValue, int.MaxValue, "", 99, "");

		public int ResourceTier { get; }

		public int GroupRank { get; }

		public int BigGroupRank { get; }

		public string SetKey { get; }

		public bool HasSet => !string.IsNullOrWhiteSpace(SetKey);

		public int SetBucket => (!HasSet) ? 1 : 0;

		public int EquipmentSlotOrder { get; }

		public string LocalizedName { get; }

		public SortKey(int resourceTier, int groupRank, int bigGroupRank, string setKey, int equipmentSlotOrder, string localizedName)
		{
			ResourceTier = resourceTier;
			GroupRank = groupRank;
			BigGroupRank = bigGroupRank;
			SetKey = setKey;
			EquipmentSlotOrder = equipmentSlotOrder;
			LocalizedName = localizedName;
		}
	}
	internal sealed class TooltipSourceCacheCore<TKey, TValue> where TKey : notnull
	{
		private readonly Dictionary<TKey, TValue> _items;

		private readonly List<TKey> _order = new List<TKey>();

		private readonly IEqualityComparer<TKey> _comparer;

		private readonly int _maxEntries;

		public int Count => _items.Count;

		public TooltipSourceCacheCore(int maxEntries, IEqualityComparer<TKey>? comparer = null)
		{
			_maxEntries = Math.Max(1, maxEntries);
			_comparer = comparer ?? EqualityComparer<TKey>.Default;
			_items = new Dictionary<TKey, TValue>(_comparer);
		}

		public void Set(TKey key, TValue value)
		{
			if (!_items.ContainsKey(key))
			{
				_order.Add(key);
			}
			_items[key] = value;
			TrimOverflow();
		}

		public bool TryGet(TKey key, out TValue value)
		{
			return _items.TryGetValue(key, out value);
		}

		public bool Remove(TKey key)
		{
			if (!_items.Remove(key))
			{
				return false;
			}
			RemoveOrderedKey(key);
			return true;
		}

		public int RemoveWhere(Func<TKey, TValue, bool> predicate)
		{
			int num = 0;
			for (int num2 = _order.Count - 1; num2 >= 0; num2--)
			{
				TKey val = _order[num2];
				if (!_items.TryGetValue(val, out var value))
				{
					_order.RemoveAt(num2);
				}
				else if (predicate(val, value))
				{
					_items.Remove(val);
					_order.RemoveAt(num2);
					num++;
				}
			}
			return num;
		}

		public void Clear()
		{
			_items.Clear();
			_order.Clear();
		}

		private void TrimOverflow()
		{
			while (_items.Count > _maxEntries && _order.Count > 0)
			{
				TKey key = _order[0];
				_order.RemoveAt(0);
				_items.Remove(key);
			}
		}

		private void RemoveOrderedKey(TKey key)
		{
			for (int i = 0; i < _order.Count; i++)
			{
				if (_comparer.Equals(_order[i], key))
				{
					_order.RemoveAt(i);
					break;
				}
			}
		}
	}
	internal static class UpgradeFavoriteCore
	{
		public static string GetItemId(IDictionary<string, string>? customData, string key)
		{
			if (customData == null || string.IsNullOrWhiteSpace(key))
			{
				return "";
			}
			if (!customData.TryGetValue(key, out string value))
			{
				return "";
			}
			return (value ?? "").Trim();
		}

		public static string GetOrCreateItemId(IDictionary<string, string> customData, string key, ISet<string> existingIds, Func<string> createId)
		{
			string itemId = GetItemId(customData, key);
			if (!string.IsNullOrWhiteSpace(itemId))
			{
				return itemId;
			}
			string text;
			do
			{
				text = createId().Trim();
			}
			while (string.IsNullOrWhiteSpace(text) || existingIds.Contains(text));
			customData[key] = text;
			return text;
		}

		public static void SetItemId(IDictionary<string, string> customData, string key, string id)
		{
			if (customData != null && !string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(id))
			{
				customData[key] = id.Trim();
			}
		}

		public static bool RemoveItemId(IDictionary<string, string>? customData, string key)
		{
			if (customData != null && !string.IsNullOrWhiteSpace(key))
			{
				return customData.Remove(key);
			}
			return false;
		}
	}
}
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;
		}
	}
}