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.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.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.0.4")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LocalizationManager
{
	internal static class Localizer
	{
		[CompilerGenerated]
		private sealed class <FindExternalTranslationFiles>d__15 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string language;

			public string <>3__language;

			private string <modName>5__2;

			private IEnumerator<string> <>7__wrap2;

			private string <root>5__4;

			private string[] <>7__wrap4;

			private int <>7__wrap5;

			private string[] <>7__wrap6;

			private int <>7__wrap7;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						<>7__wrap7++;
						goto IL_011f;
					}
					<>1__state = -1;
					if ((Object)(object)_plugin == (Object)null)
					{
						return false;
					}
					<modName>5__2 = _plugin.Info.Metadata.Name;
					<>7__wrap2 = GetExternalTranslationRoots().GetEnumerator();
					<>1__state = -3;
					goto IL_0165;
					IL_011f:
					if (<>7__wrap7 < <>7__wrap6.Length)
					{
						string text = <>7__wrap6[<>7__wrap7];
						<>2__current = text;
						<>1__state = 1;
						return true;
					}
					<>7__wrap6 = null;
					<>7__wrap5++;
					goto IL_0144;
					IL_0144:
					if (<>7__wrap5 < <>7__wrap4.Length)
					{
						string text2 = <>7__wrap4[<>7__wrap5];
						string searchPattern = <modName>5__2 + "." + language + text2;
						<>7__wrap6 = Directory.GetFiles(<root>5__4, searchPattern, SearchOption.AllDirectories);
						<>7__wrap7 = 0;
						goto IL_011f;
					}
					<>7__wrap4 = null;
					<root>5__4 = null;
					goto IL_0165;
					IL_0165:
					do
					{
						if (<>7__wrap2.MoveNext())
						{
							<root>5__4 = <>7__wrap2.Current;
							continue;
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						return false;
					}
					while (!Directory.Exists(<root>5__4));
					<>7__wrap4 = FileExtensions;
					<>7__wrap5 = 0;
					goto IL_0144;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<FindExternalTranslationFiles>d__15 <FindExternalTranslationFiles>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindExternalTranslationFiles>d__ = this;
				}
				else
				{
					<FindExternalTranslationFiles>d__ = new <FindExternalTranslationFiles>d__15(0);
				}
				<FindExternalTranslationFiles>d__.language = <>3__language;
				return <FindExternalTranslationFiles>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetExternalTranslationRoots>d__16 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!string.IsNullOrWhiteSpace(Paths.PluginPath))
					{
						<>2__current = Paths.PluginPath;
						<>1__state = 1;
						return true;
					}
					goto IL_0049;
				case 1:
					<>1__state = -1;
					goto IL_0049;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0049:
					if ((Object)(object)_plugin != (Object)null)
					{
						<>2__current = Path.Combine(Paths.ConfigPath, _plugin.Info.Metadata.GUID + "Translations");
						<>1__state = 2;
						return true;
					}
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetExternalTranslationRoots>d__16(0);
			}

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

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

		[IteratorStateMachine(typeof(<FindExternalTranslationFiles>d__15))]
		private static IEnumerable<string> FindExternalTranslationFiles(string language)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindExternalTranslationFiles>d__15(-2)
			{
				<>3__language = language
			};
		}

		[IteratorStateMachine(typeof(<GetExternalTranslationRoots>d__16))]
		private static IEnumerable<string> GetExternalTranslationRoots()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetExternalTranslationRoots>d__16(-2);
		}

		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)
		{
			string resourceFileName2 = resourceFileName;
			if ((Object)(object)_plugin == (Object)null)
			{
				return null;
			}
			Assembly assembly = ((object)_plugin).GetType().Assembly;
			string text = assembly.GetManifestResourceNames().FirstOrDefault((string name) => name.EndsWith(resourceFileName2, 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.0.4")]
	[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.*/)]
	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 FieldInfo? _backpackEquippedField;

			private AdventureBackpacksApi(MethodInfo isBackpackMethod, MethodInfo? equipItemPostfixMethod, MethodInfo? unequipItemPrefixMethod, MethodInfo? isBackpackEquippedMethod, MethodInfo? isThisBackpackEquippedMethod, MethodInfo? getEquippedBackpackMethod, FieldInfo? backpackEquippedField)
			{
				_isBackpackMethod = isBackpackMethod;
				_equipItemPostfixMethod = equipItemPostfixMethod;
				_unequipItemPrefixMethod = unequipItemPrefixMethod;
				_isBackpackEquippedMethod = isBackpackEquippedMethod;
				_isThisBackpackEquippedMethod = isThisBackpackEquippedMethod;
				_getEquippedBackpackMethod = getEquippedBackpackMethod;
				_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");
				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), 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 ex)
				{
					Log.LogDebug((object)("AdventureBackpacks equip sync failed: " + ex.Message));
				}
			}

			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 ex)
				{
					Log.LogDebug((object)("AdventureBackpacks unequip sync failed: " + ex.Message));
				}
				finally
				{
					((Humanoid)player).m_shoulderItem = shoulderItem;
				}
			}

			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);
					Log.LogDebug((object)((label ?? target.Name) + " compatibility patch applied."));
				}
			}
		}

		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 ex)
				{
					Log.LogDebug((object)("Smoothbrain Backpacks visual sync failed: " + ex.Message));
				}
			}

			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 ex)
				{
					Log.LogDebug((object)("RustyBags equipment sync failed: " + ex.Message));
				}
			}

			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 delegate bool CompatApiFactory<TApi>(Assembly assembly, out TApi? api, out string detail) where TApi : class;

		private enum CompatCapabilityState
		{
			Unknown,
			Unavailable,
			Available,
			MissingApi,
			Failed
		}

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

			public bool ReflectionFailed;

			public CompatCapabilityState CapabilityState;
		}

		private sealed class CompatRuntimeState
		{
			public bool MyLittleUICraftingCompatibilityApplied;

			public bool JewelcraftingSlotStateInitialized;

			public bool AdventureBackpacksPatchesApplied;

			public bool LastJewelcraftingRingSlotEnabled;

			public bool LastJewelcraftingNecklaceSlotEnabled;

			public ItemData? LastAdventureBackpackCompatItem;

			public ItemData? LastSmoothbrainBackpackCompatItem;

			public ItemData? LastRustyBagCompatItem;

			public ItemData? LastRustyQuiverCompatItem;

			public ItemData? LastMagicSupremacyBeltCompatItem;

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

		private readonly struct SfxVolumeMemberCache
		{
			public FieldInfo[] Fields { get; }

			public PropertyInfo[] Properties { get; }

			public SfxVolumeMemberCache(FieldInfo[] fields, PropertyInfo[] properties)
			{
				Fields = fields;
				Properties = properties;
			}
		}

		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 sealed class CustomEquipmentVisualState
		{
			public string SlotId { get; }

			public int ItemHash { get; }

			public int Variant { get; }

			public string PrefabName { get; }

			public ItemType ItemType { get; }

			public CustomEquipmentVisualState(string slotId, int itemHash, int variant, string prefabName, ItemType itemType)
			{
				//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;
			}
		}

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

		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 string RecipeGridSignature = "";

			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 string RecipeScrollbarSignature = "";
		}

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

		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? TooltipExpandedPanel;

			public RectTransform? TooltipGemIconRow;

			public TMP_InputField? SearchInput;

			public RectTransform? SearchInputRect;

			public RectTransform? RecipeGridZoomHint;

			public TMP_Text? RecipeGridZoomHintText;

			public bool SearchInputDirty = true;

			public int HoveredRecipeIndex = -1;

			public string SearchInputSignature = "";

			public string RecipeGridZoomHintSignature = "";

			public string HoverTooltipSignature = "";

			public string HoverTooltipContentKey = "";

			public string HoverTooltipLayoutSignature = "";

			public string HoverTooltipVisualSignature = "";

			public string HoverGemIconSignature = "";

			public float HoverTooltipScrollOffset;

			public float HoverTooltipMaxScroll;
		}

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

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

			public static void MarkRecipeViewDirty()
			{
				_craftingRecipeViewDirty = true;
				_craftingRecipeViewSignature = "";
			}

			public static void MarkRecipeGridDirty()
			{
				_craftingRecipeGridDirty = true;
				_craftingRecipeGridSignature = "";
			}

			public static void MarkRecipeScrollbarDirty()
			{
				_craftingRecipeScrollbarDirty = true;
				_craftingRecipeScrollbarSignature = "";
			}

			public static void MarkGroupRailDirty()
			{
				_craftingGroupRailDirty = true;
				_craftingGroupRailSignature = "";
			}

			public static void MarkBottomControlsDirty()
			{
				_craftingBottomControlsDirty = true;
				_craftingBottomControlsSignature = "";
			}

			public static void MarkSearchInputDirty()
			{
				CraftingUi.SearchInputDirty = true;
				CraftingUi.SearchInputSignature = "";
			}

			public static void MarkRecipeViewDirtyCascade()
			{
				MarkRecipeViewDirty();
				MarkRecipeGridDirty();
				MarkRecipeScrollbarDirty();
				MarkGroupRailDirty();
				MarkBottomControlsDirty();
			}

			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 InvalidateRecipeGridZoomHint()
			{
				CraftingUi.RecipeGridZoomHintSignature = "";
			}

			public static void ClearHoverTooltipContentKey()
			{
				CraftingUi.HoverTooltipContentKey = "";
			}
		}

		private sealed class CraftingTooltipNativePanelLayoutState : MonoBehaviour
		{
			public float AppliedOffsetMinYDelta;
		}

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

			public Vector2i OriginalGridPos { get; }

			public string OriginalSlotId { get; }

			public SlotKind? OriginalSlotKind { get; }

			public bool WasQuickSlot => OriginalSlotKind.GetValueOrDefault() == 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;
			}
		}

		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 string Signature = "";
		}

		private enum FoodStat
		{
			None,
			Health,
			Stamina,
			Eitr
		}

		private static class ItemClassifierController
		{
			public static string GetInventoryItemBigGroupId(ItemClassifierRuntimeState state, ItemData item, IReadOnlyList<CraftingRecipeGroupFilter> groupFilters)
			{
				if (item?.m_shared == null)
				{
					return "";
				}
				ItemClassification itemClassification = GetItemClassification(state, item);
				if (itemClassification.BigGroupResolved)
				{
					return itemClassification.BigGroupId;
				}
				for (int i = 0; i < groupFilters.Count; i++)
				{
					CraftingRecipeGroupFilter craftingRecipeGroupFilter = groupFilters[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;
			}

			public static bool ItemMatchesBuiltInPredefinedGroup(ItemClassifierRuntimeState state, ItemData item, string groupId)
			{
				string text = NormalizeGroupId(groupId);
				if (item?.m_shared == null || string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				ItemClassification itemClassification = GetItemClassification(state, item);
				if (itemClassification.BuiltInGroupMatches.TryGetValue(text, out var value))
				{
					return value;
				}
				bool flag = ItemMatchesBuiltInPredefinedGroupUncached(item, text);
				itemClassification.BuiltInGroupMatches[text] = flag;
				return flag;
			}

			public static void ClearCaches(ItemClassifierRuntimeState state)
			{
				state.Cache.Clear();
				state.Signature = "";
			}

			private static ItemClassification GetItemClassification(ItemClassifierRuntimeState state, ItemData item)
			{
				EnsureCacheFresh(state);
				string itemClassifierCacheKey = GetItemClassifierCacheKey(item);
				if (state.Cache.TryGetValue(itemClassifierCacheKey, out ItemClassification value))
				{
					return value;
				}
				if (state.Cache.Count >= 2048)
				{
					state.Cache.Clear();
				}
				ItemClassification itemClassification = new ItemClassification();
				state.Cache[itemClassifierCacheKey] = itemClassification;
				return itemClassification;
			}

			private static void EnsureCacheFresh(ItemClassifierRuntimeState state)
			{
				string itemClassifierCacheSignature = GetItemClassifierCacheSignature();
				if (!string.Equals(state.Signature, itemClassifierCacheSignature, StringComparison.Ordinal))
				{
					state.Cache.Clear();
					state.Signature = itemClassifierCacheSignature;
				}
			}
		}

		private static class ItemSortController
		{
			public static void EnsureRecipeOutputLookupCache(InventorySortRuntimeState state)
			{
				string recipeOutputLookupSignature = GetRecipeOutputLookupSignature();
				if (string.Equals(state.RecipeOutputLookupSignature, recipeOutputLookupSignature, StringComparison.Ordinal))
				{
					return;
				}
				state.RecipeOutputLookupCache.Clear();
				state.RecipeOutputLookupSignature = recipeOutputLookupSignature;
				if (ObjectDB.instance?.m_recipes == null)
				{
					return;
				}
				foreach (Recipe recipe in ObjectDB.instance.m_recipes)
				{
					AddRecipeOutputLookup(recipe);
				}
			}

			public static void ClearCaches(InventorySortRuntimeState state)
			{
				state.RecipeOutputLookupCache.Clear();
				state.RecipeOutputLookupSignature = "";
			}
		}

		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 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 sealed class JewelcraftingGemApi
		{
			private readonly MethodInfo _getGemsMethod;

			private readonly MethodInfo? _itemDataMethod;

			private readonly MethodInfo? _itemInfoGetSocketableMethod;

			private readonly FieldInfo? _socketedGemsField;

			private readonly FieldInfo? _socketNameField;

			private readonly FieldInfo? _socketSeedField;

			private readonly FieldInfo? _effectPowersField;

			private readonly FieldInfo? _effectNamesField;

			private readonly MethodInfo? _getGemLocationMethod;

			private readonly MethodInfo? _getItemGemLocationMethod;

			private readonly MethodInfo? _displayGemEffectPowerMethod;

			private readonly FieldInfo? _openEquipmentField;

			private readonly FieldInfo? _openInventoryField;

			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 readonly Dictionary<Type, MemberInfo?> _gemEffectsMembers = new Dictionary<Type, MemberInfo>();

			private JewelcraftingGemApi(MethodInfo getGemsMethod, MethodInfo? itemDataMethod, MethodInfo? itemInfoGetSocketableMethod, FieldInfo? socketedGemsField, FieldInfo? socketNameField, FieldInfo? socketSeedField, FieldInfo? effectPowersField, FieldInfo? effectNamesField, MethodInfo? getGemLocationMethod, MethodInfo? getItemGemLocationMethod, MethodInfo? displayGemEffectPowerMethod, FieldInfo? openEquipmentField, FieldInfo? openInventoryField, PropertyInfo? itemInfoItemDataProperty, MethodInfo? itemInfoGetAllSocketSeedsMethod, PropertyInfo? socketSeedSeedProperty)
			{
				_getGemsMethod = getGemsMethod;
				_itemDataMethod = itemDataMethod;
				_itemInfoGetSocketableMethod = itemInfoGetSocketableMethod;
				_socketedGemsField = socketedGemsField;
				_socketNameField = socketNameField;
				_socketSeedField = socketSeedField;
				_effectPowersField = effectPowersField;
				_effectNamesField = effectNamesField;
				_getGemLocationMethod = getGemLocationMethod;
				_getItemGemLocationMethod = getItemGemLocationMethod;
				_displayGemEffectPowerMethod = displayGemEffectPowerMethod;
				_openEquipmentField = openEquipmentField;
				_openInventoryField = openInventoryField;
				_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.SocketItem");
				Type type5 = assembly.GetType("Jewelcrafting.Jewelcrafting");
				Type type6 = assembly.GetType("Jewelcrafting.GemEffects.EffectDef");
				Type type7 = assembly.GetType("Jewelcrafting.Utils");
				Type type8 = assembly.GetType("Jewelcrafting.GemEffects.EffectPower");
				Type type9 = assembly.GetType("Jewelcrafting.GemStones+AddFakeSocketsContainer");
				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;
				if (type2 != null)
				{
					MethodInfo[] methods = type2.GetMethods(BindingFlags.Instance | BindingFlags.Public);
					foreach (MethodInfo methodInfo2 in methods)
					{
						if (type3 != null && methodInfo2.Name == "Get" && methodInfo2.IsGenericMethodDefinition && methodInfo2.GetParameters().Length == 1)
						{
							itemInfoGetSocketableMethod = methodInfo2.MakeGenericMethod(type3);
						}
						else if (type10 != null && methodInfo2.Name == "GetAll" && methodInfo2.IsGenericMethodDefinition && methodInfo2.GetParameters().Length == 0)
						{
							itemInfoGetAllSocketSeedsMethod = methodInfo2.MakeGenericMethod(type10);
						}
					}
				}
				MethodInfo displayGemEffectPowerMethod = null;
				if (type7 != null && type8 != null)
				{
					MethodInfo[] methods = type7.GetMethods(BindingFlags.Static | BindingFlags.Public);
					foreach (MethodInfo methodInfo3 in methods)
					{
						if (methodInfo3.Name == "DisplayGemEffectPower" && methodInfo3.GetParameters().Length == 5)
						{
							displayGemEffectPowerMethod = methodInfo3;
							break;
						}
					}
				}
				api = new JewelcraftingGemApi(methodInfo, itemDataMethod, itemInfoGetSocketableMethod, type3?.GetField("socketedGems", BindingFlags.Instance | BindingFlags.Public), type4?.GetField("Name", BindingFlags.Instance | BindingFlags.Public), type4?.GetField("Seed", BindingFlags.Instance | BindingFlags.Public), type5?.GetField("EffectPowers", BindingFlags.Static | BindingFlags.Public), type6?.GetField("EffectNames", BindingFlags.Static | BindingFlags.Public), type7?.GetMethod("GetGemLocation", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(SharedData),
					typeof(Player)
				}, null), type7?.GetMethod("GetItemGemLocation", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, null), displayGemEffectPowerMethod, type9?.GetField("openEquipment", BindingFlags.Static | BindingFlags.Public), type9?.GetField("openInventory", BindingFlags.Static | BindingFlags.Public), 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 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;
				}
			}

			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_0195:
				prefabName = text2;
				if (!((Object)(object)sprite != (Object)null))
				{
					return !string.IsNullOrWhiteSpace(prefabName);
				}
				return true;
				IL_017e:
				text2 = gemMemberValue2?.ToString() ?? "";
				goto IL_0195;
			}

			public bool TryGetGemTooltipData(object gem, out Sprite? sprite, out string prefabName, out List<KeyValuePair<string, float>> effects)
			{
				effects = new List<KeyValuePair<string, float>>();
				if (!TryGetGemIconData(gem, out sprite, out prefabName) && string.IsNullOrWhiteSpace(prefabName))
				{
					return false;
				}
				Type type = gem.GetType();
				if (!_gemEffectsMembers.TryGetValue(type, out MemberInfo value))
				{
					value = FindGemMember(type, typeof(IDictionary), "gemEffects", "GemEffects", "effects", "Effects");
					_gemEffectsMembers[type] = value;
				}
				if (!(GetGemMemberValue(value, gem) is IDictionary dictionary))
				{
					return true;
				}
				foreach (DictionaryEntry item in dictionary)
				{
					string text = item.Key?.ToString() ?? "";
					if (string.IsNullOrWhiteSpace(text))
					{
						continue;
					}
					float result;
					if (item.Value is float value2)
					{
						effects.Add(new KeyValuePair<string, float>(text, value2));
					}
					else if (item.Value is IConvertible convertible)
					{
						try
						{
							effects.Add(new KeyValuePair<string, float>(text, convertible.ToSingle(CultureInfo.InvariantCulture)));
						}
						catch
						{
						}
					}
					else if (item.Value != null && float.TryParse(item.Value.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out result))
					{
						effects.Add(new KeyValuePair<string, float>(text, result));
					}
				}
				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 ex)
				{
					Log.LogDebug((object)("Jewelcrafting direct socket read failed for " + GetItemPrefabName(item) + ": " + ex.Message));
				}
				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;
			}

			public string GetSocketDebugSummary(ItemData item)
			{
				List<JewelcraftingSocketGemData> socketGemData = GetSocketGemData(item);
				List<string> list = new List<string>();
				foreach (JewelcraftingSocketGemData item2 in socketGemData)
				{
					list.Add(string.IsNullOrWhiteSpace(item2.PrefabName) ? "<empty>" : item2.PrefabName);
				}
				return "directSockets=" + socketGemData.Count + ", directNames=" + string.Join("/", list);
			}

			public string GetOpenSocketDebugSummary(ItemData item)
			{
				List<JewelcraftingSocketGemData> openSocketGemData = GetOpenSocketGemData(item);
				List<string> list = new List<string>();
				foreach (JewelcraftingSocketGemData item2 in openSocketGemData)
				{
					list.Add(string.IsNullOrWhiteSpace(item2.PrefabName) ? "<empty>" : item2.PrefabName);
				}
				return "openSockets=" + openSocketGemData.Count + ", openNames=" + string.Join("/", list);
			}

			public string BuildSocketEffectText(ItemData item, JewelcraftingSocketGemData socket)
			{
				if (!socket.HasGem || _effectPowersField == null || _effectNamesField == null || _getGemLocationMethod == null || _getItemGemLocationMethod == null || _displayGemEffectPowerMethod == null || !(_effectPowersField.GetValue(null) is IDictionary dictionary) || !(_effectNamesField.GetValue(null) is IDictionary dictionary2))
				{
					return "";
				}
				object location = _getGemLocationMethod.Invoke(null, new object[2]
				{
					item.m_shared,
					Player.m_localPlayer
				});
				object location2 = _getItemGemLocationMethod.Invoke(null, new object[1] { item });
				List<object> list = new List<object>();
				int stableHashCode = StringExtensionMethods.GetStableHashCode(socket.PrefabName);
				if (dictionary.Contains(stableHashCode) && dictionary[stableHashCode] is IDictionary locationPowers)
				{
					AddLocationPowers(locationPowers, location, list);
					AddLocationPowers(locationPowers, location2, list);
				}
				if (list.Count == 0)
				{
					return "$jc_effect_no_effect";
				}
				List<string> list2 = new List<string>();
				foreach (object item2 in list)
				{
					object obj = item2.GetType().GetField("Effect", BindingFlags.Instance | BindingFlags.Public)?.GetValue(item2);
					string text = ((obj == null || !dictionary2.Contains(obj)) ? (obj?.ToString() ?? "") : (dictionary2[obj]?.ToString() ?? obj.ToString() ?? ""));
					string text2 = "";
					try
					{
						text2 = (_displayGemEffectPowerMethod.Invoke(null, new object[5] { item2, null, 0, socket.Seeds, false }) as string) ?? "";
					}
					catch
					{
					}
					if (!string.IsNullOrWhiteSpace(text))
					{
						list2.Add("$jc_effect_" + text.ToLowerInvariant() + (string.IsNullOrWhiteSpace(text2) ? "" : (" " + text2)));
					}
				}
				return string.Join("\n", list2);
			}

			private static void AddLocationPowers(IDictionary locationPowers, object? location, List<object> powers)
			{
				if (location == null || !locationPowers.Contains(location) || !(locationPowers[location] is IEnumerable enumerable))
				{
					return;
				}
				foreach (object item in enumerable)
				{
					if (item != null)
					{
						powers.Add(item);
					}
				}
			}

			private static Dictionary<string, uint>? CopySocketSeeds(object? seedObject)
			{
				if (!(seedObject is IDictionary dictionary) || dictionary.Count == 0)
				{
					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 dictionary) || dictionary.Count == 0)
					{
						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;
			}

			public string GetGemDebugSummary(object gem)
			{
				if (gem == null)
				{
					return "null";
				}
				Type type = gem.GetType();
				List<string> list = new List<string> { type.FullName ?? type.Name };
				MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MemberInfo memberInfo in members)
				{
					if (!(memberInfo is FieldInfo) && !(memberInfo is PropertyInfo))
					{
						continue;
					}
					object gemMemberValue = GetGemMemberValue(memberInfo, gem);
					string text;
					if (gemMemberValue != null)
					{
						Sprite val = (Sprite)((gemMemberValue is Sprite) ? gemMemberValue : null);
						if (val == null)
						{
							GameObject val2 = (GameObject)((gemMemberValue is GameObject) ? gemMemberValue : null);
							text = ((val2 != null) ? ("GameObject:" + ((Object)val2).name) : ((!(gemMemberValue is IDictionary dictionary)) ? (gemMemberValue.ToString() ?? "") : ("Dictionary:" + dictionary.Count)));
						}
						else
						{
							text = "Sprite:" + ((Object)val).name;
						}
					}
					else
					{
						text = "null";
					}
					string text2 = text;
					if (text2.Length > 80)
					{
						text2 = text2.Substring(0, 80) + "...";
					}
					list.Add(memberInfo.Name + "=" + text2);
					if (list.Count >= 8)
					{
						break;
					}
				}
				return string.Join(";", list);
			}

			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 propertyInfo) || !propertyInfo.CanRead || propertyInfo.GetIndexParameters().Length != 0) ? null : propertyInfo.GetValue(instance));
				}
				catch
				{
					return null;
				}
			}
		}

		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 MethodInfo? _isJewelryEquippedMethod;

			private ConfigEntryBase? _ringSlotConfig;

			private ConfigEntryBase? _necklaceSlotConfig;

			private JewelcraftingSlotApi(FieldInfo ringSlotField, FieldInfo necklaceSlotField, MethodInfo? isJewelryEquippedMethod)
			{
				_ringSlotField = ringSlotField;
				_necklaceSlotField = necklaceSlotField;
				_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);
				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, isJewelryEquippedMethod);
				detail = "";
				return true;
			}

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

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

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

		internal enum InventoryStateEnsureReason
		{
			Unknown,
			PeriodicAudit,
			PlayerAwake,
			PlayerSpawned,
			PlayerLoad,
			PlayerSave,
			InventoryChanged,
			EquipmentChanged,
			InventoryLoad,
			InventoryMove,
			Tombstone,
			GuiShow,
			SlotAction,
			BackupRestore,
			YamlReload,
			JewelcraftingSlotRefresh,
			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? PlayerInventoryScrollbar;

			public Scrollbar? PlayerInventoryScrollbarComponent;

			public RectTransform? PlayerInventoryResizeHandle;

			public TMP_Text? PlayerInventoryResizeHandleLabel;

			public RectTransform? TrackedContainerPanel;

			public RectTransform? TrackedContainerWeightPanel;

			public Vector3 ContainerPanelBasePosition;

			public Vector3 ContainerPanelAppliedOffset;

			public Vector3 ContainerWeightPanelBasePosition;

			public float ContainerWeightPanelAppliedYOffset;

			public RectTransform? DraggedInventoryPanel;

			public Vector3 InventoryPanelDragStartMouse;

			public Vector2 InventoryPanelDragStartOffset;

			public bool UpdatingPlayerInventoryScrollbar;

			public bool PlayerInventoryRowsDragging;

			public bool ContainerPanelBasePositionSet;

			public bool ContainerWeightPanelBasePositionSet;

			public bool DraggingQuickSlotsPanelOffset;

			public bool DraggingEquipmentSlotsPanelOffset;

			public Vector2 EquipmentSlotsPanelRuntimeOffset = EquipmentSlotsPanelFixedOffset;

			public Vector2 QuickSlotsPanelRuntimeOffset = QuickSlotsPanelFixedOffset;

			public Vector3 PlayerInventoryRowsDragStartMouse;

			public int PlayerInventoryRowsDragStartRows;

			public int LastExpandableInventoryRows = 4;

			public int PlayerInventoryScrollOffset;

			public int PlayerInventoryMaxScroll;

			public float QuickSlotPanelIntroStartTime = -1f;

			public float QuickSlotPanelIntroDuration = 0.25f;

			public float QuickSlotPanelOutroStartTime = -1f;

			public float QuickSlotPanelOutroDuration = 0.25f;

			public float QuickSlotHudElementSpace = 70f;

			public Container? ContainerRestockHoldContainer;

			public float ContainerRestockHoldStartTime = -1f;

			public bool ContainerRestockHoldTriggered;

			public bool QuickSlotPanelIntroActive;

			public bool QuickSlotPanelOutroActive;

			public bool QuickSlotHudAnchorValid;

			public bool LastExpandableInventoryRowsLoaded;

			public Vector3 QuickSlotHudAnchoredPosition;
		}

		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 HashSet<string> SlotRecoveryWarnings = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

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

			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 LastFullIntegrityAuditSignature = int.MinValue;

			public bool SlotUnequipInProgress;

			public bool SuppressSlotAutoEquip;

			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> QuickPanelSlotCache = new List<SlotDefinition>();

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

			public readonly Dictionary<string, YamlPredefinedGroup> PredefinedGroupDefinitions = new Dictionary<string, YamlPredefinedGroup>(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> 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> CraftingRecipeHealthFoodInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

			public readonly HashSet<string> CookingStationEitrFoodInputTokens = 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 HashSet<string> FermenterHealthFoodInputTokens = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

			public readonly HashSet<string> FermenterEitrFoodInputTokens = 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 CustomPanelSlotCacheVersion = -1;

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

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

			public string RecipeOutputLookupSignature = "";
		}

		private static class InventoryDefinitionController
		{
			public static bool TryGetSlotAtGridPos(InventoryDefinitionRuntimeState state, Inventory inventory, Vector2i pos, int fixedRegularRows, out SlotDefinition? slot)
			{
				//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)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				slot = null;
				int width = inventory.GetWidth();
				if (pos.y < fixedRegularRows)
				{
					return false;
				}
				int num = (pos.y - fixedRegularRows) * width + pos.x;
				if (num < 0 || num >= state.SlotDefinitions.Count)
				{
					return false;
				}
				slot = state.SlotDefinitions[num];
				return true;
			}

			public static bool TryGetSlotById(InventoryDefinitionRuntimeState state, string id, out SlotDefinition? slot)
			{
				slot = null;
				for (int i = 0; i < state.SlotDefinitions.Count; i++)
				{
					SlotDefinition slotDefinition = state.SlotDefinitions[i];
					if (string.Equals(slotDefinition.Id, id, StringComparison.Ordinal))
					{
						slot = slotDefinition;
						return true;
					}
				}
				return false;
			}

			public static List<SlotDefinition> GetCustomPanelSlots(InventoryDefinitionRuntimeState state)
			{
				if (state.CustomPanelSlotCacheVersion == state.SlotDefinitionVersion)
				{
					return state.CustomPanelSlotCache;
				}
				state.CustomPanelSlotCache.Clear();
				for (int i = 0; i < state.SlotDefinitions.Count; i++)
				{
					SlotDefinition slotDefinition = state.SlotDefinitions[i];
					if (slotDefinition.Kind != SlotKind.Quick)
					{
						state.CustomPanelSlotCache.Add(slotDefinition);
					}
				}
				state.CustomPanelSlotCacheVersion = state.SlotDefinitionVersion;
				return state.CustomPanelSlotCache;
			}

			public static List<SlotDefinition> GetQuickPanelSlots(InventoryDefinitionRuntimeState state, int unlockedCount)
			{
				if (state.QuickPanelSlotCacheVersion == state.SlotDefinitionVersion && state.QuickPanelSlotCacheUnlockedCount == unlockedCount)
				{
					return state.QuickPanelSlotCache;
				}
				state.QuickPanelSlotCache.Clear();
				for (int i = 0; i < state.SlotDefinitions.Count; i++)
				{
					SlotDefinition slotDefinition = state.SlotDefinitions[i];
					if (slotDefinition.Kind == SlotKind.Quick && slotDefinition.QuickSlotIndex >= 0 && slotDefinition.QuickSlotIndex < unlockedCount)
					{
						state.QuickPanelSlotCache.Add(slotDefinition);
					}
				}
				state.QuickPanelSlotCacheVersion = state.SlotDefinitionVersion;
				state.QuickPanelSlotCacheUnlockedCount = unlockedCount;
				return state.QuickPanelSlotCache;
			}

			public static bool TryGetQuickSlotDefinition(InventoryDefinitionRuntimeState state, int quickSlotIndex, out SlotDefinition? slot)
			{
				if (state.QuickSlotDefinitionCacheVersion != state.SlotDefinitionVersion)
				{
					state.QuickSlotDefinitionCache.Clear();
					for (int i = 0; i < state.SlotDefinitions.Count; i++)
					{
						SlotDefinition slotDefinition = state.SlotDefinitions[i];
						if (slotDefinition.Kind == SlotKind.Quick && slotDefinition.QuickSlotIndex >= 0)
						{
							state.QuickSlotDefinitionCache[slotDefinition.QuickSlotIndex] = slotDefinition;
						}
					}
					state.QuickSlotDefinitionCacheVersion = state.SlotDefinitionVersion;
				}
				return state.QuickSlotDefinitionCache.TryGetValue(quickSlotIndex, out slot);
			}

			public static Vector2i GetSlotGridPos(InventoryDefinitionRuntimeState state, Inventory inventory, SlotDefinition slot, int fixedRegularRows)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				int num = state.SlotDefinitions.IndexOf(slot);
				int width = inventory.GetWidth();
				return new Vector2i(num % width, fixedRegularRows + num / width);
			}

			public static int GetSlotTailRows(InventoryDefinitionRuntimeState state, int width)
			{
				if (state.SlotDefinitions.Count == 0)
				{
					return 0;
				}
				return Mathf.CeilToInt((float)state.SlotDefinitions.Count / (float)Mathf.Max(1, width));
			}

			public static void InvalidateCaches(InventoryDefinitionRuntimeState state)
			{
				state.SlotDefinitionVersion++;
				state.CustomPanelSlotCacheVersion = -1;
				state.QuickPanelSlotCacheVersion = -1;
				state.QuickPanelSlotCacheUnlockedCount = -1;
				state.QuickSlotDefinitionCacheVersion = -1;
				state.CustomPanelSlotCache.Clear();
				state.QuickPanelSlotCache.Clear();
				state.QuickSlotDefinitionCache.Clear();
			}
		}

		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 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 ex)
				{
					Log.LogDebug((object)("Magic Supremacy belt sync failed: " + ex.Message));
				}
			}

			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 ex)
				{
					Log.LogDebug((object)("Magic Supremacy belt clear failed: " + ex.Message));
				}
			}

			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 InventoryPlacementScope
		{
			General,
			LocalPlayer,
			LoadPreservation
		}

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

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

		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 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 num2 = ((_entryAmountField.GetValue(item2) is int num) ? num : 0);
						if (num2 > 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 ?? "", num2, 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;
				}
			}
		}

		public enum Toggle
		{
			Off,
			On
		}

		public enum InventoryRowsDisplayMode
		{
			Fixed,
			Expandable
		}

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

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

			public float NextDebugTime;

			public string LastDebugSignature = "";
		}

		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 PinnedTooltipContext ActivePinnedContext => PinnedTooltips.ActiveContext;

			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 YamlApplySnapshot
		{
			public YamlRoot Config { get; }

			public List<SlotDefinition> SlotDefinitions { get; }

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

			public List<string> PredefinedGroupOrder { get; }

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

			public Dictionary<string, int> ResourceTierByToken { get; }

			public HashSet<string> CookingStationInputTokens { get; }

			public HashSet<string> CraftingRecipeFoodInputTokens { get; }

			public HashSet<string> CraftingRecipeHealthFoodInputTokens { get; }

			public HashSet<string> CraftingRecipeStaminaFoodInputTokens { get; }

			public HashSet<string> CraftingRecipeEitrFoodInputTokens { get; }

			public HashSet<string> CookingStationFoodInputTokens { get; }

			public HashSet<string> CookingStationHealthFoodInputTokens { get; }

			public HashSet<string> CookingStationStaminaFoodInputTokens { get; }

			public HashSet<string> CookingStationEitrFoodInputTokens { get; }

			public HashSet<string> FermenterInputTokens { get; }

			public HashSet<string> FermenterOutputTokens { get; }

			public HashSet<string> FermenterFoodInputTokens { get; }

			public HashSet<string> FermenterHealthFoodInputTokens { get; }

			public HashSet<string> FermenterStaminaFoodInputTokens { get; }

			public HashSet<string> FermenterEitrFoodInputTokens { get; }

			public bool StationInputTokensInitialized { get; }

			public int CachedStationInputObjectDbItemCount { get; }

			public int CachedStationInputPrefabCount { get; }

			public int CachedStationInputRecipeCount { get; }

			public YamlApplySnapshot(YamlRoot config, List<SlotDefinition> slotDefinitions, Dictionary<string, YamlPredefinedGroup> predefinedGroupDefinitions, List<string> predefinedGroupOrder, Dictionary<string, List<string>> predefinedGroupOrders, Dictionary<string, int> resourceTierByToken, HashSet<string> cookingStationInputTokens, HashSet<string> craftingRecipeFoodInputTokens, HashSet<string> craftingRecipeHealthFoodInputTokens, HashSet<string> craftingRecipeStaminaFoodInputTokens, HashSet<string> craftingRecipeEitrFoodInputTokens, HashSet<string> cookingStationFoodInputTokens, HashSet<string> cookingStationHealthFoodInputTokens, HashSet<string> cookingStationStaminaFoodInputTokens, HashSet<string> cookingStationEitrFoodInputTokens, HashSet<string> fermenterInputTokens, HashSet<string> fermenterOutputTokens, HashSet<string> fermenterFoodInputTokens, HashSet<string> fermenterHealthFoodInputTokens, HashSet<string> fermenterStaminaFoodInputTokens, HashSet<string> fermenterEitrFoodInputTokens, bool stationInputTokensInitialized, int cachedStationInputObjectDbItemCount, int cachedStationInputPrefabCount, int cachedStationInputRecipeCount)
			{
				Config = config;
				SlotDefinitions = slotDefinitions;
				PredefinedGroupDefinitions = predefinedGroupDefinitions;
				PredefinedGroupOrder = predefinedGroupOrder;
				PredefinedGroupOrders = predefinedGroupOrders;
				ResourceTierByToken = resourceTierByToken;
				CookingStationInputTokens = cookingStationInputTokens;
				CraftingRecipeFoodInputTokens = craftingRecipeFoodInputTokens;
				CraftingRecipeHealthFoodInputTokens = craftingRecipeHealthFoodInputTokens;
				CraftingRecipeStaminaFoodInputTokens = craftingRecipeStaminaFoodInputTokens;
				CraftingRecipeEitrFoodInputTokens = craftingRecipeEitrFoodInputTokens;
				CookingStationFoodInputTokens = cookingStationFoodInputTokens;
				CookingStationHealthFoodInputTokens = cookingStationHealthFoodInputTokens;
				CookingStationStaminaFoodInputTokens = cookingStationStaminaFoodInputTokens;
				CookingStationEitrFoodInputTokens = cookingStationEitrFoodInputTokens;
				FermenterInputTokens = fermenterInputTokens;
				FermenterOutputTokens = fermenterOutputTokens;
				FermenterFoodInputTokens = fermenterFoodInputTokens;
				FermenterHealthFoodInputTokens = fermenterHealthFoodInputTokens;
				FermenterStaminaFoodInputTokens = fermenterStaminaFoodInputTokens;
				FermenterEitrFoodInputTokens = fermenterEitrFoodInputTokens;
				StationInputTokensInitialized = stationInputTokensInitialized;
				CachedStationInputObjectDbItemCount = cachedStationInputObjectDbItemCount;
				CachedStationInputPrefabCount = cachedStationInputPrefabCount;
				CachedStationInputRecipeCount = cachedStationInputRecipeCount;
			}
		}

		[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 Func<ItemData, SortKey> <9>__GetInventoryItemSortKey;

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

			public static UnityAction<string> <11>__UpdateCraftingSearchQuery;

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

			public static Comparison<CraftingRecipeViewEntry> <13>__CompareCraftingRecipeViewEntries;

			public static UnityAction<float> <14>__OnCraftingRecipeScrollbarChanged;

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

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

			public static CompatApiFactory<JewelcraftingSlotApi> <17>__TryCreate;

			public static CompatApiFactory<JewelcraftingVisualApi> <18>__TryCreate;

			public static CompatApiFactory<JewelcraftingGemCuttingApi> <19>__TryCreate;

			public static CompatApiFactory<JewelcraftingCraftingSocketUiApi> <20>__TryCreate;

			public static CompatApiFactory<JewelcraftingTooltipApi> <21>__TryCreate;

			public static CompatApiFactory<JewelcraftingGemApi> <22>__TryCreate;

			public static CompatApiFactory<ItemRequiresSkillLevelApi> <23>__TryCreate;

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

			public static CompatApiFactory<MagicSupremacyApi> <25>__TryCreate;

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

			public static UnityAction<float> <27>__OnPlayerInventoryScrollbarChanged;

			public static UnityAction <28>__TryClickInventoryTrashPanel;

			public static Action<UIInputHandler> <29>__HandleInventoryGridTooltipPointerEnter;

			public static Action<UIInputHandler> <30>__HandleInventoryGridTooltipPointerExit;

			public static CompatApiFactory<RecycleNReclaimApi> <31>__TryCreate;

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

			public static Action<ConfigEntryBase> <33>__DrawRestockTargetStackLimitsConfig;

			public static Action <34>__HandleLocalizationComplete;

			public static Action<ConfigEntryBase> <35>__DrawControllerHotkeyConfig;

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

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

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

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

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

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

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

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

			public static Func<FieldInfo, bool> <>9__164_0;

			public static Func<PropertyInfo, bool> <>9__164_1;

			public static Comparison<ItemData> <>9__174_1;

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

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

			public static Comparison<ItemData> <>9__177_1;

			public static Comparison<ItemData> <>9__188_1;

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

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

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

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

			public static Func<ItemData, global::<>f__AnonymousType0<string, int>> <>9__213_1;

			public static Func<IGrouping<global::<>f__AnonymousType0<string, int>, ItemData>, List<ItemData>> <>9__213_2;

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

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

			public static Comparison<ItemData> <>9__216_1;

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

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

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

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

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

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

			public static UnityAction<string> <>9__300_0;

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

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

			public static EventHandler <>9__346_0;

			public static EventHandler <>9__346_1;

			public static EventHandler <>9__346_2;

			public static EventHandler <>9__346_3;

			public static EventHandler <>9__346_4;

			public static EventHandler <>9__346_5;

			public static Func<string> <>9__409_0;

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

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

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

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

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

			public static Action<UIInputHandler> <>9__443_0;

			public static Action<UIInputHandler> <>9__443_1;

			public static Action<UIInputHandler> <>9__443_2;

			public static Action<UIInputHandler> <>9__443_3;

			public static Action<UIInputHandler> <>9__458_0;

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

			public static Action<UIInputHandler> <>9__569_0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static UnityAction <>9__1489_0;

			public static UnityAction <>9__1489_1;

			public static UnityAction <>9__1491_0;

			public static UnityAction <>9__1498_0;

			public static Func<KeyValuePair<string, string>, string> <>9__1529_0;

			public static Func<KeyValuePair<string, string>, string> <>9__1529_1;

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

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

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

			public static Func<Transform, bool> <>9__1560_0;

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

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

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

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

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

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

			public static Action<UIInputHandler> <>9__1825_0;

			public static Action<UIInputHandler> <>9__1825_1;

			public static Action<UIInputHandler> <>9__1868_0;

			public static Action<UIInputHandler> <>9__1868_1;

			public static Action<UIInputHandler> <>9__1939_0;

			public static Action<UIInputHandler> <>9__1939_1;

			public static Action<UIInputHandler> <>9__1953_0;

			public static Action<UIInputHandler> <>9__1953_1;

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

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

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

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

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

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

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

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

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

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

			public static EventHandler <>9__2258_0;

			public static EventHandler <>9__2258_1;

			public static EventHandler <>9__2258_2;

			public static EventHandler <>9__2258_3;

			public static EventHandler <>9__2258_4;

			public static EventHandler <>9__2258_5;

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

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

			public static Action <>9__2427_0;

			public static FileSystemEventHandler <>9__2429_0;

			public static RenamedEventHandler <>9__2429_1;

			public static ErrorEventHandler <>9__2429_2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal int <GetActionContainers>b__144_0((Container Container, float DistanceSq) left, (Container Container, float DistanceSq) right)
			{
				return left.DistanceSq.CompareTo(right.DistanceSq);
			}

			internal bool <GetSfxVolumeMemberCache>b__164_0(FieldInfo field)
			{
				if (field.FieldType == typeof(float) && IsSfxVolumeMemberName(field.Name))
				{
					return !IsUnsupportedSfxVolumeMemberName(field.Name);
				}
				return false;
			}

			internal bool <GetSfxVolumeMemberCache>b__164_1(PropertyInfo property)
			{
				if (property.PropertyType == typeof(float) && property.CanRead && property.CanWrite && property.GetIndexParameters().Length == 0 && IsSfxVolumeMemberName(property.Name))
				{
					return !IsUnsupportedSfxVolumeMemberName(property.Name);
				}
				return false;
			}

			internal int <QuickStackIntoContainers>b__174_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__176_0(ItemData item)
			{
				return item?.m_shared != null;
			}

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

			internal int <StoreAllToCurrentContainer>b__177_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__188_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__205_0(ItemData item)
			{
				return item?.m_shared != null;
			}

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

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

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

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

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

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

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

			internal int <SafeTakeAllItems>b__216_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__218_1(ItemData target)
			{
				return target.m_gridPos.y;
			}

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

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

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

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

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

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

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

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

			internal void <BindCraftingClientConfigs>b__346_0(object _, EventArgs _)
			{
				InvalidateCraftingRecipeGridLayout();
				InvalidateCraftingRecipeGridZoomHint();
			}

			internal void <BindCraftingClientConfigs>b__346_1(object _, EventArgs _)
			{
				InvalidateCraftingRecipeGridZoomHint();
			}

			internal void <BindCraftingClientConfigs>b__346_2(object _, EventArgs _)
			{
				MarkCraftingGroupRailDirty();
			}

			internal void <BindCraftingClientConfigs>b__346_3(object _, EventArgs _)
			{
				InvalidateCraftingRecipeGridZoomHint();
			}

			internal void <BindCraftingClientConfigs>b__346_4(object _, EventArgs _)
			{
				_craftingSortModeButtonsSignature = "";
				InvalidateCraftingRecipeView();
			}

			internal void <BindCraftingClientConfigs>b__346_5(object _, EventArgs _)
			{
				InvalidateCraftingRecipeGridLayout();
			}

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

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

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

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

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

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

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

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

			internal void <ConfigureCraftingRecipeCell>b__443_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__443_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__458_0(UIInputHandler handler)
			{
				ShowCraftingRecipeStyleDialog(((Component)handler).GetComponent<CraftingRecipeStyleButtonMarker>());
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal bool <TryFindFreeRegularLoadPreservationCell>b__1429_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 void <UpdateContainerActionPanel>b__1489_0()
			{
				StoreAllToCurrentContainer(Player.m_localPlayer);
			}

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

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

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

			internal string <GetEquipmentSlotTooltipSignature>b__1529_0(KeyValuePair<string, string> pair)
			{
				return pair.Key;
			}

			internal string <GetEquipmentSlotTooltipSignature>b__1529_1(KeyValuePair<string, string> pair)
			{
				return pair.Key + "=" + pair.Value;
			}

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

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

			internal InventorySlotsFavoriteSlot <SaveFavorites>b__1550_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 <FindVanillaKeyBackgroundTemplate>b__1560_0(Transform child)
			{
				if (((Object)child).name.StartsWith("key_bkg", StringComparison.OrdinalIgnoreCase))
				{
					return (Object)(object)((Component)child).GetComponent<Image>() != (Object)null;
				}
				return false;
			}

			internal bool <TryFindLoadedFontAsset>b__1577_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__1700_0(UITooltip tooltip, InventoryHoverTooltipItemSource source)
			{
				return !IsInventoryHoverTooltipSourceValid(tooltip, source);
			}

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

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

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

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

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

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

			internal void <EnsurePlayerInventoryResizeHandle>b__1868_0(UIInputHandler _)
			{
				StartPlayerInventoryRowsDrag();
			}

			internal void <EnsurePlayerInventoryResizeHandle>b__1868_1(UIInputHandler _)
			{
				StopPlayerInventoryRowsDrag();
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal void <StartYamlWatcher>b__2429_0(object _, FileSystemEventArgs _)
			{
				QueueYamlReload();
			}

			internal void <StartYamlWatcher>b__2429_1(object _, RenamedEventArgs _)
			{
				QueueYamlReload();
			}

			internal void <StartYamlWatcher>b__2429_2(object _, ErrorEventArgs _)
			{
				QueueYamlReload();
			}

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

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

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

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

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

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

			internal bool <RebuildSlotDefinitions>b__2449_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__2449_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__2449_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__2449_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__2449_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)
				{
					return !IsJewelcraftingDedicatedJewelryItem(item);
				}
				return false;
			}

			internal bool <RebuildSlotDefinitions>b__2449_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__2454_0(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

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

			internal bool <HasConfiguredValues>b__2466_0(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}
		}

		[CompilerGenerated]
		private sealed class <FindCraftingPanelFieldBackgroundImages>d__923 : IEnumerable<Image>, IEnumerable, IEnumerator<Image>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Image <>2__current;

			private int <>l__initialThreadId;

			private InventoryGui gui;

			public InventoryGui <>3__gui;

			private Transform[] <>7__wrap1;

			private int <>7__wrap2;

			private Transform <anchor>5__4;

			private Transform <cursor>5__5;

			private Transform <parent>5__6;

			private Image[] <>7__wrap6;

			private int <>7__wrap7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<anchor>5__4 = null;
				<cursor>5__5 = null;
				<parent>5__6 = null;
				<>7__wrap6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>7__wrap1 = (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
					};
					<>7__wrap2 = 0;
					goto IL_027f;
				case 1:
					<>1__state = -1;
					goto IL_0134;
				case 2:
					{
						<>1__state = -1;
						goto IL_01fd;
					}
					IL_027f:
					if (<>7__wrap2 < <>7__wrap1.Length)
					{
						<anchor>5__4 = <>7__wrap1[<>7__wrap2];
						<cursor>5__5 = <anchor>5__4;
						goto IL_023a;
					}
					<>7__wrap1 = null;
					return false;
					IL_01fd:
					<>7__wrap7++;
					goto IL_020b;
					IL_0134:
					<>7__wrap7++;
					goto IL_0142;
					IL_023a:
					if ((Object)(object)<cursor>5__5 != (Object)null && (Object)(object)<cursor>5__5 != (Object)(object)gui.m_crafting)
					{
						<>7__wrap6 = ((Component)<cursor>5__5).GetComponents<Image>();
						<>7__wrap7 = 0;
						goto IL_0142;
					}
					<cursor>5__5 = null;
					<anchor>5__4 = null;
					<>7__wrap2++;
					goto IL_027f;
					IL_0222:
					<cursor>5__5 = <cursor>5__5.parent;
					<parent>5__6 = null;
					goto IL_023a;
					IL_0142:
					if (<>7__wrap7 < <>7__wrap6.Length)
					{
						Image image = <>7__wrap6[<>7__wrap7];
						if (ShouldHideCraftingPanelBackgroundImage(gui, image))
						{
							<>2__current = image;
							<>1__state = 1;
							return true;
						}
						goto IL_0134;
					}
					<>7__wrap6 = null;
					<parent>5__6 = <cursor>5__5.parent;
					if ((Object)(object)<parent>5__6 != (Object)null && (Object)(object)<parent>5__6 != (Object)(object)gui.m_crafting)
					{
						<>7__wrap6 = ((Component)<parent>5__6).GetComponentsInChildren<Image>(true);
						<>7__wrap7 = 0;
						goto IL_020b;
					}
					goto IL_0222;
					IL_020b:
					if (<>7__wrap7 < <>7__wrap6.Length)
					{
						Image val = <>7__wrap6[<>7__wrap7];
						if (ShouldHideCraftingPanelBackgroundImage(gui, val) && IsNearCraftingFieldBackground(<anchor>5__4, ((Component)val).transform, <parent>5__6))
						{
							<>2__current = val;
							<>1__state = 2;
							return true;
						}
						goto IL_01fd;
					}
					<>7__wrap6 = null;
					goto IL_0222;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<Image> IEnumerable<Image>.GetEnumerator()
			{
				<FindCraftingPanelFieldBackgroundImages>d__923 <FindCraftingPanelFieldBackgroundImages>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindCraftingPanelFieldBackgroundImages>d__ = this;
				}
				else
				{
					<FindCraftingPanelFieldBackgroundImages>d__ = new <FindCraftingPanelFieldBackgroundImages>d__923(0);
				}
				<FindCraftingPanelFieldBackgroundImages>d__.gui = <>3__gui;
				return <FindCraftingPanelFieldBackgroundImages>d__;
			}

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

		[CompilerGenerated]
		private sealed class <FindCraftingPanelNamedBackgroundImages>d__922 : IEnumerable<Image>, IEnumerable, IEnumerator<Image>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Image <>2__current;

			private int <>l__initialThreadId;

			private InventoryGui gui;

			public InventoryGui <>3__gui;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

			private Transform <panel>5__4;

			private Image <panelImage>5__5;

			private Image[] <>7__wrap5;

			private int <>7__wrap6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<panel>5__4 = null;
				<panelImage>5__5 = null;
				<>7__wrap5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>7__wrap1 = new string[3] { "RecipeList", "Decription", "Description" };
					<>7__wrap2 = 0;
					goto IL_0180;
				case 1:
					<>1__state = -1;
					goto IL_00d6;
				case 2:
					{
						<>1__state = -1;
						goto IL_013f;
					}
					IL_0180:
					if (<>7__wrap2 < <>7__wrap1.Length)
					{
						string text = <>7__wrap1[<>7__wrap2];
						<panel>5__4 = ((Transform)gui.m_crafting).Find(text);
						if (!((Object)(object)<panel>5__4 == (Object)null))
						{
							<panelImage>5__5 = ((Component)<panel>5__4).GetComponent<Image>();
							if ((Object)(object)<panelImage>5__5 != (Object)null && ShouldHideCraftingPanelBackgroundImage(gui, <panelImage>5__5))
							{
								<>2__current = <panelImage>5__5;
								<>1__state = 1;
								return true;
							}
							goto IL_00d6;
						}
						goto IL_0172;
					}
					<>7__wrap1 = null;
					return false;
					IL_00d6:
					<>7__wrap5 = ((Component)<panel>5__4).GetComponentsInChildren<Image>(true);
					<>7__wrap6 = 0;
					goto IL_014d;
					IL_014d:
					if (<>7__wrap6 < <>7__wrap5.Length)
					{
						Image val = <>7__wrap5[<>7__wrap6];
						if ((Object)(object)val != (Object)(object)<panelImage>5__5 && ShouldHideCraftingPanelBackgroundImage(gui, val) && IsCraftingBackgroundLikeImage(((Component)val).transform))
						{
							<>2__current = val;
							<>1__state = 2;
							return true;
						}
						goto IL_013f;
					}
					<>7__wrap5 = null;
					<panel>5__4 = null;
					<panelImage>5__5 = null;
					goto IL_0172;
					IL_0172:
					<>7__wrap2++;
					goto IL_0180;
					IL_013f:
					<>7__wrap6++;
					goto IL_014d;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<Image> IEnumerable<Image>.GetEnumerator()
			{
				<FindCraftingPanelNamedBackgroundImages>d__922 <FindCraftingPanelNamedBackgroundImages>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindCraftingPanelNamedBackgroundImages>d__ = this;
				}
				else
				{
					<FindCraftingPanelNamedBackgroundImages>d__ = new <FindCraftingPanelNamedBackgroundImages>d__922(0);
				}
				<FindCraftingPanelNamedBackgroundImages>d__.gui = <>3__gui;
				return <FindCraftingPanelNamedBackgroundImages>d__;
			}

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

		[CompilerGenerated]
		private sealed class <FindCraftingPanelResizeProtectedChildren>d__511 : IEnumerable<RectTransform>, IEnumerable, IEnumerator<RectTransform>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private RectTransform <>2__current;

			private int <>l__initialThreadId;

			private InventoryGui gui;

			public InventoryGui <>3__gui;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0079;
				}
				<>1__state = -1;
				if ((Object)(object)gui.m_crafting == (Object)null)
				{
					return false;
				}
				<i>5__2 = 0;
				goto IL_0089;
				IL_0079:
				<i>5__2++;
				goto IL_0089;
				IL_0089:
				if (<i>5__2 >= ((Transform)gui.m_crafting).childCount)
				{
					return false;
				}
				Transform child = ((Transform)gui.m_crafting).GetChild(<i>5__2);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null && ShouldProtectCraftingPanelResizeChild(gui, val))
				{
					<>2__current = val;
					<>1__state = 1;
					return true;
				}
				goto IL_0079;
			}

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

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

			[DebuggerHidden]
			IEnumerator<RectTransform> IEnumerable<RectTransform>.GetEnumerator()
			{
				<FindCraftingPanelResizeProtectedChildren>d__511 <FindCraftingPanelResizeProtectedChildren>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindCraftingPanelResizeProtectedChildren>d__ = this;
				}
				else
				{
					<FindCraftingPanelResizeProtectedChildren>d__ = new <FindCraftingPanelResizeProtectedChildren>d__511(0);
				}
				<FindCraftingPanelResizeProtectedChildren>d__.gui = <>3__gui;
				return <FindCraftingPanelResizeProtectedChildren>d__;
			}

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

		[CompilerGenerated]
		private sealed class <FindCraftingVanillaPanelBackgroundImages>d__921 : IEnumerable<Image>, IEnumerable, IEnumerator<Image>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Image <>2__current;

			private int <>l__initialThreadId;

			private InventoryGui gui;

			public InventoryGui <>3__gui;

			private HashSet<Image> <yielded>5__2;

			private IEnumerator<Image> <>7__wrap2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<yielded>5__2 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if ((Object)(object)gui.m_crafting == (Object)null)
						{
							return false;
						}
						<yielded>5__2 = new HashSet<Image>();
						<>7__wrap2 = FindCraftingPanelNamedBackgroundImages(gui).GetEnumerator();
						<>1__state = -3;
						goto IL_00a3;
					case 1:
						<>1__state = -3;
						goto IL_00a3;
					case 2:
						{
							<>1__state = -4;
							break;
						}
						IL_00a3:
						while (<>7__wrap2.MoveNext())
						{
							Image current = <>7__wrap2.Current;
							if (<yielded>5__2.Add(current))
							{
								<>2__current = current;
								<>1__state = 1;
								return true;
							}
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						<>7__wrap2 = FindCraftingPanelFieldBackgroundImages(gui).GetEnumerator();
						<>1__state = -4;
						break;
					}
					while (<>7__wrap2.MoveNext())
					{
						Image current2 = <>7__wrap2.Current;
						if (<yielded>5__2.Add(current2))
						{
							<>2__current = current2;
							<>1__state = 2;
							return true;
						}
					}
					<>m__Finally2();
					<>7__wrap2 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

			[DebuggerHidden]
			IEnumerator<Image> IEnumerable<Image>.GetEnumerator()
			{
				<FindCraftingVanillaPanelBackgroundImages>d__921 <FindCraftingVanillaPanelBackgroundImages>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindCraftingVanillaPanelBackgroundImages>d__ = this;
				}
				else
				{
					<FindCraftingVanillaPanelBackgroundImages>d__ = new <FindCraftingVanillaPanelBackgroundImages>d__921(0);
				}
				<FindCraftingVanillaPanelBackgroundImages>d__.gui = <>3__gui;
				return <FindCraftingVanillaPanelBackgroundImages>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetItemIdentityTokens>d__1036 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private ItemData item;

			public ItemData <>3__item;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0090;
				}
				<>1__state = -1;
				string itemPrefabName = GetItemPrefabName(item);
				string text = item.m_shared.m_name ?? "";
				<>7__wrap1 = new string[3]
				{
					itemPrefabName,
					NormalizeResourceToken(itemPrefabName),
					text
				};
				<>7__wrap2 = 0;
				goto IL_009e;
				IL_009e:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					string value = <>7__wrap1[<>7__wrap2];
					if (!string.IsNullOrWhiteSpace(value))
					{
						<>2__current = value;
						<>1__state = 1;
						return true;
					}
					goto IL_0090;
				}
				<>7__wrap1 = null;
				return false;
				IL_0090:
				<>7__wrap2++;
				goto IL_009e;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<GetItemIdentityTokens>d__1036 <GetItemIdentityTokens>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetItemIdentityTokens>d__ = this;
				}
				else
				{
					<GetItemIdentityTokens>d__ = new <GetItemIdentityTokens>d__1036(0);
				}
				<GetItemIdentityTokens>d__.item = <>3__item;
				return <GetItemIdentityTokens>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetItemRecipeLookupTokens>d__1094 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private ItemData item;

			public ItemData <>3__item;

			private string <sharedName>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string itemPrefabName = GetItemPrefabName(item);
					<sharedName>5__2 = item.m_shared.m_name ?? "";
					if (!string.IsNullOrWhiteSpace(itemPrefabName))
					{
						<>2__current = GetRecipeOutputLookupKey("prefab", itemPrefabName);
						<>1__state = 1;
						return true;
					}
					goto IL_0076;
				}
				case 1:
					<>1__state = -1;
					goto IL_0076;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0076:
					if (!string.IsNullOrWhiteSpace(<sharedName>5__2))
					{
						<>2__current = GetRecipeOutputLookupKey("name", <sharedName>5__2);
						<>1__state = 2;
						return true;
					}
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<GetItemRecipeLookupTokens>d__1094 <GetItemRecipeLookupTokens>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetItemRecipeLookupTokens>d__ = this;
				}
				else
				{
					<GetItemRecipeLookupTokens>d__ = new <GetItemRecipeLookupTokens>d__1094(0);
				}
				<GetItemRecipeLookupTokens>d__.item = <>3__item;
				return <GetItemRecipeLookupTokens>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetKnownVanillaCraftingRoots>d__909 : IEnumerable<Transform>, IEnumerable, IEnumerator<Transform>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Transform? <>2__current;

			private int <>l__initialThreadId;

			private InventoryGui gui;

			public InventoryGui <>3__gui;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_recipeListScroll != (Object)null) ? ((Component)gui.m_recipeListScroll).transform : null);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_recipeIcon != (Object)null) ? ((Component)gui.m_recipeIcon).transform : null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_recipeName != (Object)null) ? gui.m_recipeName.transform : null);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_recipeDecription != (Object)null) ? gui.m_recipeDecription.transform : null);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_itemCraftType != (Object)null) ? gui.m_itemCraftType.transform : null);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_variantButton != (Object)null) ? ((Component)gui.m_variantButton).transform : null);
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_minStationLevelIcon != (Object)null) ? ((Component)gui.m_minStationLevelIcon).transform : null);
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_minStationLevelText != (Object)null) ? gui.m_minStationLevelText.transform : null);
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_craftButton != (Object)null) ? ((Component)gui.m_craftButton).transform : null);
					<>1__state = 9;
					return true;
				case 9:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_repairButton != (Object)null) ? ((Component)gui.m_repairButton).transform : null);
					<>1__state = 10;
					return true;
				case 10:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_repairButtonGlow != (Object)null) ? ((Component)gui.m_repairButtonGlow).transform : null);
					<>1__state = 11;
					return true;
				case 11:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_tabCraft != (Object)null) ? ((Component)gui.m_tabCraft).transform : null);
					<>1__state = 12;
					return true;
				case 12:
					<>1__state = -1;
					<>2__current = (((Object)(object)gui.m_tabUpgrade != (Object)null) ? ((Component)gui.m_tabUpgrade).transform : null);
					<>1__state = 13;
					return true;
				case 13:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<Transform> IEnumerable<Transform>.GetEnumerator()
			{
				<GetKnownVanillaCraftingRoots>d__909 <GetKnownVanillaCraftingRoots>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetKnownVanillaCraftingRoots>d__ = this;
				}
				else
				{
					<GetKnownVanillaCraftingRoots>d__ = new <GetKnownVanillaCraftingRoots>d__909(0);
				}
				<GetKnownVanillaCraftingRoots>d__.gui = <>3__gui;
				return <GetKnownVanillaCraftingRoots>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetResourceTokens>d__672 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private ItemDrop itemDrop;

			public ItemDrop <>3__itemDrop;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00d6;
				}
				<>1__state = -1;
				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);
				<>7__wrap1 = new string[5]
				{
					text,
					itemPrefabName,
					text2,
					StripLocalizationToken(text2),
					text3
				};
				<>7__wrap2 = 0;
				goto IL_00e4;
				IL_00e4:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					string value = NormalizeResourceToken(<>7__wrap1[<>7__wrap2]);
					if (!string.IsNullOrWhiteSpace(value))
					{
						<>2__current = value;
						<>1__state = 1;
						return true;
					}
					goto IL_00d6;
				}
				<>7__wrap1 = null;
				return false;
				IL_00d6:
				<>7__wrap2++;
				goto IL_00e4;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<GetResourceTokens>d__672 <GetResourceTokens>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetResourceTokens>d__ = this;
				}
				else
				{
					<GetResourceTokens>d__ = new <GetResourceTokens>d__672(0);
				}
				<GetResourceTokens>d__.itemDrop = <>3__itemDrop;
				return <GetResourceTokens>d__;
			}

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

		[CompilerGenerated]
		private sealed class <GetRestockTargetLookupTokens>d__201 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string? <>2__current;

			private int <>l__initialThreadId;

			private ItemData item;

			public ItemData <>3__item;

			private string <sharedName>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (item == null)
					{
						return false;
					}
					<>2__current = GetItemPrefabName(item);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!IsUnityNull((Object?)(object)item.m_dropPrefab))
					{
						<>2__current = ((Object)item.m_dropPrefab).name;
						<>1__state = 2;
						return true;
					}
					goto IL_0091;
				case 2:
					<>1__state = -1;
					goto IL_0091;
				case 3:
					<>1__state = -1;
					<>2__current = StripLocalizationToken(<sharedName>5__2);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					if (Localization.instance != null && !string.IsNullOrWhiteSpace(<sharedName>5__2))
					{
						<>2__current = Localization.instance.Localize(<sharedName>5__2);
						<>1__state = 5;
						return true;
					}
					break;
				case 5:
					{
						<>1__state = -1;
						break;
					}
					IL_0091:
					<sharedName>5__2 = item.m_shared?.m_name ?? "";
					<>2__current = <sharedName>5__2;
					<>1__state = 3;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<GetRestockTargetLookupTokens>d__201 <GetRestockTargetLookupTokens>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetRestockTargetLookupTokens>d__ = this;
				}
				else
				{
					<GetRestockTargetLookupTokens>d__ = new <GetRestockTargetLookupTokens>d__201(0);
				}
				<GetRestockTargetLookupTokens>d__.item = <>3__item;
				return <GetRestockTargetLookupTokens>d__;
			}

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

		[CompilerGenerated]
		private sealed class <SplitConfiguredList>d__1929 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string value;

			public string <>3__value;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0084;
				}
				<>1__state = -1;
				if (string.IsNullOrWhiteSpace(value))
				{
					return false;
				}
				<>7__wrap1 = value.Split(new char[3] { ',', ';', '|' }, StringSplitOptions.RemoveEmptyEntries);
				<>7__wrap2 = 0;
				goto IL_0092;
				IL_0084:
				<>7__wrap2++;
				goto IL_0092;
				IL_0092:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					string text = <>7__wrap1[<>7__wrap2].Trim();
					if (!string.IsNullOrWhiteSpace(text))
					{
						<>2__current = text;
						<>1__state = 1;
						return true;
					}
					goto IL_0084;
				}
				<>7__wrap1 = null;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<SplitConfiguredList>d__1929 <SplitConfiguredList>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SplitConfiguredList>d__ = this;
				}
				else
				{
					<SplitConfiguredList>d__ = new <SplitConfiguredList>d__1929(0);
				}
				<SplitConfiguredList>d__.value = <>3__value;
				return <SplitConfiguredList>d__;
			}

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

		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 static readonly CompatRuntimeState CompatRuntime = new CompatRuntimeState();

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

		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> _quickSlotCount = null;

		private static ConfigEntry<Toggle> _quickSlotProgressionEnabled = null;

		private static ConfigEntry<string>[] _quickSlotRowUnlockItems = 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<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<float> _craftingHoverTooltipBackgroundAlpha = null;

		private static ConfigEntry<float> _inventoryContainerHoverTooltipBackgroundAlpha = null;

		private static ConfigEntry<int> _containerActionSuccessFxMode = null;

		private static ConfigEntry<float> _containerActionSuccessFxVolume = null;

		private static ConfigEntry<CraftingRecipeSortMode> _inventorySortMode = 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<KeyboardShortcut> _favoriteModifierKey = null;

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

		private static YamlRoot _yamlConfig = new YamlRoot();

		private const string ContainerActionSuccessFxPrefabName = "fx_HildirChest_Unlock";

		private const int ContainerActionSuccessFxMaxMode = 12;

		private static readonly Dictionary<Type, SfxVolumeMemberCache> SfxVolumeMembersByType = new Dictionary<Type, SfxVolumeMemberCache>();

		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 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 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 CraftingSelectedRecipeBorderName = "InventorySlots_CraftingSelectedRecipeBorder";

		private const string CraftingPinnedTooltipMarkerName = "InventorySlots_CraftingPinnedTooltipMarker";

		private const string CraftingSocketWarningName = "InventorySlots_CraftingSocketWarning";

		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 = 16f;

		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 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 RectTransform? _craftingGroupRail;

		private static TMP_InputField? _craftingCountInput;

		private static RectTransform? _craftingCountInputRect;

		private static RectTransform? _craftingCountInputViewport;

		private static RectTransform? _craftingUpgradeProgressionRect;

		private static TMP_Text? _craftingUpgradeProgressionText;

		private static RectTransform? _craftingSortModeButtonGroup;

		private static RectTransform? _craftingControlsBackground;

		private static RectTransform? _craftingSocketWarningRect;

		private static TMP_Text? _craftingSocketWarningText;

		private static Transform? _craftingRequiredStationLevelOriginalRoot;

		private static RectTransform? _craftingRequiredStationLevelHitbox;

		private static RectTransformSnapshot? _craftingPanelRootSnapshot;

		private static Vector2 _craftingPanelOriginalSizeDelta;

		private static bool _craftingRedesignApplied;

		private static bool _craftingRecipeViewDirty = true;

		private static bool _craftingGroupRailDirty = true;

		private static bool _craftingBottomControlsDirty = true;

		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 _craftingRecipeViewSignature = "";

		private static string _craftingGroupRailSignature = "";

		private static string _craftingGroupAvailabilitySignature = "";

		private static string _craftingGroupAvailabilityContextSignature = "";

		private static string _craftingSelectableGroupFilterIdsSignature = "";

		private static string _craftingPanelExtensionSignature = "";

		private static string _craftingBottomControlsSignature = "";

		private static string _craftingSocketWarningSignature = "";

		private static string _craftingSortModeButtonsSignature = "";

		private static string _craftingFrameFastPathSignature = "";

		private static string _craftingRecipeListChangeSignature = "";

		private static string _craftingSelectedRecipeChangeSignature = "";

		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 CraftingHoverRecipeOverlayBottomPadding = 6f;

		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 bool? _epicLootLoaded;

		private static int _epicLootInventoryGridTooltipUiPatchScope;

		private static GameObject? _epicLootSuppressedOnHoverTooltip;

		private static bool _epicLootComparisonTooltipReflectionResolved;

		private static FieldInfo? _epicLootComparisonTooltipField;

		private static FieldInfo? _epicLootComparisonAddedField;

		private const int MaxItemClassifierCacheItems = 2048;

		private static readonly ItemClassifierRuntimeState ItemClassifierRuntime = new ItemClassifierRuntimeState();

		private const string JewelcraftingGemcutterStationPrefabName = "op_transmution_table";

		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 CustomSyncedValue<string> _syncedYaml = 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 DateTime _yamlReloadAfterUtc;

		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 string _myLittleUICraftingSuppressionSignature = "";

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

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

		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 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 static string QuickSlotProgressionCachePlayerId = "";

		private static int QuickSlotProgressionCachedRows;

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

		private const float PinnedTooltipScrollbarWidth = 3f;

		private const float PinnedTooltipScrollbarOutsideOffset = 2f;

		private const float PinnedTooltipDebugInterval = 0.75f;

		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 static readonly List<RestockTargetLimitEditorRow> RestockTargetLimitEditorRows = new List<RestockTargetLimitEditorRow>();

		private static string _restockTargetLimitEditorLastValue = "";

		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 const int BaseRows = 4;

		private const int InventoryWidth = 8;

		private const int MaxSupportedExtraRows = 5;

		private const int MaxSupportedQuickSlots = 9;

		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 YamlFileName = "InventorySlots.yml";

		private const string ClientStateFileName = "InventorySlots.Client.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 string RpcRequestSort = "InventorySlots_RequestSort";

		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 static readonly bool LeaveEmptyFavoriteSlots = false;

		private static readonly bool TombstoneSafeguardsEnabled = true;

		private const float ContainerActionPairButtonWidthMultiplier = 1f;

		private const float SortButtonOutsideGap = 1f;

		private const float QuickSlotPanelIntroFallbackDuration = 0.25f;

		private const float ContainerRestockHoldDuration = 0.5f;

		private const int PinnedTooltipSlotCount = 3;

		private const float PinnedTooltipFixedPanelGap = 15f;

		private static readonly bool SlotBackupEnabled = true;

		private static readonly bool PeriodicInventorySafetyAuditEnabled = true;

		private const float InventoryMaintenanceInterval = 1f;

		private const float LightSafetyAuditInterval = 5f;

		private const float HeavySafetyAuditInterval = 30f;

		private const int MaxInventoryStateAuditPasses = 3;

		private const float PendingSlotActionTimeout = 30f;

		private const float InventoryPinnedJewelcraftingReservedHeight = 190f;

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

		private const string ClientConfigSection = "3 - Client";

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

		private const string RestockConfigSection = "5 - Restock";

		private const string ControllerInputConfigSection = "6 - 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;

		internal const string ModName = "InventorySlots";

		internal const string ModVersion = "1.0.4";

		internal const string Author = "sighsorry";

		internal const string ModGUID = "sighsorry.InventorySlots";

		internal static string ConnectionError = "";

		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 bool HasServerCharactersActive
		{
			get
			{
				if (!ZNet.IsSinglePlayer)
				{
					return HasPlugin("org.bepinex.plugins.servercharacters");
				}
				return false;
			}
		}

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

		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 Scrollbar? _craftingRecipeScrollbarComponent
		{
			get
			{
				return CraftingScrollbar.RecipeScrollbarComponent;
			}
			set
			{
				CraftingScrollbar.RecipeScrollbarComponent = value;
			}
		}

		private static bool _continuingCraftingQueue
		{
			get
			{
				return CraftingQueue.ContinuingQueue;
			}
			set
			{
				CraftingQueue.ContinuingQueue = value;
			}
		}

		private static bool _updatingCraftingRecipeScrollbar
		{
			get
			{
				return CraftingScrollbar.UpdatingRecipeScrollbar;
			}
			set
			{
				CraftingScrollbar.UpdatingRecipeScrollbar = value;
			}
		}

		private static bool _craftingRecipeGridDirty
		{
			get
			{
				return CraftingGrid.RecipeGridDirty;
			}
			set
			{
				CraftingGrid.RecipeGridDirty = value;
			}
		}

		private static bool _craftingRecipeScrollbarDirty
		{
			get
			{
				return CraftingScrollbar.RecipeScrollbarDirty;
			}
			set
			{
				CraftingScrollbar.RecipeScrollbarDirty = value;
			}
		}

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

		private static int _craftingQueueTotal
		{
			get
			{
				return CraftingQueue.QueueTotal;
			}
			set
			{
				CraftingQueue.QueueTotal = value;
			}
		}

		private static int _craftingQueueRemaining
		{
			get
			{
				return CraftingQueue.QueueRemaining;
			}
			set
			{
				CraftingQueue.QueueRemaining = value;
			}
		}

		private static int _craftingQueueVariant
		{
			get
			{
				return CraftingQueue.QueueVariant;
			}
			set
			{
				CraftingQueue.QueueVariant = value;
			}
		}

		private static int _craftingProgressLabelCount
		{
			get
			{
				return CraftingQueue.ProgressLabelCount;
			}
			set
			{
				CraftingQueue.ProgressLabelCount = value;
			}
		}

		private static int _craftingProgressLabelVariant
		{
			get
			{
				return CraftingQueue.ProgressLabelVariant;
			}
			set
			{
				CraftingQueue.ProgressLabelVariant = value;
			}
		}

		private static string _craftingRecipeGridSignature
		{
			get
			{
				return CraftingGrid.RecipeGridSignature;
			}
			set
			{
				CraftingGrid.RecipeGridSignature = value;
			}
		}

		private static string _craftingRecipeScrollbarSignature
		{
			get
			{
				return CraftingScrollbar.RecipeScrollbarSignature;
			}
			set
			{
				CraftingScrollbar.RecipeScrollbarSignature = value;
			}
		}

		private static string _craftingRecipeGridLayoutSignature
		{
			get
			{
				return CraftingGrid.RecipeGridLayoutSignature;
			}
			set
			{
				CraftingGrid.RecipeGridLayoutSignature = value;
			}
		}

		private static int _craftingRecipeGridCellCapacity
		{
			get
			{
				return CraftingGrid.RecipeGridCellCapacity;
			}
			set
			{
				CraftingGrid.RecipeGridCellCapacity = value;
			}
		}

		private static Recipe? _craftingQueueRecipe
		{
			get
			{
				return CraftingQueue.QueueRecipe;
			}
			set
			{
				CraftingQueue.QueueRecipe = value;
			}
		}

		private static Recipe? _craftingProgressLabelRecipe
		{
			get
			{
				return CraftingQueue.ProgressLabelRecipe;
			}
			set
			{
				CraftingQueue.ProgressLabelRecipe = value;
			}
		}

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

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

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

		private static Dictionary<int, SlotDefinition> QuickSlotDefinitionCache => InventoryDefinitions.QuickSlotDefinitionCache;

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

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

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

		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> CraftingRecipeHealthFoodInputTokens => InventoryDefinitions.CraftingRecipeHealthFoodInputTokens;

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static Dictionary<string, int> RestockTargetStackLimits
		{
			get
			{
				return InventoryDefinitions.RestockTargetStackLimits;
			}
			set
			{
				InventoryDefinitions.RestockTargetStackLimits = value;
			}
		}

		private static int _slotDefinitionVersion
		{
			get
			{
				return InventoryDefinitions.SlotDefinitionVersion;
			}
			set
			{
				InventoryDefinitions.SlotDefinitionVersion = value;
			}
		}

		private static int _customPanelSlotCacheVersion
		{
			get
			{
				return InventoryDefinitions.CustomPanelSlotCacheVersion;
			}
			set
			{
				InventoryDefinitions.CustomPanelSlotCacheVersion = value;
			}
		}

		private static int _quickPanelSlotCacheVersion
		{
			get
			{
				return InventoryDefinitions.QuickPanelSlotCacheVersion;
			}
			set
			{
				InventoryDefinitions.QuickPanelSlotCacheVersion = value;
			}
		}

		private static int _quickPanelSlotCacheUnlockedCount
		{
			get
			{
				return InventoryDefinitions.QuickPanelSlotCacheUnlockedCount;
			}
			set
			{
				InventoryDefinitions.QuickPanelSlotCacheUnlockedCount = value;
			}
		}

		private static int _quickSlotDefinitionCacheVersion
		{
			get
			{
				return InventoryDefinitions.QuickSlotDefinitionCacheVersion;
			}
			set
			{
				InventoryDefinitions.QuickSlotDefinitionCacheVersion = value;
			}
		}

		private static int _cachedObjectDbItemCount
		{
			get
			{
				return InventoryDefinitions.CachedObjectDbItemCount;
			}
			set
			{
				InventoryDefinitions.CachedObjectDbItemCount = value;
			}
		}

		private static int _cachedStationInputObjectDbItemCount
		{
			get
			{
				return InventoryDefinitions.CachedStationInputObjectDbItemCount;
			}
			set
			{
				InventoryDefinitions.CachedStationInputObjectDbItemCount = value;
			}
		}

		private static int _cachedStationInputPrefabCount
		{
			get
			{
				return InventoryDefinitions.CachedStationInputPrefabCount;
			}
			set
			{
				InventoryDefinitions.CachedStationInputPrefabCount = value;
			}
		}

		private static int _cachedStationInputRecipeCount
		{
			get
			{
				return InventoryDefinitions.CachedStationInputRecipeCount;
			}
			set
			{
				InventoryDefinitions.CachedStationInputRecipeCount = value;
			}
		}

		private static bool _stationInputTokensInitialized
		{
			get
			{
				return InventoryDefinitions.StationInputTokensInitialized;
			}
			set
			{
				InventoryDefinitions.StationInputTokensInitialized = value;
			}
		}

		private static bool _clientStateLoaded
		{
			get
			{
				return InventoryClient.ClientStateLoaded;
			}
			set
			{
				InventoryClient.ClientStateLoaded = value;
			}
		}

		private static string _loadedFavoritesPlayerId
		{
			get
			{
				return InventoryClient.LoadedFavoritesPlayerId;
			}
			set
			{
				InventoryClient.LoadedFavoritesPlayerId = value;
			}
		}

		private static InventorySlotsClientState _clientState
		{
			get
			{
				return InventoryClient.ClientState;
			}
			set
			{
				InventoryClient.ClientState = value;
			}
		}

		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;

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

		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 YamlFilePath => Path.Combine(Paths.ConfigPath, "InventorySlots.yml");

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

		internal static string DefaultYaml => "# Slot labels and custom equipment slot definitions. The six vanilla equipment\n# slot ids are fixed and only their names can be changed here.\n# Built-in compatibility slot ids are fixed as well; keep the id values unchanged.\n# Compatibility slots are created when the matching mod/API is loaded. Some\n# compatibility slots also support a non-empty items list as a custom fallback.\n# Other ids create custom equipment slots in the listed order.\nSlots:\n  - id: helmet\n    name: Helmet\n  - id: chest\n    name: Chest\n  - id: legs\n    name: Legs\n  - id: cape\n    name: Cape\n  - id: utility\n    name: Utility\n  - id: trinket\n    name: Trinket\n#  - id: circlet\n#    name: Circlet\n#    items:\n#      - HelmetDverger\n#  - id: wishbone\n#    name: Wishbone\n#    items:\n#      - Wishbone\n#  - id: demister\n#    name: Demister\n#    items:\n#      - Demister\n  - id: jewelcrafting.necklace\n    name: Necklace\n    items: []\n  - id: jewelcrafting.ring\n    name: Ring\n    items: []\n  - id: smoothbrainbackpacks.backpack\n    name: Backpack\n    items: []\n  - id: adventurebackpacks.backpack\n    name: Backpack\n    items: []\n  - id: rustybags.bag\n    name: Bag\n    items: []\n  - id: rustybags.quiver\n    name: Quiver\n    items: []\n  - id: magicsupremacy.belt\n    name: MagicBelt\n    items: []\n\n# Item groups control subgroup order for crafting, inventory, and container\n# sorting. Melee/Ranged/Magic/Equipment/Food/Consumable/Meadbase/Misc are\n# fixed top-level sections. Other keys define custom prefab groups, which can be\n# inserted into those sections or referenced by KeepOnDeath and QuickSlots.\nGroups:\n  Melee:\n    - sword\n    - axe\n    - club\n    - knife\n    - spear\n    - polearm\n    - fists\n    - shield\n    - pickaxe\n    - tool\n  Ranged:\n    - bow\n    - arrow\n    - crossbow\n    - bolt\n    - ammo\n    - bomb\n  Magic:\n    - elementalmagic\n    - bloodmagic\n  Equipment:\n    - helmet\n    - chest\n    - legs\n    - cape\n    - utility\n    - trinket\n#    - customgroup\n  Food:\n    - healthfood\n    - staminafood\n    - eitrfood\n#    - randomrandom\n  Consumable:\n    - mead\n    - potion\n  Meadbase: []\n  Misc:\n    - trophy\n    - valuable\n#  customgroup:\n#    - customprefab\n#    - prefabwhat\n#  randomrandom:\n#    - randomprefab\n#    - prefabprefab\n\n# Items matching these built-in groups, custom groups, or exact prefab/internal\n# names stay in the player inventory instead of moving to the tombstone.\nKeepOnDeath:\n  - Melee\n  - Ranged\n  - Magic\n  - Equipment\n\n# Items matching these top-level groups, subgroups, custom groups, or exact\n# prefab/internal names can be placed in quick slots.\nQuickSlots:\n  - Melee\n  - Ranged\n  - Magic\n  - healthfood\n  - staminafood\n  - eitrfood\n  - mead\n  - potion\n#\n# Resource tier map for crafting recipe sorting. The lowest tier should be\n# listed first by default; InventorySlots sorts higher tiers first in the grid.\nresourceMap:\n  - biome: Meadows\n    materials:\n      - Wood\n      - Stone\n      - Resin\n      - Dandelion\n      - Flint\n      - LeatherScraps\n      - BoneFragments\n      - Honey\n      - Raspberry\n      - Blueberries\n      - DeerHide\n      - DeerMeat\n      - Feathers\n      - GreydwarfEye\n      - RawMeat\n  - biome: BlackForest\n    materials:\n      - HardAntler\n      - Bronze\n      - BronzeNails\n      - Copper\n      - Tin\n      - Ectoplasm\n      - SurtlingCore\n      - TrollHide\n      - BjornHide\n      - FineWood\n      - AncientSeed\n      - Carrot\n      - BjornMeat\n      - BjornPaw\n      - RoundLog\n      - Thistle\n  - biome: Swamp\n    materials:\n      - Iron\n      - Ooze\n      - Entrails\n      - Guck\n      - Bloodbag\n      - Chain\n      - ElderBark\n      - IronNails\n      - Root\n      - Turnip\n      - WitheredBone\n      - CuredSquirrelHamstring\n  - biome: Ocean\n    materials:\n      - Chitin\n      - Resin\n      - SerpentScale\n      - SerpentMeat\n  - biome: Mountain\n    materials:\n      - Silver\n      - Crystal\n      - DragonEgg\n      - JuteRed\n      - Obsidian\n      - WolfClaw\n      - WolfFang\n      - WolfHairBundle\n      - WolfMeat\n      - WolfPelt\n  - biome: Plains\n    materials:\n      - UndeadBjornRibcage\n      - BlackMetal\n      - DragonTear\n      - Barley\n      - BarleyFlour\n      - BoneFragments\n      - ChickenEgg\n      - ChickenMeat\n      - Flax\n      - GoblinTotem\n      - LinenThread\n      - LoxMeat\n      - LoxPelt\n      - Needle\n      - Tar\n  - biome: Mistlands\n    materials:\n      - Eitr\n      - Bilebag\n      - BlackCore\n      - BlackMarble\n      - BugMeat\n      - Carapace\n      - DvergrKeyFragment\n      - DvergrNeedle\n      - GiantBloodSack\n      - HareMeat\n      - JuteBlue\n      - Mandible\n      - Sap\n      - ScaleHide\n      - Softtissue\n      - Wisp\n      - YagluthDrop\n      - YggdrasilWood\n  - biome: AshLands\n    materials:\n      - FlametalNew\n      - AskBladder\n      - AskHide\n      - AsksvinEgg\n      - AsksvinMeat\n      - Blackwood\n      - BoneMawSerpentMeat\n      - BonemawSerpentTooth\n      - CelestialFeather\n      - CeramicPlate\n      - CharcoalResin\n      - CharredBone\n      - CharredCogwheel\n      - Charredskull\n      - Grausten\n      - MoltenCore\n      - MorgenHeart\n      - MorgenSinew\n      - ProustitePowder\n      - SulfurStone\n      - VoltureEgg\n      - VoltureMeat";

		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 ex)
			{
				Log.LogDebug((object)("AzuCraftyBoxes compatibility count failed: " + ex.Message));
				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 TryFormatAzuCraftyBoxesRequirementAmount(int available, int required, out string text)
		{
			text = "";
			if (!TryGetAzuCraftyBoxesApi(out AzuCraftyBoxesApi api) || api == null || api.ShouldPrevent())
			{
				return false;
			}
			return api.TryFormatRequirementAmount(available, required, out text);
		}

		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 (!CompatRuntime.AdventureBackpacksPatchesApplied && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) && api != null)
			{
				api.ApplyPatches(_instance._harmony);
				CompatRuntime.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)
		{
			string id2 = id;
			Func<ItemData?, bool> accepts2 = accepts;
			if (SlotDefinitions.Any((SlotDefinition existing) => existing.Id == id2))
			{
				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(id2, name, SlotKind.CustomEquipment, (ItemData? item) => accepts2(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 (CompatRuntime.LastAdventureBackpackCompatItem != item || !api.IsBackpackEquippedFlagSet())
				{
					api.OnCustomBackpackEquipped(player, item);
				}
				CompatRuntime.LastAdventureBackpackCompatItem = item;
			}
			if (IsSmoothbrainBackpackItem(item) && TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi api2) && api2 != null)
			{
				api2.SyncEquippedBackpack(player, item);
				CompatRuntime.LastSmoothbrainBackpackCompatItem = item;
			}
			if (TryGetRustyBagsApi(out RustyBagsApi api3) && api3 != null)
			{
				if (IsRustyBagItem(item))
				{
					api3.SyncBag(player, item);
					CompatRuntime.LastRustyBagCompatItem = item;
				}
				else if (IsRustyQuiverItem(item))
				{
					api3.SyncQuiver(player, item);
					CompatRuntime.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 ((CompatRuntime.LastAdventureBackpackCompatItem == item || IsAdventureBackpackItem(item)) && TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) && api != null)
			{
				api.OnCustomBackpackUnequipping(player, item);
				if (CompatRuntime.LastAdventureBackpackCompatItem == item)
				{
					CompatRuntime.LastAdventureBackpackCompatItem = null;
				}
			}
			if ((CompatRuntime.LastSmoothbrainBackpackCompatItem == item || IsSmoothbrainBackpackItem(item)) && TryGetSmoothbrainBackpacksApi(out SmoothbrainBackpacksApi api2) && api2 != null)
			{
				api2.SyncEquippedBackpack(player, null);
				if (CompatRuntime.LastSmoothbrainBackpackCompatItem == item)
				{
					CompatRuntime.LastSmoothbrainBackpackCompatItem = null;
				}
			}
			if (TryGetRustyBagsApi(out RustyBagsApi api3) && api3 != null)
			{
				if (CompatRuntime.LastRustyBagCompatItem == item || IsRustyBagItem(item))
				{
					api3.ClearBagIfCurrent(player, item);
					if (CompatRuntime.LastRustyBagCompatItem == item)
					{
						CompatRuntime.LastRustyBagCompatItem = null;
					}
				}
				if (CompatRuntime.LastRustyQuiverCompatItem == item || IsRustyQuiverItem(item))
				{
					api3.ClearQuiverIfCurrent(player, item);
					if (CompatRuntime.LastRustyQuiverCompatItem == item)
					{
						CompatRuntime.LastRustyQuiverCompatItem = null;
					}
				}
			}
			OnMagicSupremacyBeltUnequipping(player, item);
		}

		private static void SyncAdventureBackpackCompatState(Player player)
		{
			if (!TryGetAdventureBackpacksApi(out AdventureBackpacksApi api) || api == null)
			{
				CompatRuntime.LastAdventureBackpackCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsAdventureBackpackItem);
			if (val != CompatRuntime.LastAdventureBackpackCompatItem)
			{
				if (CompatRuntime.LastAdventureBackpackCompatItem != null)
				{
					api.OnCustomBackpackUnequipping(player, CompatRuntime.LastAdventureBackpackCompatItem);
				}
				CompatRuntime.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)
			{
				CompatRuntime.LastSmoothbrainBackpackCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsSmoothbrainBackpackItem);
			api.SyncEquippedBackpack(player, val);
			CompatRuntime.LastSmoothbrainBackpackCompatItem = val;
		}

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

		private static ItemData? FindCustomEquippedItem(Player player, Func<ItemData?, bool> predicate)
		{
			Func<ItemData?, bool> predicate2 = predicate;
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			return ((IEnumerable<ItemData>)GetCustomEquippedItems(player)).FirstOrDefault((Func<ItemData, bool>)((ItemData item) => item != null && predicate2(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)
		{
			ItemData itemData2 = itemData;
			if (!__result && !((Object)(object)player == (Object)null) && itemData2 != null && IsAdventureBackpackItem(itemData2))
			{
				__result = GetCustomEquippedItems(player).Any((ItemData item) => item == itemData2);
			}
		}

		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, "BetterArchery quiver", 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, ref TApi? cachedApi, ref bool reflectionFailed, ref CompatCapabilityState state, CompatApiFactory<TApi> factory, string warningPrefix, out TApi? api) where TApi : class
		{
			api = cachedApi;
			if (api != null)
			{
				return SetCompatCapabilityState(ref state, CompatCapabilityState.Available, capability);
			}
			if (!TryGetCompatAssembly(guid, capability, ref reflectionFailed, ref state, out Assembly assembly))
			{
				api = null;
				return false;
			}
			try
			{
				if (!factory(assembly, out api, out var detail) || api == null)
				{
					return MarkCompatMissingApi(ref reflectionFailed, ref state, capability, detail, warningPrefix + ": " + detail + ".");
				}
				cachedApi = api;
				return SetCompatCapabilityState(ref state, CompatCapabilityState.Available, capability);
			}
			catch (Exception ex)
			{
				api = null;
				return MarkCompatReflectionFailed(ref reflectionFailed, ref state, capability, ex.Message, warningPrefix);
			}
		}

		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 SetCompatCapabilityState(ref runtime.CapabilityState, CompatCapabilityState.Available, capability);
			}
			if (!TryGetCompatAssembly(guid, capability, runtime, out Assembly assembly))
			{
				api = null;
				return false;
			}
			try
			{
				if (!factory(assembly, out api, out var detail) || api == null)
				{
					return MarkCompatMissingApi(runtime, capability, detail, warningPrefix + ": " + detail + ".");
				}
				runtime.Api = api;
				return SetCompatCapabilityState(ref runtime.CapabilityState, CompatCapabilityState.Available, capability);
			}
			catch (Exception ex)
			{
				api = null;
				return MarkCompatReflectionFailed(runtime, capability, ex.Message, warningPrefix);
			}
		}

		private static bool TryGetCompatAssembly(string guid, string capability, ref bool reflectionFailed, ref CompatCapabilityState state, out Assembly? assembly)
		{
			assembly = null;
			if (!HasPlugin(guid))
			{
				return SetCompatCapabilityState(ref state, CompatCapabilityState.Unavailable, capability);
			}
			if (reflectionFailed)
			{
				if (state != CompatCapabilityState.MissingApi)
				{
					return SetCompatCapabilityState(ref state, CompatCapabilityState.Failed, capability);
				}
				return false;
			}
			try
			{
				assembly = ((object)Chainloader.PluginInfos[guid].Instance).GetType().Assembly;
				return true;
			}
			catch (Exception ex)
			{
				return MarkCompatReflectionFailed(ref reflectionFailed, ref state, capability, ex.Message, capability + " compatibility disabled");
			}
		}

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

		private static bool MarkCompatMissingApi(ref bool reflectionFailed, ref CompatCapabilityState state, string capability, string detail, string warning)
		{
			reflectionFailed = true;
			SetCompatCapabilityState(ref state, CompatCapabilityState.MissingApi, capability, detail);
			Log.LogWarning((object)warning);
			return false;
		}

		private static bool MarkCompatMissingApi<TApi>(CompatApiRuntimeState<TApi> runtime, string capability, string detail, string warning) where TApi : class
		{
			runtime.ReflectionFailed = true;
			SetCompatCapabilityState(ref runtime.CapabilityState, CompatCapabilityState.MissingApi, capability, detail);
			Log.LogWarning((object)warning);
			return false;
		}

		private static bool MarkCompatReflectionFailed(ref bool reflectionFailed, ref CompatCapabilityState state, string capability, string detail, string warningPrefix)
		{
			reflectionFailed = true;
			SetCompatCapabilityState(ref state, CompatCapabilityState.Failed, capability, detail);
			Log.LogWarning((object)(warningPrefix + ": " + detail));
			return false;
		}

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

		private static object? GetCompatConfigEntryValue(FieldInfo? field)
		{
			if (field == null)
			{
				return null;
			}
			try
			{
				object? value = field.GetValue(null);
				ConfigEntryBase val = (ConfigEntryBase)((value is ConfigEntryBase) ? value : null);
				return (val != null) ? val.BoxedValue : null;
			}
			catch
			{
				return null;
			}
		}

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

		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 != 0)
			{
				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 != 0)
			{
				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 != 0)
			{
				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 bool CanHandleContainerRestock(Player player, Container container)
		{
			if ((Object)(object)player != (Object)null && !player.m_isLoading && (Object)(object)container != (Object)null && container.m_inventory != null && CanMutateContainerDirectly(container, allowLocalWithoutZNetView: true))
			{
				return HasContainerPlayerAccess(player, container, flashGuardStone: false);
			}
			return false;
		}

		private static bool IsAreaContainerAllowed(Player player, Container container, Container? currentContainer, Vector3 playerPosition, float rangeSq, 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) || !CanMutateContainerDirectly(container) || !HasContainerPlayerAccess(player, container, flashGuardStone: true))
			{
				return false;
			}
			if ((Object)(object)container.m_piece != (Object)null && !container.m_piece.IsPlacedByPlayer())
			{
				return false;
			}
			if (!HasMultiUserChestActive)
			{
				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 bool CanUseContainerThroughOwnerOrMultiUserChest(Container container, bool allowLocalWithoutZNetView = false)
		{
			if ((Object)(object)container == (Object)null)
			{
				return false;
			}
			if ((Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return allowLocalWithoutZNetView;
			}
			if (container.m_nview.IsOwner())
			{
				return true;
			}
			if (HasMultiUserChestActive)
			{
				return !IsMultiUserChestIgnored(container);
			}
			return false;
		}

		private static bool CanMutateContainerDirectly(Container container, bool allowLocalWithoutZNetView = false)
		{
			if ((Object)(object)container == (Object)null)
			{
				return false;
			}
			if ((Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return allowLocalWithoutZNetView;
			}
			return container.m_nview.IsOwner();
		}

		private static bool CanProcessContainerSortRpc(Container container, long sender, long requesterPlayerId)
		{
			if (sender != 0L && requesterPlayerId != 0L && sender == requesterPlayerId && CanMutateContainerDirectly(container))
			{
				return container.CheckAccess(sender);
			}
			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 bool IsRemoteMultiUserChestInventory(Inventory inventory)
		{
			Inventory inventory2 = inventory;
			if (inventory2 != null && HasMultiUserChestActive)
			{
				return InventoryContainers.KnownContainers.Any((Container container) => (Object)(object)container != (Object)null && container.m_inventory == inventory2 && (Object)(object)container.m_nview != (Object)null && container.m_nview.IsValid() && !container.m_nview.IsOwner() && !IsMultiUserChestIgnored(container));
			}
			return false;
		}

		private static List<Container> GetActionContainers(Player player, Container currentContainer, bool areaForQuickStack)
		{
			//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, out distanceSq))
				{
					list2.Add((val, distanceSq));
					hashSet.Add(val);
				}
			}
			list2.Sort(((Container Container, float DistanceSq) left, (Container Container, float DistanceSq) right) => left.DistanceSq.CompareTo(right.DistanceSq));
			foreach (var item2 in list2)
			{
				Container item = item2.Item1;
				list.Add(item);
			}
			return list;
		}

		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_005f: 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))
					{
						InventoryCellKind inventoryCellKind = GetInventoryCellKind(player, inventory, val);
						if (inventoryCellKind == InventoryCellKind.RegularUnlocked || (includeHotbar && inventoryCellKind == InventoryCellKind.Hotbar))
						{
							list.Add(val);
						}
					}
				}
			}
			return list;
		}

		private static HashSet<Vector2i> GetFavoriteBlockedSlots(Player player, Inventory inventory)
		{
			//IL_0053: 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)
			HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
			if (!AreFavoritesEnabled())
			{
				return hashSet;
			}
			EnsureFavoritesLoaded(player);
			if (LeaveEmptyFavoriteSlots)
			{
				hashSet.UnionWith(FavoriteSlots);
				return hashSet;
			}
			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;
			}
			Container currentContainer = InventoryGui.instance.m_currentContainer;
			if ((Object)(object)currentContainer == (Object)null || currentContainer.m_inventory == null)
			{
				ShowActionResult(player, LocalizeUi("$inventoryslots_action_container", "Container"), 0);
				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, out bool remotePending)
		{
			int num = (sourceInventory.m_inventory.Contains(sourceItem) ? sourceItem.m_stack : 0);
			int num2 = Math.Max(0, before - num);
			remotePending = false;
			if (num2 == 0 && moveSucceeded && IsRemoteMultiUserChestInventory(sourceInventory))
			{
				remotePending = true;
				num2 = requestedAmount;
			}
			return num2;
		}

		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_0007: 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)
			int num = a.y.CompareTo(b.y);
			if (num == 0)
			{
				return a.x.CompareTo(b.x);
			}
			return num;
		}

		private static void ShowActionResult(Player player, string action, int moved)
		{
			if (!((Object)(object)player == (Object)null))
			{
				string text = LocalizeUi("$inventoryslots_action_result_format", "{action}: {count}").Replace("{action}", action).Replace("{count}", moved.ToString());
				((Character)player).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static int GetContainerActionSuccessFxMode()
		{
			return Mathf.Clamp((_containerActionSuccessFxMode == null) ? 1 : _containerActionSuccessFxMode.Value, 0, 12);
		}

		private static float GetContainerActionSuccessFxVolume()
		{
			return Mathf.Clamp01((_containerActionSuccessFxVolume != null) ? _containerActionSuccessFxVolume.Value : 1f);
		}

		private static int TryPlayChangedContainerActionSuccessFx(Player player, Container container, int mode, int played)
		{
			if (mode < 2 || played >= mode)
			{
				return played;
			}
			PlayContainerActionSuccessFx(player, container);
			return played + 1;
		}

		private static void PlayContainerActionSuccessFx(Player player, Container container)
		{
			//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_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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && !IsUnityNull((Object?)(object)player) && !((Object)(object)container == (Object)null) && !IsUnityNull((Object?)(object)container) && !((Object)(object)ZNetScene.instance == (Object)null))
			{
				GameObject prefab = ZNetScene.instance.GetPrefab("fx_HildirChest_Unlock");
				if (!((Object)(object)prefab == (Object)null) && !IsUnityNull((Object?)(object)prefab))
				{
					Vector3 position = ((Component)container).transform.position;
					Quaternion rotation = ((Component)container).transform.rotation;
					ApplyContainerActionSuccessFxVolume(Object.Instantiate<GameObject>(prefab, position, rotation));
				}
			}
		}

		private static void ApplyContainerActionSuccessFxVolume(GameObject instance)
		{
			float containerActionSuccessFxVolume = GetContainerActionSuccessFxVolume();
			if ((Object)(object)instance == (Object)null || IsUnityNull((Object?)(object)instance) || containerActionSuccessFxVolume >= 0.999f)
			{
				return;
			}
			Component[] componentsInChildren = instance.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
				{
					ScaleSfxComponentVolume(val, containerActionSuccessFxVolume);
				}
			}
		}

		private static void ScaleSfxComponentVolume(Component component, float volumeScale)
		{
			Type type = ((object)component).GetType();
			if (IsUnityAudioSource(type))
			{
				ScaleUnityAudioSourceVolume(component, type, volumeScale);
			}
			else
			{
				if (!IsLikelySfxComponent(type))
				{
					return;
				}
				SfxVolumeMemberCache sfxVolumeMemberCache = GetSfxVolumeMemberCache(type);
				FieldInfo[] fields = sfxVolumeMemberCache.Fields;
				foreach (FieldInfo fieldInfo in fields)
				{
					try
					{
						fieldInfo.SetValue(component, Mathf.Max(0f, (float)fieldInfo.GetValue(component) * volumeScale));
					}
					catch
					{
					}
				}
				PropertyInfo[] properties = sfxVolumeMemberCache.Properties;
				foreach (PropertyInfo propertyInfo in properties)
				{
					try
					{
						propertyInfo.SetValue(component, Mathf.Max(0f, (float)propertyInfo.GetValue(component) * volumeScale));
					}
					catch
					{
					}
				}
			}
		}

		private static SfxVolumeMemberCache GetSfxVolumeMemberCache(Type type)
		{
			if (SfxVolumeMembersByType.TryGetValue(type, out var value))
			{
				return value;
			}
			value = new SfxVolumeMemberCache((from field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where field.FieldType == typeof(float) && IsSfxVolumeMemberName(field.Name) && !IsUnsupportedSfxVolumeMemberName(field.Name)
				select field).ToArray(), (from property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where property.PropertyType == typeof(float) && property.CanRead && property.CanWrite && property.GetIndexParameters().Length == 0 && IsSfxVolumeMemberName(property.Name) && !IsUnsupportedSfxVolumeMemberName(property.Name)
				select property).ToArray());
			SfxVolumeMembersByType[type] = value;
			return value;
		}

		private static bool IsLikelySfxComponent(Type type)
		{
			string name = type.Name;
			if (name.IndexOf("SFX", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("Audio", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool IsSfxVolumeMemberName(string name)
		{
			if (name.IndexOf("volume", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("vol", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool IsUnsupportedSfxVolumeMemberName(string name)
		{
			if (!string.Equals(name, "minVolume", StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(name, "maxVolume", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsUnityAudioSource(Type type)
		{
			return string.Equals(type.FullName, "UnityEngine.AudioSource", StringComparison.Ordinal);
		}

		private static void ScaleUnityAudioSourceVolume(Component component, Type type, float volumeScale)
		{
			PropertyInfo property = type.GetProperty("volume", BindingFlags.Instance | BindingFlags.Public);
			if (property == null || !property.CanRead || !property.CanWrite)
			{
				return;
			}
			try
			{
				property.SetValue(component, Mathf.Max(0f, (float)property.GetValue(component) * volumeScale));
			}
			catch
			{
			}
		}

		internal static bool TryHandleVanillaPlaceStacks(InventoryGui gui)
		{
			if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_currentContainer == (Object)null)
			{
				return false;
			}
			if (!CanMutateContainerDirectly(gui.m_currentContainer, allowLocalWithoutZNetView: true))
			{
				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;
			}
			if (!CanMutateContainerDirectly(container, allowLocalWithoutZNetView: true))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			QuickStackIntoContainers(localPlayer, 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)
		{
			Player localPlayer2 = localPlayer;
			Inventory playerInventory2 = playerInventory;
			List<ItemData> list = playerInventory2.m_inventory.Where((ItemData item) => ShouldQuickStackItem(localPlayer2, playerInventory2, item, includeHotbar: false)).ToList();
			list.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 num = 0;
			int num2 = (includeArea ? GetContainerActionSuccessFxMode() : 0);
			int played = 0;
			foreach (Container item in (List<Container>)(includeArea ? ((IList)GetActionContainers(localPlayer2, container, areaForQuickStack: true)) : ((IList)new List<Container> { container })))
			{
				int num3 = QuickStackItemsIntoContainer(playerInventory2, item.m_inventory, list);
				num += num3;
				if (num3 > 0)
				{
					played = TryPlayChangedContainerActionSuccessFx(localPlayer2, item, num2, played);
				}
			}
			if (num > 0)
			{
				playerInventory2.Changed();
				ClearCraftingRequirementAvailabilityCache();
				if (num2 == 1)
				{
					PlayContainerActionSuccessFx(localPlayer2, container);
				}
			}
			ShowActionResult(localPlayer2, LocalizeUi("$inventoryslots_action_stack", "Stack"), num);
		}

		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();
			}
			ShowActionResult(localPlayer, LocalizeUi("$inventoryslots_action_place_all", "Place All"), num);
		}

		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()
		{
			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)
		{
			if (!TryGetContainerRestockHotkeyContext(player, out Container container))
			{
				ResetContainerRestockHold();
				return;
			}
			if (IsUnityNull((Object?)(object)InventoryPanels.ContainerRestockHoldContainer) || (Object)(object)InventoryPanels.ContainerRestockHoldContainer != (Object)(object)container)
			{
				InventoryPanels.ContainerRestockHoldContainer = container;
				InventoryPanels.ContainerRestockHoldStartTime = Time.time;
				InventoryPanels.ContainerRestockHoldTriggered = false;
			}
			if (!InventoryPanels.ContainerRestockHoldTriggered && !(Time.time - InventoryPanels.ContainerRestockHoldStartTime < 0.5f))
			{
				if (TryRestockFromHoveredContainer(player, container))
				{
					InventoryPanels.ContainerRestockHoldTriggered = true;
				}
				else
				{
					ResetContainerRestockHold();
				}
			}
		}

		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;
			}
			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)
		{
			Player localPlayer2 = localPlayer;
			Inventory playerInventory2 = playerInventory;
			if ((Object)(object)localPlayer2 == (Object)null || playerInventory2 == null || (Object)(object)container == (Object)null || container.m_inventory == null)
			{
				return;
			}
			bool num = mode == ContainerTakeStacksMode.AreaFavoriteRestock;
			List<ItemData> list = playerInventory2.m_inventory.Where((ItemData item) => ShouldTakeStacksTarget(localPlayer2, playerInventory2, item, includeHotbar: false, mode)).ToList();
			list.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 num2 = 0;
			int num3 = (num ? GetContainerActionSuccessFxMode() : 0);
			int played = 0;
			foreach (Container item in (List<Container>)(num ? ((IList)GetActionContainers(localPlayer2, container, areaForQuickStack: false)) : ((IList)new List<Container> { container })))
			{
				int num4 = RestockTargetsFromContainer(playerInventory2, item.m_inventory, list, mode);
				num2 += num4;
				if (num4 > 0)
				{
					played = TryPlayChangedContainerActionSuccessFx(localPlayer2, item, num3, played);
				}
			}
			if (num2 > 0)
			{
				playerInventory2.Changed();
				ClearCraftingRequirementAvailabilityCache();
				if (num3 == 1)
				{
					PlayContainerActionSuccessFx(localPlayer2, container);
				}
			}
			ShowActionResult(localPlayer2, LocalizeUi("$inventoryslots_action_take_stacks", "Take stacks"), num2);
		}

		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)
			if (!IsContainerRestockKeyConfigured() || !IsShortcutHeldAllowingAltPair(_containerRestockKey.Value))
			{
				return IsControllerHotkeyHeld(_controllerContainerRestockButton);
			}
			return true;
		}

		private static void ResetContainerRestockHold()
		{
			InventoryPanels.ContainerRestockHoldContainer = null;
			InventoryPanels.ContainerRestockHoldStartTime = -1f;
			InventoryPanels.ContainerRestockHoldTriggered = false;
		}

		private static string GetContainerRestockKeyDisplayText()
		{
			//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_001d: 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_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_004f: 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)
			List<string> list = new List<string>();
			if (_containerRestockKey != null)
			{
				KeyboardShortcut value = _containerRestockKey.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					KeyboardShortcut value2 = _containerRestockKey.Value;
					List<string> list2 = new List<string>();
					foreach (KeyCode modifier in ((KeyboardShortcut)(ref value2)).Modifiers)
					{
						AddContainerRestockKeyPart(list2, FormatContainerRestockKey(modifier));
					}
					AddContainerRestockKeyPart(list2, FormatContainerRestockKey(((KeyboardShortcut)(ref value2)).MainKey));
					AddContainerRestockKeyPart(list, string.Join(" + ", list2));
				}
			}
			AddContainerRestockKeyPart(list, GetControllerHotkeyDisplayText(_controllerContainerRestockButton));
			return string.Join("/", list);
		}

		private static void AddContainerRestockKeyPart(List<string> parts, string value)
		{
			if (!string.IsNullOrWhiteSpace(value) && !parts.Contains(value))
			{
				parts.Add(value);
			}
		}

		private static string FormatContainerRestockKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0005: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected I4, but got Unknown
			//IL_000b: 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_003c: Expected I4, but got Unknown
			//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)
			//IL_008d: Expected I4, but got Unknown
			if ((int)key <= 57)
			{
				if ((int)key == 0)
				{
					return "";
				}
				switch (key - 48)
				{
				case 0:
					return "0";
				case 1:
					return "1";
				case 2:
					return "2";
				case 3:
					return "3";
				case 4:
					return "4";
				case 5:
					return "5";
				case 6:
					return "6";
				case 7:
					return "7";
				case 8:
					return "8";
				case 9:
					return "9";
				}
			}
			else
			{
				if ((int)key == 96)
				{
					return "`";
				}
				switch (key - 303)
				{
				case 4:
				case 5:
					return "Alt";
				case 2:
				case 3:
					return "Ctrl";
				case 0:
				case 1:
					return "Shift";
				}
				switch (key - 323)
				{
				case 0:
					return "Mouse-1";
				case 1:
					return "Mouse-2";
				case 2:
					return "Mouse-3";
				case 3:
					return "Mouse-4";
				case 4:
					return "Mouse-5";
				}
			}
			return ((object)(KeyCode)(ref key)).ToString();
		}

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

		private static bool ShouldRestockItem(Player player, Inventory inventory, ItemData item, bool includeHotbar)
		{
			if (item?.m_shared == null || !IsRegularActionItem(player, inventory, item, includeHotbar) || !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 IsFavoriteRestockTarget(Player player, ItemData item)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (AreFavoritesEnabled())
			{
				return IsFavoriteSlot(player, item.m_gridPos);
			}
			return false;
		}

		private static int GetRestockTargetStack(ItemData item)
		{
			if (item?.m_shared != null)
			{
				return RestockTargetLimitCore.ResolveTargetStackLimit(RestockTargetStackLimits, GetRestockTargetLookupTokens(item), item.m_shared.m_maxStackSize);
			}
			return 0;
		}

		[IteratorStateMachine(typeof(<GetRestockTargetLookupTokens>d__201))]
		private static IEnumerable<string?> GetRestockTargetLookupTokens(ItemData item)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetRestockTargetLookupTokens>d__201(-2)
			{
				<>3__item = item
			};
		}

		private static bool CanRestockFromContainerItem(ItemData target, ItemData source)
		{
			if (target?.m_shared != null && source?.m_shared != null && CanUseContainerActionStacking(target) && CanUseContainerActionStacking(source) && string.Equals(target.m_shared.m_name, source.m_shared.m_name, StringComparison.OrdinalIgnoreCase))
			{
				return target.m_quality == source.m_quality;
			}
			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);
							bool remotePending;
							int num6 = CountMovedFromContainerSource(containerInventory, val, stack, num5, moveSucceeded, out remotePending);
							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))
			{
				Container currentContainer = InventoryGui.instance.m_currentContainer;
				if ((Object)(object)currentContainer == (Object)null || currentContainer.m_inventory == null)
				{
					ShowActionResult(player, LocalizeUi("$inventoryslots_action_container", "Container"), 0);
				}
				else if (CanMutateContainerDirectly(currentContainer, allowLocalWithoutZNetView: true))
				{
					int moved = SortContainerInventory(currentContainer);
					ShowActionResult(player, LocalizeUi("$inventoryslots_action_sort", "Sort"), moved);
				}
				else if (!CanUseContainerThroughOwnerOrMultiUserChest(currentContainer))
				{
					((Character)player).Message((MessageType)2, LocalizeUi("$inventoryslots_container_not_ready", "Container is not ready."), 0, (Sprite)null);
				}
				else
				{
					currentContainer.m_nview.InvokeRPC("InventorySlots_RequestSort", new object[1] { player.GetPlayerID() });
					((Character)player).Message((MessageType)2, LocalizeUi("$inventoryslots_action_sort_requested", "Sort requested."), 0, (Sprite)null);
				}
			}
		}

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

		internal static void UnregisterContainer(Container container)
		{
			if ((Object)(object)container != (Object)null)
			{
				InventoryContainers.KnownContainers.Remove(container);
			}
		}

		private static void RegisterContainerRpcs(Container container)
		{
			Container container2 = container;
			if ((Object)(object)container2 == (Object)null)
			{
				return;
			}
			if ((Object)(object)container2.m_nview == (Object)null)
			{
				container2.m_nview = (((Object)(object)container2.m_rootObjectOverride != (Object)null) ? ((Component)container2.m_rootObjectOverride).GetComponent<ZNetView>() : ((Component)container2).GetComponent<ZNetView>());
			}
			if (!((Object)(object)container2.m_nview == (Object)null))
			{
				container2.m_nview.Unregister("InventorySlots_RequestSort");
				container2.m_nview.Register<long>("InventorySlots_RequestSort", (Action<long, long>)delegate(long sender, long requesterPlayerId)
				{
					RPC_RequestSort(container2, sender, requesterPlayerId);
				});
			}
		}

		private static void RPC_RequestSort(Container container, long sender, long requesterPlayerId)
		{
			if (CanProcessContainerSortRpc(container, sender, requesterPlayerId))
			{
				SortContainerInventory(container);
			}
		}

		private static void SortPlayerInventory(Player? player)
		{
			Player player2 = player;
			if ((Object)(object)player2 == (Object)null || player2.m_isLoading)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player2).GetInventory();
			if (inventory != null)
			{
				List<Vector2i> playerActionSlots = GetPlayerActionSlots(player2, inventory, includeHotbar: false, blockFavorites: true);
				HashSet<Vector2i> allowedSet = new HashSet<Vector2i>(playerActionSlots);
				InventoryGui.instance.SetupDragItem((ItemData)null, (Inventory)null, 0);
				int moved = SortInventoryInternal(inventory, playerActionSlots, (ItemData item) => item?.m_shared != null && allowedSet.Contains(item.m_gridPos) && !IsFavoriteProtected(player2, inventory, item));
				ShowActionResult(player2, LocalizeUi("$inventoryslots_action_sort_inventory", "Sort Inv"), moved);
			}
		}

		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 i = 0; i < num2; i++)
			{
				if (list[i].m_gridPos != allowedSlots[i])
				{
					num++;
					flag = true;
					list[i].m_gridPos = allowedSlots[i];
				}
			}
			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
				} 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;
			}
			Container currentContainer = gui.m_currentContainer;
			if (!CanMutateContainerDirectly(currentContainer, allowLocalWithoutZNetView: true))
			{
				((Character)localPlayer).Message((MessageType)2, LocalizeUi("$inventoryslots_container_not_ready", "Container is not ready."), 0, (Sprite)null);
				return true;
			}
			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);
			int num2 = SafeTakeAllItems(localPlayer, inventory, inventory2, includeHotbar: false);
			if (num2 > 0)
			{
				inventory.Changed();
				inventory2.Changed();
				ClearCraftingRequirementAvailabilityCache();
			}
			if (num && inventory2.NrOfItems() == 0)
			{
				component.OnTakeAllSuccess();
			}
			ShowActionResult(localPlayer, LocalizeUi("$inventoryslots_action_take_all", "Take All"), num2);
			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_00d2: 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_00f5: 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)
			int num = 0;
			if (CanMergeForSafeMove(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);
						bool remotePending;
						int num3 = CountMovedFromContainerSource(containerInventory, source, stack, num2, moveSucceeded, out remotePending);
						num += num3;
						if (remotePending)
						{
							return num;
						}
					}
				}
			}
			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);
				bool remotePending2;
				int num4 = CountMovedFromContainerSource(containerInventory, source, stack2, stack3, moveSucceeded2, out remotePending2);
				num += num4;
				if (num4 == 0 || remotePending2)
				{
					break;
				}
			}
			return num;
		}

		private static List<ItemData> GetSafeTakeAllStackTargets(Inventory playerInventory, ItemData source, HashSet<Vector2i> allowedSlots)
		{
			HashSet<Vector2i> allowedSlots2 = allowedSlots;
			ItemData source2 = source;
			return (from target in playerInventory.m_inventory
				where target?.m_shared != null && allowedSlots2.Contains(target.m_gridPos) && CanMergeForSafeMove(target) && string.Equals(target.m_shared.m_name, source2.m_shared.m_name, StringComparison.OrdinalIgnoreCase) && target.m_quality == source2.m_quality && 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)
		{
			Inventory playerInventory2 = playerInventory;
			return actionSlots.Where((Vector2i slot) => playerInventory2.GetItemAt(slot.x, slot.y) == null).ToList();
		}

		private static bool CanMergeForSafeMove(ItemData item)
		{
			if (item?.m_shared != null && item.m_shared.m_maxStackSize > 1)
			{
				return CanUseContainerActionStacking(item);
			}
			return false;
		}

		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 != 0)
				{
					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 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 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 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 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);
			List<CustomEquipmentVisualState> states = BuildCustomEquipmentVisualStatesFromInventory(player, inventory, visEquipment);
			SuppressJewelcraftingNativeVisualSlots(player, inventory);
			ApplyCustomEquipmentVisualStates(visEquipment, states);
		}

		internal static void UpdateCustomEquipmentVisualsFromZdo(VisEquipment visEquipment)
		{
			//IL_00f9: 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)
			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 @int = val.GetInt(GetCustomEquipmentVisualItemZdoKey(item.Id), 0);
				if (@int == 0)
				{
					continue;
				}
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(@int);
				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.m_shared.m_itemType))
					{
						int int2 = val.GetInt(GetCustomEquipmentVisualVariantZdoKey(item.Id), 0);
						list.Add(new CustomEquipmentVisualState(item.Id, @int, int2, ((Object)itemPrefab).name, component.m_itemData.m_shared.m_itemType));
					}
				}
			}
			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));
				}
				SetCustomEquipmentVisualZdoValue(visEquipment, item.Id, itemHash, variant);
			}
			return list;
		}

		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();
			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)
			{
				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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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 (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 bool ShouldAttachCustomEquipmentVisual(ItemType itemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			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);
						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 LayoutCraftingBottomControls(InventoryGui gui, RectTransform grid)
		{
			//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_0084: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_009f: 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_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_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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0133: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			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);
				}
				MarkCraftingBottomControlsDirty();
				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 = _craftingBottomControlsDirty || !string.Equals(_craftingBottomControlsSignature, craftingBottomControlsLayoutSignature, StringComparison.Ordinal);
			UpdateCraftingActionControls(gui, countRect, upgradeProgressionRect, craftPosition, countPosition, val, val2, updateLayout);
			UpdateCraftingStationAndWarningControls(gui, grid, requiredStationPosition, updateLayout);
			UpdateCraftingRequirementStrip(gui, requirementPosition, visibleCraftingRequirements, updateLayout);
			_craftingBottomControlsSignature = craftingBottomControlsLayoutSignature;
			_craftingBottomControlsDirty = false;
		}

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

		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_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_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_0086: 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_00a2: 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_00e0: 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)
			string craftingStatusHudText = GetCraftingStatusHudText(gui);
			if (string.IsNullOrWhiteSpace(craftingStatusHudText))
			{
				HideCraftingSocketWarning();
				return;
			}
			RectTransform val = EnsureCraftingSocketWarning(gui);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)_craftingSocketWarningText == (Object)null))
			{
				Vector2 val2 = GetCraftingGridCellPosition(grid, 0, 9) + CraftingBottomControlsFixedOffset;
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(568f, 58f);
				string text = $"{((Object)gui.m_crafting).GetInstanceID()}|{((Object)grid).GetInstanceID()}|{val2.x:0.###}|{val2.y:0.###}|{val3.x:0.###}|{val3.y:0.###}|{craftingStatusHudText}";
				if (updateLayout || !string.Equals(_craftingSocketWarningSignature, text, StringComparison.Ordinal))
				{
					SetCraftingTopLeftRect(gui.m_crafting, val, val2, val3);
					ConfigureCraftingSocketWarningText(_craftingSocketWarningText, craftingStatusHudText);
					_craftingSocketWarningSignature = text;
				}
				((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_0093: 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_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)_craftingSocketWarningRect != (Object)null && !IsUnityNull((Object?)(object)_craftingSocketWarningRect) && (Object)(object)((Transform)_craftingSocketWarningRect).parent == (Object)(object)gui.m_crafting)
			{
				return _craftingSocketWarningRect;
			}
			Transform val = ((Transform)gui.m_crafting).Find("InventorySlots_CraftingSocketWarning");
			_craftingSocketWarningRect = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)_craftingSocketWarningRect == (Object)null)
			{
				_craftingSocketWarningRect = new GameObject("InventorySlots_CraftingSocketWarning", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			}
			((Transform)_craftingSocketWarningRect).SetParent((Transform)(object)gui.m_crafting, false);
			Image val2 = default(Image);
			if (((Component)_craftingSocketWarningRect).TryGetComponent<Image>(ref val2))
			{
				((Behaviour)val2).enabled = false;
				((Graphic)val2).raycastTarget = false;
			}
			Transform val3 = ((Transform)_craftingSocketWarningRect).Find("Text");
			RectTransform rect;
			if ((Object)(object)val3 != (Object)null)
			{
				TMP_Text component = ((Component)val3).GetComponent<TMP_Text>();
				if (component != null)
				{
					rect = (RectTransform)val3;
					_craftingSocketWarningText = component;
					goto IL_011a;
				}
			}
			rect = CreateTextRect("Text", (Transform)(object)_craftingSocketWarningRect, out _craftingSocketWarningText);
			goto IL_011a;
			IL_011a:
			SetStretchRectLayoutCached(rect, new Vector2(12f, 5f), new Vector2(-12f, -5f), "crafting-socket-warning-text");
			ConfigureCraftingSocketWarningText(_craftingSocketWarningText, _craftingSocketWarningText.text);
			return _craftingSocketWarningRect;
		}

		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)_craftingSocketWarningRect != (Object)null && !IsUnityNull((Object?)(object)_craftingSocketWarningRect))
			{
				((Component)_craftingSocketWarningRect).gameObject.SetActive(false);
			}
			_craftingSocketWarningSignature = "";
		}

		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_01a2: 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);
				SetStretchRectLayoutCached(component2, new Vector2(22f, 3f), new Vector2(-4f, -3f), "crafting-count-input-viewport");
				_craftingCountInputViewport = component2;
				SetStretchRectLayoutCached(CreateTextRect("Text", (Transform)(object)component2, out TMP_Text text), Vector2.zero, Vector2.zero, "crafting-count-input-text");
				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>();
				TMP_InputField? craftingCountInput = _craftingCountInput;
				_craftingCountInputViewport = ((craftingCountInput != null) ? craftingCountInput.textViewport : null);
				if ((Object)(object)_craftingCountInputViewport == (Object)null || IsUnityNull((Object?)(object)_craftingCountInputViewport))
				{
					Transform obj = ((Transform)_craftingCountInputRect).Find("Text Area");
					_craftingCountInputViewport = (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_0119: 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_016f: 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;
				SetStretchRectLayoutCached(CreateTextRect("Text", (Transform)(object)_craftingUpgradeProgressionRect, out _craftingUpgradeProgressionText), new Vector2(4f, 3f), new Vector2(-4f, -3f), "crafting-upgrade-progression-text");
				_craftingUpgradeProgressionText.fontSize = 20f;
				_craftingUpgradeProgressionText.alignment = (TextAlignmentOptions)514;
				((Graphic)_craftingUpgradeProgressionText).color = new Color(1f, 0.84f, 0.42f, 1f);
				_craftingUpgradeProgressionText.textWrappingMode = (TextWrappingModes)0;
				_craftingUpgradeProgressionText.overflowMode = (TextOverflowModes)0;
				((Graphic)_craftingUpgradeProgressionText).raycastTarget = false;
			}
			else
			{
				Transform obj = ((Transform)_craftingUpgradeProgressionRect).Find("Text");
				_craftingUpgradeProgressionText = ((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)_craftingUpgradeProgressionText != (Object)null)
			{
				string text2 = $"{text}|{_craftingUpgradeProgressionText.fontSizeMax:0.###}";
				CraftingTextCacheState craftingTextCache = GetCraftingTextCache(((Component)_craftingUpgradeProgressionRect).gameObject);
				if (!string.Equals(craftingTextCache.LastTextSignature, text2, StringComparison.Ordinal))
				{
					ApplyDefaultFontAsset(_craftingUpgradeProgressionText);
					_craftingUpgradeProgressionText.text = text;
					_craftingUpgradeProgressionText.enableAutoSizing = true;
					_craftingUpgradeProgressionText.fontSizeMin = 10f;
					_craftingUpgradeProgressionText.fontSizeMax = 20f;
					craftingTextCache.LastTextSignature = text2;
				}
			}
			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_0149: 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)
			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 = _craftingCountInputViewport;
			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 = (_craftingCountInputViewport = (RectTransform?)(object)((obj2 is RectTransform) ? obj2 : null));
			}
			if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val))
			{
				SetStretchRectLayoutCached(val, new Vector2(22f, 3f), new Vector2(-4f, -3f), "crafting-count-input-viewport");
			}
		}

		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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_014a: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: 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);
			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 = requiredStationLevel.ToString();
			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 flag2 = (Object)(object)val4 == (Object)null || val4.GetLevel(true) < requiredStationLevel;
			((Graphic)gui.m_minStationLevelText).color = ((flag2 && !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, GetCraftingStationDisplayName(requiredStation), enabled: true);
			}
		}

		private static RectTransform? EnsureCraftingRequiredStationLevelHitbox(InventoryGui gui, Vector2 iconPosition, float iconSize)
		{
			//IL_0086: 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_00a1: 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)gui.m_crafting == (Object)null)
			{
				return null;
			}
			RectTransform val = _craftingRequiredStationLevelHitbox;
			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>();
				}
				_craftingRequiredStationLevelHitbox = 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 craftingRequiredStationLevelHitbox = _craftingRequiredStationLevelHitbox;
			if ((Object)(object)craftingRequiredStationLevelHitbox == (Object)null || IsUnityNull((Object?)(object)craftingRequiredStationLevelHitbox))
			{
				_craftingRequiredStationLevelHitbox = null;
				return;
			}
			ConfigureSimpleTooltip(((Component)craftingRequiredStationLevelHitbox).gameObject, "", enabled: false);
			((Component)craftingRequiredStationLevelHitbox).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)_craftingRequiredStationLevelOriginalRoot == (Object)null || IsUnityNull((Object?)(object)_craftingRequiredStationLevelOriginalRoot))
			{
				_craftingRequiredStationLevelOriginalRoot = FindCraftingRequiredStationLevelOriginalRoot(gui, iconRect, textRect);
			}
			Transform craftingRequiredStationLevelOriginalRoot = _craftingRequiredStationLevelOriginalRoot;
			if ((Object)(object)craftingRequiredStationLevelOriginalRoot == (Object)null || IsUnityNull((Object?)(object)craftingRequiredStationLevelOriginalRoot) || (Object)(object)craftingRequiredStationLevelOriginalRoot == (Object)(object)gui.m_crafting || !craftingRequiredStationLevelOriginalRoot.IsChildOf((Transform)(object)gui.m_crafting))
			{
				_craftingRequiredStationLevelOriginalRoot = FindCraftingRequiredStationLevelOriginalRoot(gui, iconRect, textRect);
				craftingRequiredStationLevelOriginalRoot = _craftingRequiredStationLevelOriginalRoot;
				if ((Object)(object)craftingRequiredStationLevelOriginalRoot == (Object)null || IsUnityNull((Object?)(object)craftingRequiredStationLevelOriginalRoot) || (Object)(object)craftingRequiredStationLevelOriginalRoot == (Object)(object)gui.m_crafting || !craftingRequiredStationLevelOriginalRoot.IsChildOf((Transform)(object)gui.m_crafting))
				{
					_craftingRequiredStationLevelOriginalRoot = null;
					return;
				}
			}
			Image[] componentsInChildren = ((Component)craftingRequiredStationLevelOriginalRoot).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);
			string text2 = "craft|" + text + "|" + craftingTextCache.ChildSignature;
			if (string.Equals(craftingTextCache.LastTextSignature, text2, StringComparison.Ordinal) && 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.LastTextSignature = text2;
			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_002a: 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_0054: 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_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_00be: 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_00ff: 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)
			Color craftingActionButtonTextStateColor = GetCraftingActionButtonTextStateColor(button, interactable);
			CraftingTextCacheState craftingTextCache = GetCraftingTextCache(((Component)button).gameObject);
			string text = $"{interactable}|{craftingActionButtonTextStateColor.r:0.###}|{craftingActionButtonTextStateColor.g:0.###}|{craftingActionButtonTextStateColor.b:0.###}|{craftingActionButtonTextStateColor.a:0.###}|{craftingTextCache.ChildSignature}";
			if (string.Equals(craftingTextCache.LastColorSignature, text, StringComparison.Ordinal) && 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.LastColorSignature = text;
		}

		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);
			}
			string text2 = "progress|" + text + "|" + craftingProgressTextCache.ChildSignature;
			if (string.Equals(craftingProgressTextCache.LastTextSignature, text2, StringComparison.Ordinal) && 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.LastTextSignature = text2;
		}

		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 (_craftingQueueTotal > 1 && (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)(object)_craftingQueueRecipe && gui.m_selectedVariant == _craftingQueueVariant)
			{
				int num = ((gui.m_craftTimer >= 0f) ? 1 : 0);
				count = Mathf.Clamp(_craftingQueueRemaining + num, 1, _craftingQueueTotal);
				return true;
			}
			if (gui.m_multiCrafting && gui.m_multiCraftAmount > 1)
			{
				count = Mathf.Clamp(gui.m_multiCraftAmount, 1, 99);
				return true;
			}
			if (_craftingProgressLabelCount > 1 && (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)(object)_craftingProgressLabelRecipe && gui.m_selectedVariant == _craftingProgressLabelVariant)
			{
				count = Mathf.Clamp(_craftingProgressLabelCount, 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.LastTextSignature = "";
				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 (!string.IsNullOrEmpty(craftingTooltipState.Signature) || !((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.Signature = "";
				}
			}
			else
			{
				if ((Object)(object)component != (Object)null)
				{
					component.m_topic = "";
					component.m_text = "";
					((Behaviour)component).enabled = false;
				}
				string text2 = topic + "|" + text;
				if (!string.Equals(craftingTooltipState.Signature, text2, StringComparison.Ordinal))
				{
					(target.GetComponent<InventorySlotsSimpleTooltipHover>() ?? target.AddComponent<InventorySlotsSimpleTooltipHover>()).Configure(topic, text);
					craftingTooltipState.Signature = text2;
				}
			}
		}

		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.LastTextSignature = "";
			craftingTextCacheState.LastColorSignature = "";
			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 (_craftingQueueRemaining <= 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_00a4: 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_00d0: 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_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_01bb: 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_01e7: 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_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: 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_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: 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);
			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 = Color.white;
					((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 availableCraftingRequirementAmount = GetAvailableCraftingRequirementAmount(requirement);
					bool availableEnough = HasNoCraftCost() || availableCraftingRequirementAmount >= num;
					string text2 = FormatCompactRequirementAmount(availableCraftingRequirementAmount, num);
					Color compactRequirementAmountColor = GetCompactRequirementAmountColor(availableEnough);
					string text3 = $"{text2}|{compactRequirementAmountColor}";
					if (!string.Equals(craftingRequirementUiMarker.AmountSignature, text3, StringComparison.Ordinal) || !RequirementAmountTextMatches(amountText, text2, compactRequirementAmountColor))
					{
						ApplyDefaultFontAsset(amountText);
						amountText.text = text2;
						((Graphic)amountText).color = compactRequirementAmountColor;
						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 val = EnsureCraftingRequirementHitbox(rect, craftingRequirementUiMarker);
			DisableCompetingCraftingRequirementTooltips(rect, val, craftingRequirementUiMarker);
			ConfigureCraftingRequirementTooltip(gui, ((Component)val).gameObject, requirement, quality, craftMultiplier);
			craftingRequirementUiMarker.LayoutSignature = text;
		}

		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 BindCraftingClientConfigs()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0045: 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_0064: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			_craftingRecipeGridSize = OrderedConfigEntry("3 - Client", "Crafting Recipe Grid Size", 6, new ConfigDescription("Recipe icon grid size inside the fixed 8x8 recipe area. 8 means 8x8 small icons; 4 means 4x4 large icons.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(4, 8), Array.Empty<object>()), 590, synchronizedSetting: false);
			_craftingRecipeGridZoomModifier = ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false);
			_craftingClearFavoritesKey = ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false);
			_showCraftingRecipeGridZoomHint = OrderedConfigEntry("3 - Client", "Show Crafting Recipe Grid Zoom Hint", Toggle.On, "Show the Alt + mouse wheel hint above the crafting recipe grid. Not synced with server.", 580, synchronizedSetting: false);
			_craftingRecipeGridSize.SettingChanged += delegate
			{
				InvalidateCraftingRecipeGridLayout();
				InvalidateCraftingRecipeGridZoomHint();
			};
			_craftingRecipeGridZoomModifier.SettingChanged += delegate
			{
				InvalidateCraftingRecipeGridZoomHint();
			};
			_craftingClearFavoritesKey.SettingChanged += delegate
			{
				MarkCraftingGroupRailDirty();
			};
			_showCraftingRecipeGridZoomHint.SettingChanged += delegate
			{
				InvalidateCraftingRecipeGridZoomHint();
			};
			_craftingRecipeSortMode = OrderedConfigEntry("3 - Client", "Crafting Recipe Sort Mode", CraftingRecipeSortMode.TierThenGroup, "Sorting mode used by crafting station recipe grids. Crafting still keeps favorites and craftable recipes first. TierThenGroup sorts biome/resource tier first, then predefined group. GroupThenTier sorts predefined group first, then biome/resource tier.", 530, synchronizedSetting: false);
			_craftingRecipeSortMode.SettingChanged += delegate
			{
				_craftingSortModeButtonsSignature = "";
				InvalidateCraftingRecipeView();
			};
			_craftingRecipeCraftableBackgroundColor = OrderedConfigEntry<Color>("3 - Client", "Craftable Recipe Background Color", CraftingRecipeDefaultCraftableBackgroundColor, "Advanced color for recipe grid cells that can currently be crafted. Not synced with server.", 510, synchronizedSetting: false);
			_craftingRecipeCraftableBackgroundColor.SettingChanged += delegate
			{
				InvalidateCraftingRecipeGridLayout();
			};
		}

		private static bool TryToggleCraftingRecipeFavorite(int originalIndex)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (IsRecycleNReclaimReclaimTabActive(InventoryGui.instance))
			{
				return false;
			}
			if (!AreFavoritesEnabled() || !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();
			UpdateCraftingRecipeView(instance);
			EnsureSelectedCraftingRecipeVisible(instance);
			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 (!AreFavoritesEnabled() || (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_0021: 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 (!AreFavoritesEnabled())
			{
				return false;
			}
			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 (!AreFavoritesEnabled() || (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;
			}
			string craftingFrameFastPathSignature = GetCraftingFrameFastPathSignature(gui, adapter);
			if (!string.Equals(_craftingFrameFastPathSignature, craftingFrameFastPathSignature, StringComparison.Ordinal))
			{
				_craftingFrameFastPathSignature = craftingFrameFastPathSignature;
				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) && !HasCraftingPanelRebuildWork() && !CraftingUi.SearchInputDirty && (Object)(object)_craftingQueueRecipe == (Object)null)
			{
				return !_continuingCraftingQueue;
			}
			return false;
		}

		private static bool HasCraftingPanelRebuildWork()
		{
			if (!_craftingRecipeViewDirty && !_craftingRecipeGridDirty && !_craftingRecipeScrollbarDirty && !_craftingGroupRailDirty)
			{
				return _craftingBottomControlsDirty;
			}
			return true;
		}

		private static bool HandleCraftingPanelFastPathInput(InventoryGui gui, RectTransform grid)
		{
			if (HandleCraftingCountWheel())
			{
				MarkCraftingBottomControlsDirty();
				return true;
			}
			HandleCraftingGroupFavoriteClearShortcut();
			if (HasCraftingPanelRebuildWork())
			{
				return true;
			}
			if (!HandleCraftingPinnedTooltipWheel() && !HandleCraftingHoverTooltipWheel() && !HandleCraftingRecipeGridZoomWheel(gui, grid) && !HandleCraftingRecipeGridWheel(gui, grid))
			{
				return HasCraftingPanelRebuildWork();
			}
			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) || HasCraftingPanelRebuildWork() || CraftingUi.SearchInputDirty || (Object)(object)_craftingQueueRecipe != (Object)null || _continuingCraftingQueue)
			{
				_craftingFrameFastPathSignature = "";
			}
			else
			{
				_craftingFrameFastPathSignature = GetCraftingFrameFastPathSignature(gui, adapter);
			}
		}

		private static string GetCraftingFrameFastPathSignature(InventoryGui gui, CraftingTabAdapterState adapter)
		{
			InventoryGui gui2 = gui;
			RectTransform craftingRecipeGrid = _craftingRecipeGrid;
			int selectedCraftingRecipeIndexSafe = GetSelectedCraftingRecipeIndexSafe(gui2);
			return string.Join("|", ((Object)gui2).GetInstanceID(), ((Object)(object)gui2.m_crafting != (Object)null && !IsUnityNull((Object?)(object)gui2.m_crafting)) ? ((Object)gui2.m_crafting).GetInstanceID().ToString() : "0", ((Object)(object)craftingRecipeGrid != (Object)null && !IsUnityNull((Object?)(object)craftingRecipeGrid)) ? ((Object)craftingRecipeGrid).GetInstanceID().ToString() : "0", adapter.Kind.ToString(), SafeReadBool(() => gui2.InCraftTab()), SafeReadBool(() => gui2.InUpradeTab()), GetCraftingRecipeViewSignature(gui2), selectedCraftingRecipeIndexSafe.ToString(), _craftingRecipePage.ToString(), GetCraftingRecipeGridDimension().ToString(), CraftingRequirements.AvailabilityVersion.ToString(), HasNoCraftCost().ToString(), GetCraftingPinnedTooltipGridSignature(), _craftingRecipeVariantVersion.ToString(), _craftingFavoritesVersion.ToString(), _selectedCraftingGroupId, _craftingSearchQuery, CraftingController.HoveredRecipeIndex.ToString(), Screen.width.ToString(), Screen.height.ToString());
		}

		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)
		{
			if (IsCraftingRecipeGridZoomModifierHeld())
			{
				return false;
			}
			int craftingRecipePageCount = GetCraftingRecipePageCount(gui);
			bool flag = IsCraftingRecipeGridScrollTargetActive(grid);
			float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Discrete);
			if (craftingRecipePageCount <= 1 || !flag)
			{
				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.ClearHoveredRecipe();
			InvalidateCraftingRecipeGridLayout();
			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)
		{
			bool num = IsCraftingRecipeGridScrollTargetActive(grid);
			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);
			InvalidateCraftingRecipeGridLayout();
			MarkCraftingRecipeScrollbarDirty();
			CraftingController.ClearHoveredRecipe();
			return true;
		}

		private static bool IsCraftingRecipeGridScrollTargetActive(RectTransform grid)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (!RectContainsCraftingRecipeIconArea(grid, GetUiMousePosition()))
			{
				return IsGamepadUiScrollActive();
			}
			return true;
		}

		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 InvalidateCraftingRecipeGridZoomHint()
		{
			CraftingController.InvalidateRecipeGridZoomHint();
		}

		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_0140: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: 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_01fa: 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_021a: 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_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: 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_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			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))
					{
						CraftingController.InvalidateRecipeGridZoomHint();
						SetHintActive(CraftingUi.RecipeGridZoomHint, active: false);
						return;
					}
					CraftingUi.RecipeGridZoomHint = EnsureInventoryHintLabel(gui.m_crafting, "InventorySlots_CraftingRecipeGridZoomHint", ref CraftingUi.RecipeGridZoomHintText);
					if ((Object)(object)CraftingUi.RecipeGridZoomHint == (Object)null || (Object)(object)CraftingUi.RecipeGridZoomHintText == (Object)null)
					{
						return;
					}
					float num = 16f;
					float num2 = Mathf.Clamp(num * 1.35f, 14f, 42f);
					float num3 = Mathf.Max(10f, num2 * 0.72f);
					float num4 = 16f;
					string text = craftingRecipeGridZoomModifierDisplayText + "+";
					float num5 = Mathf.Max(num2, num * 1.45f);
					float num6 = Mathf.Ceil(Mathf.Max(num * 1.4f, CraftingUi.RecipeGridZoomHintText.GetPreferredValues(text, 1000f, num2).x + 1f));
					float num7 = num6 + num4 + num3;
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(num7, num5);
					Vector2 craftingRecipeGridZoomHintPosition = GetCraftingRecipeGridZoomHintPosition(grid, val);
					string text2 = $"v2|{((Object)gui.m_crafting).GetInstanceID()}|{((Object)grid).GetInstanceID()}|{grid.anchoredPosition.x:0.###}|{grid.anchoredPosition.y:0.###}|{text}|{num:0.###}|{num3:0.###}|{num2:0.###}|{num4:0.###}|{craftingRecipeGridZoomHintPosition.x:0.###}|{craftingRecipeGridZoomHintPosition.y:0.###}|{InventoryWheelHintColor}";
					if (((Component)CraftingUi.RecipeGridZoomHint).gameObject.activeSelf && string.Equals(CraftingUi.RecipeGridZoomHintSignature, text2, StringComparison.Ordinal) && (Object)(object)((Transform)CraftingUi.RecipeGridZoomHint).parent == (Object)(object)gui.m_crafting && RectLayoutMatches(CraftingUi.RecipeGridZoomHint, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), craftingRecipeGridZoomHintPosition, val))
					{
						((Transform)CraftingUi.RecipeGridZoomHint).SetAsLastSibling();
						return;
					}
					CraftingUi.RecipeGridZoomHintText.text = text;
					CraftingUi.RecipeGridZoomHintText.fontSize = num;
					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, craftingRecipeGridZoomHintPosition, val);
					((Transform)CraftingUi.RecipeGridZoomHint).SetAsLastSibling();
					RectTransform val2 = (RectTransform)CraftingUi.RecipeGridZoomHintText.transform;
					if ((Object)(object)val2 != (Object)(object)CraftingUi.RecipeGridZoomHint)
					{
						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;
					}
					CraftingUi.RecipeGridZoomHintText.alignment = (TextAlignmentOptions)513;
					CraftingUi.RecipeGridZoomHintText.textWrappingMode = (TextWrappingModes)0;
					CraftingUi.RecipeGridZoomHintText.overflowMode = (TextOverflowModes)0;
					((Graphic)CraftingUi.RecipeGridZoomHintText).color = InventoryWheelHintColor;
					((Graphic)CraftingUi.RecipeGridZoomHintText).raycastTarget = false;
					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;
					CraftingUi.RecipeGridZoomHintSignature = text2;
					SetHintActive(CraftingUi.RecipeGridZoomHint, active: true);
					return;
				}
			}
			CraftingController.InvalidateRecipeGridZoomHint();
			SetHintActive(CraftingUi.RecipeGridZoomHint, active: false);
		}

		private static Vector2 GetCraftingRecipeGridZoomHintPosition(RectTransform grid, Vector2 size)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return CraftingRecipeGridZoomHintFixedOffset;
		}

		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.Replace("LeftAlt", "Alt").Replace("RightAlt", "Alt").Replace("LeftControl", "Ctrl")
				.Replace("RightControl", "Ctrl")
				.Replace("LeftShift", "Shift")
				.Replace("RightShift", "Shift")
				.Replace("Left Alt", "Alt")
				.Replace("Right Alt", "Alt")
				.Replace("Left Control", "Ctrl")
				.Replace("Right Control", "Ctrl")
				.Replace("Left Shift", "Shift")
				.Replace("Right Shift", "Shift")
				.Replace(" + ", "+")
				.Replace("+ ", "+")
				.Replace(" +", "+");
		}

		private static void SyncCraftingRecipePageToSelected(InventoryGui gui)
		{
			int selectedRecipeIndex = gui.GetSelectedRecipeIndex(false);
			if (selectedRecipeIndex < 0)
			{
				int craftingRecipePage = _craftingRecipePage;
				_craftingRecipePage = 0;
				if (_craftingRecipePage != craftingRecipePage)
				{
					InvalidateCraftingRecipeGridLayout();
				}
				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)
			{
				InvalidateCraftingRecipeGridLayout();
			}
		}

		private static void ClampCraftingRecipePage(InventoryGui gui)
		{
			int craftingRecipePage = _craftingRecipePage;
			_craftingRecipePage = Mathf.Clamp(_craftingRecipePage, 0, Mathf.Max(0, GetCraftingRecipePageCount(gui) - 1));
			if (_craftingRecipePage != craftingRecipePage)
			{
				InvalidateCraftingRecipeGridLayout();
			}
		}

		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_00fd: 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);
			string text = $"{craftingRecipeGridDimension}|{num}|{selectedRecipeIndex}|{craftingRecipeGridAvailabilityHash}|{GetCraftingPinnedTooltipGridSignature()}|{CraftingRecipes.View.Count}|{_craftingRecipeVariantVersion}";
			if (!_craftingRecipeGridDirty && string.Equals(_craftingRecipeGridSignature, text, StringComparison.Ordinal))
			{
				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);
			}
			_craftingRecipeGridSignature = text;
			_craftingRecipeGridDirty = false;
		}

		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_0119: 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_00d8: 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_0162: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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)
			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 = IsCraftingRecipeActionAvailable(gui, pair, index);
				((Graphic)cell.Background).raycastTarget = true;
				((Graphic)cell.Background).color = (craftingSelected ? CraftingRecipeSelectedBackgroundColor : (flag ? GetCraftingRecipeCraftableBackgroundColor() : CraftingRecipeUnavailableBackgroundColor));
			}
			ConfigureCraftingRecipeCellIcon(cell.Icon, pair, craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeCellAmountText(cell.Amount, GetCraftingRecipeCellAmountText(gui, pair), craftingRecipeDynamicCellSize);
			ConfigureCraftingRecipeCellQualityText(cell.Quality, (((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.Food, active: false);
			SetCraftingRecipeCellChild(cell.Durability, active: false);
			SetCraftingRecipeFavoriteBorder(cell, IsFavoriteCraftingRecipe(pair), IsUpgradeFavoritePair(pair));
			SetCraftingRecipeSelectedBorder(cell, active: false);
			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 component4 = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					SetCraftingRecipeHover(component4?.Index ?? (-1), component4?.Tooltip);
				});
				input.m_onPointerExit = (Action<UIInputHandler>)Delegate.Combine(input.m_onPointerExit, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					CraftingRecipeGridMarker component3 = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					ClearCraftingRecipeHover(component3?.Index ?? (-1), component3?.Tooltip);
				});
				input.m_onLeftClick = (Action<UIInputHandler>)Delegate.Combine(input.m_onLeftClick, (Action<UIInputHandler>)delegate(UIInputHandler handler)
				{
					CraftingRecipeGridMarker component2 = ((Component)handler).GetComponent<CraftingRecipeGridMarker>();
					int num4 = component2?.Index ?? (-1);
					ClearCraftingRecipeHover(num4, component2?.Tooltip);
					if (!TryToggleCraftingRecipeFavorite(num4))
					{
						SelectCraftingRecipeFromGrid(num4);
					}
				});
				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_0001: Unknown result type (might be due to invalid IL or missing references)
			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 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_0007: Unknown result type (might be due to invalid IL or missing references)
			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_00dd: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0135: 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 "foodicon":
					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_011a: 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)
			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)(((RecipeDataPair)(ref pair)).CanCraft ? Color.white : new Color(0.68f, 0.68f, 0.68f, 0.72f));
					((Graphic)icon).raycastTarget = false;
				}
			}
		}

		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_0074: 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_009e: 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_00c5: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: 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_01f4: 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;
			((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);
					InvalidateCraftingRecipeGridLayout();
					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 SetCraftingRecipeSelectedBorder(CraftingRecipeGridCell cell, bool active)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			object obj2;
			if (!active)
			{
				if ((Object)(object)cell.Rect != (Object)null && !IsUnityNull((Object?)(object)cell.Rect))
				{
					Transform obj = ((Transform)cell.Rect).Find("InventorySlots_CraftingSelectedRecipeBorder");
					RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
					if (val != null)
					{
						obj2 = val;
						goto IL_0043;
					}
				}
				obj2 = null;
			}
			else
			{
				obj2 = EnsureCraftingRecipeSelectedBorder(cell);
			}
			goto IL_0043;
			IL_0043:
			RectTransform val2 = (RectTransform)obj2;
			if (!((Object)(object)val2 == (Object)null))
			{
				Image[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Image>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Graphic)componentsInChildren[i]).color = new Color(1f, 1f, 1f, 0.98f);
				}
				((Component)val2).gameObject.SetActive(active);
				if (active)
				{
					((Transform)val2).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? EnsureCraftingRecipeSelectedBorder(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_CraftingSelectedRecipeBorder");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				return val;
			}
			GameObject val2 = new GameObject("InventorySlots_CraftingSelectedRecipeBorder", 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 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_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetLocalPointInRect(grid, screenPoint, out var localPoint))
			{
				return false;
			}
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(0f, -576f, 576f, 576f);
			return ((Rect)(ref val)).Contains(localPoint);
		}

		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_00a8: 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);
				num = num * 31 + (IsCraftingRecipeActionAvailable(gui, pair, originalIndex) ? 1 : 0);
				if (IsRecycleNReclaimReclaimTabActive(gui) && TryGetRecycleNReclaimRecyclingImpedimentCount(originalIndex, out var count))
				{
					num = num * 31 + count;
				}
			}
			return num;
		}

		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)
		{
			RectTransform rect2 = rect;
			return (from image in ((Component)rect2).GetComponentsInChildren<Image>(true)
				where IsCraftingRequirementBackgroundImage(rect2, 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_00cc: 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;
			SetStretchRectLayoutCached(val2, Vector2.zero, Vector2.zero, "crafting-requirement-hitbox");
			((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)
		{
			if (!((Object)(object)target == (Object)null) && !IsUnityNull((Object?)(object)target) && !((Object)(object)requirement.m_resItem == (Object)null))
			{
				ConfigureSimpleTooltip(target, GetRequirementDisplayName(requirement), enabled: true);
			}
		}

		private static void DisableCompetingCraftingRequirementTooltips(RectTransform root, RectTransform allowed, CraftingRequirementUiMarker marker)
		{
			RectTransform allowed2 = allowed;
			string text = $"{((Transform)root).childCount}|{((Object)allowed2).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)allowed2
					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.Signature = "";
					}
				}
			}
		}

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

		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);
				UpdateCraftingSearchInput(gui, val);
				UpdateCraftingSortModeButtons(gui, val);
				if (craftingTabAdapterState.UsesDefaultGroupRail)
				{
					UpdateCraftingGroupRail(gui, val);
				}
				else
				{
					HideCraftingGroupRail();
				}
				HandleCraftingGroupFavoriteClearShortcut();
				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_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_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)
			//IL_008b: 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;
		}

		[IteratorStateMachine(typeof(<FindCraftingPanelResizeProtectedChildren>d__511))]
		private static IEnumerable<RectTransform> FindCraftingPanelResizeProtectedChildren(InventoryGui gui)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindCraftingPanelResizeProtectedChildren>d__511(-2)
			{
				<>3__gui = gui
			};
		}

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

		internal static void InvalidateCraftingRecipeView()
		{
			CraftingController.MarkRecipeViewDirtyCascade();
		}

		internal static void ClearCraftingRecipeCaches()
		{
			CraftingRecipes.SearchTextCache.Clear();
			CraftingRecipes.HoverTooltipContentCache.Clear();
			CraftingController.ClearHoverTooltipContentKey();
			CraftingRecipes.SortKeyCache.Clear();
			CraftingRecipes.GroupMatchCache.Clear();
			ClearInventorySortCaches();
			ClearItemClassifierCaches();
			ClearCraftingRequirementAvailabilityCache();
			ClearCraftingGroupAvailabilityCache();
			ClearRecycleNReclaimSignatureCaches();
		}

		private static void InvalidateCraftingRecipeGridLayout()
		{
			CraftingController.MarkRecipeGridLayoutDirty();
		}

		private static void MarkCraftingRecipeViewDirty()
		{
			CraftingController.MarkRecipeViewDirty();
		}

		private static void MarkCraftingRecipeGridDirty()
		{
			CraftingController.MarkRecipeGridDirty();
		}

		private static void MarkCraftingRecipeScrollbarDirty()
		{
			CraftingController.MarkRecipeScrollbarDirty();
		}

		private static void MarkCraftingGroupRailDirty()
		{
			CraftingController.MarkGroupRailDirty();
		}

		private static void MarkCraftingBottomControlsDirty()
		{
			CraftingController.MarkBottomControlsDirty();
		}

		private static void MarkCraftingSearchInputDirty()
		{
			CraftingController.MarkSearchInputDirty();
		}

		internal 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();
			_craftingRecipeListChangeSignature = "";
			_craftingSelectedRecipeChangeSignature = "";
			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);
			}
			InvalidateCraftingRecipeGridZoomHint();
			HideCraftingSocketWarning();
		}

		internal static void PrepareCraftingQueue(InventoryGui gui)
		{
			if (_continuingCraftingQueue)
			{
				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)
				{
					_craftingQueueRemaining = num2 - 1;
					_craftingQueueTotal = num2;
					_craftingQueueRecipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
					_craftingQueueVariant = gui.m_selectedVariant;
				}
			}
		}

		internal static void ValidateCraftingQueueStarted(InventoryGui gui)
		{
			if (!_continuingCraftingQueue && _craftingQueueRemaining > 0 && gui.m_craftTimer < 0f)
			{
				ClearCraftingQueue(clearProgressLabel: false);
			}
		}

		internal static void TryContinueCraftingQueue(InventoryGui gui)
		{
			if (_continuingCraftingQueue || _craftingQueueRemaining <= 0 || gui.m_craftTimer >= 0f)
			{
				return;
			}
			if (!CanContinueCraftingQueue(gui))
			{
				ClearCraftingQueue();
				return;
			}
			_craftingQueueRemaining--;
			_continuingCraftingQueue = 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;
				_continuingCraftingQueue = false;
			}
		}

		internal static void ClearCraftingQueue(bool clearProgressLabel = true)
		{
			_craftingQueueTotal = 0;
			_craftingQueueRemaining = 0;
			_craftingQueueRecipe = null;
			_craftingQueueVariant = 0;
			if (clearProgressLabel)
			{
				ClearCraftingProgressLabelCount();
			}
		}

		private static void UpdateCraftingQueueLifecycle(InventoryGui gui)
		{
			UpdateCraftingProgressLabelLifecycle(gui);
			if (!((Object)(object)_craftingQueueRecipe == (Object)null))
			{
				if ((Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe != (Object)(object)_craftingQueueRecipe || ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null || gui.m_selectedVariant != _craftingQueueVariant)
				{
					ClearCraftingQueue();
				}
				else if (_craftingQueueRemaining <= 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;
			}
			_craftingProgressLabelCount = Mathf.Clamp(count, 1, 99);
			_craftingProgressLabelRecipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			_craftingProgressLabelVariant = gui.m_selectedVariant;
		}

		private static void ClearCraftingProgressLabelCount()
		{
			_craftingProgressLabelCount = 0;
			_craftingProgressLabelRecipe = null;
			_craftingProgressLabelVariant = 0;
		}

		private static void UpdateCraftingProgressLabelLifecycle(InventoryGui gui)
		{
			if (!((Object)(object)_craftingProgressLabelRecipe == (Object)null))
			{
				bool num = (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe == (Object)(object)_craftingProgressLabelRecipe && ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null && gui.m_selectedVariant == _craftingProgressLabelVariant;
				bool flag = (Object)(object)_craftingQueueRecipe == (Object)(object)_craftingProgressLabelRecipe && _craftingQueueRemaining > 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 IsCraftingRedesignTab(InventoryGui gui)
		{
			return GetCraftingTabAdapterState(gui).IsRedesign;
		}

		private static bool IsForeignCraftingTab(InventoryGui? gui)
		{
			return GetCraftingTabAdapterState(gui).IsForeign;
		}

		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_00c1: 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 || _craftingRecipeGridCellCapacity != 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);
			}
			_craftingRecipeGridLayoutSignature = "";
			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_0048: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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(_craftingRecipeGridLayoutSignature, 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();
				_craftingRecipeGridLayoutSignature = 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 num = (_craftingRecipeGridCellCapacity = GetCraftingRecipeGridCapacity());
			for (int num2 = CraftingRecipes.GridCells.Count - 1; num2 >= 0; num2--)
			{
				CraftingRecipeGridCell craftingRecipeGridCell = CraftingRecipes.GridCells[num2];
				if ((Object)(object)craftingRecipeGridCell.Rect == (Object)null || IsUnityNull((Object?)(object)craftingRecipeGridCell.Rect) || (Object)(object)((Transform)craftingRecipeGridCell.Rect).parent != (Object)(object)grid)
				{
					CraftingRecipes.GridCells.RemoveAt(num2);
				}
			}
			for (int i = CraftingRecipes.GridCells.Count; i < num; i++)
			{
				CraftingRecipes.GridCells.Add(CreateCraftingRecipeCell(gui, grid, i));
			}
			while (CraftingRecipes.GridCells.Count > num)
			{
				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_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			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("foodicon", val.transform, new Color(0.2f, 0.85f, 0.35f, 0.35f), active: false);
			CreateCleanCraftingOverlay("durability", val.transform, new Color(0.08f, 0.02f, 0.02f, 0.55f), active: false);
			((Graphic)((Component)CreateCleanCraftingImageChild("icon", val.transform, Color.white, active: true)).GetComponent<Image>()).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 = CreateCleanCraftingImageChild(name, parent, color, active);
			Image component = ((Component)obj).GetComponent<Image>();
			component.sprite = GetSolidUiSprite();
			((Graphic)component).raycastTarget = false;
			return obj;
		}

		private static RectTransform CreateCleanCraftingImageChild(string name, Transform parent, Color color, bool active)
		{
			//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 = false;
			val.SetActive(active);
			return component;
		}

		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 void UpdateCraftingGroupRail(InventoryGui gui, RectTransform grid)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d4: 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_00ec: 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_0128: 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_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_0195: 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_01d7: 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)
			RectTransform val = EnsureCraftingGroupRail(gui);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			IReadOnlyList<CraftingRecipeGroupFilter> selectableCraftingGroupFilters = GetSelectableCraftingGroupFilters(gui);
			string craftingGroupRailSignature = GetCraftingGroupRailSignature(gui, grid, selectableCraftingGroupFilters);
			if (!_craftingGroupRailDirty && string.Equals(_craftingGroupRailSignature, craftingGroupRailSignature, StringComparison.Ordinal))
			{
				return;
			}
			if (!string.IsNullOrEmpty(_selectedCraftingGroupId) && selectableCraftingGroupFilters.All((CraftingRecipeGroupFilter filter) => filter.Id != _selectedCraftingGroupId))
			{
				_selectedCraftingGroupId = "";
				_craftingRecipePage = 0;
				CraftingController.ClearHoveredRecipe();
				InvalidateCraftingRecipeView();
				selectableCraftingGroupFilters = GetSelectableCraftingGroupFilters(gui);
				craftingGroupRailSignature = GetCraftingGroupRailSignature(gui, grid, selectableCraftingGroupFilters);
			}
			if (selectableCraftingGroupFilters.Count == 0)
			{
				((Component)val).gameObject.SetActive(false);
				_craftingGroupRailSignature = craftingGroupRailSignature;
				_craftingGroupRailDirty = false;
				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 i = 0; i < selectableCraftingGroupFilters.Count; i++)
			{
				CraftingRecipeGroupFilter filter2 = selectableCraftingGroupFilters[i];
				CraftingRecipeGroupButton button = EnsureCraftingGroupButton(gui, craftingRecipeGroupPanel.Rect, i);
				bool hasRecipes = CraftingGroupHasRecipes(gui, filter2);
				ConfigureCraftingGroupButton(gui, button, filter2, i, x, x2, hasRecipes);
			}
			for (int j = 1; j < CraftingRecipes.GroupPanels.Count; j++)
			{
				RectTransform rect = CraftingRecipes.GroupPanels[j].Rect;
				if (!IsUnityNull((Object?)(object)rect))
				{
					((Component)rect).gameObject.SetActive(false);
				}
			}
			for (int k = selectableCraftingGroupFilters.Count; k < CraftingRecipes.GroupButtons.Count; k++)
			{
				GameObject go = CraftingRecipes.GroupButtons[k].Go;
				if (!IsUnityNull((Object?)(object)go))
				{
					go.SetActive(false);
				}
			}
			val.sizeDelta = new Vector2(x, y);
			_craftingGroupRailSignature = craftingGroupRailSignature;
			_craftingGroupRailDirty = false;
		}

		private static void HideCraftingGroupRail()
		{
			if ((Object)(object)_craftingGroupRail != (Object)null && !IsUnityNull((Object?)(object)_craftingGroupRail))
			{
				((Component)_craftingGroupRail).gameObject.SetActive(false);
			}
			_craftingGroupRailSignature = "";
			_craftingGroupRailDirty = true;
		}

		private static string GetCraftingGroupRailSignature(InventoryGui gui, RectTransform grid, IReadOnlyList<CraftingRecipeGroupFilter> filters)
		{
			//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.###}|{_selectedCraftingGroupId}|{_craftingFavoritesVersion}|{GetCraftingGroupIconBackgroundAlpha():0.###}|{_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_0013: Unknown result type (might be due to invalid IL or missing references)
			return JoinShortcutDisplayTexts((_craftingClearFavoritesKey != null) ? _craftingClearFavoritesKey.Value.GetDisplayText() : "Mouse-3", 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 void InvalidateCraftingGroupRailLayout()
		{
			MarkCraftingGroupRailDirty();
		}

		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))
				{
					UpdateCraftingRecipeView(instance);
					EnsureSelectedCraftingRecipeVisible(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();
				UpdateCraftingRecipeView(instance);
				EnsureSelectedCraftingRecipeVisible(instance);
				UpdateCraftingPanelRedesign(instance, CraftingPanelUpdateReason.StateChanged);
			}
		}

		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_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)
			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);
				string craftingSearchInputSignature = GetCraftingSearchInputSignature(gui, val, val2, size);
				((Component)val).gameObject.SetActive(true);
				if (((Transform)val).GetSiblingIndex() != ((Transform)val).parent.childCount - 1)
				{
					((Transform)val).SetAsLastSibling();
				}
				if (CraftingUi.SearchInputDirty || !string.Equals(CraftingUi.SearchInputSignature, craftingSearchInputSignature, StringComparison.Ordinal))
				{
					SetCraftingTopLeftRect(gui.m_crafting, val, val2, size);
					ConfigureCraftingSearchInputStyle(gui, val);
					CraftingUi.SearchInputSignature = craftingSearchInputSignature;
					CraftingUi.SearchInputDirty = false;
				}
			}
		}

		private static string GetCraftingSearchInputSignature(InventoryGui gui, RectTransform inputRect, Vector2 position, Vector2 size)
		{
			//IL_007e: 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_009a: 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)
			Image val = (((Object)(object)gui.m_tabCraft != (Object)null && !IsUnityNull((Object?)(object)gui.m_tabCraft)) ? ((Selectable)gui.m_tabCraft).image : null);
			bool flag = (Object)(object)CraftingUi.SearchInput != (Object)null && CraftingUi.SearchInput.isFocused;
			return $"{((Object)gui.m_crafting).GetInstanceID()}|{((Object)inputRect).GetInstanceID()}|{position.x:0.###}|{position.y:0.###}|{size.x:0.###}|{size.y:0.###}|{_craftingSearchQuery}|{_uiLocalizationVersion}|{flag}|{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);
				MarkCraftingSearchInputDirty();
				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>();
				MarkCraftingSearchInputDirty();
			}
			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_00dd: 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)
			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;
				string craftingSortModeButtonsSignature = GetCraftingSortModeButtonsSignature(gui, val, val3, size2, num);
				((Component)val).gameObject.SetActive(true);
				if (((Transform)val).GetSiblingIndex() != ((Transform)val).parent.childCount - 1)
				{
					((Transform)val).SetAsLastSibling();
				}
				if (!string.Equals(_craftingSortModeButtonsSignature, craftingSortModeButtonsSignature, StringComparison.Ordinal))
				{
					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);
					_craftingSortModeButtonsSignature = craftingSortModeButtonsSignature;
				}
			}
		}

		private static string GetCraftingSortModeButtonsSignature(InventoryGui gui, RectTransform group, Vector2 position, Vector2 size, float buttonSize)
		{
			//IL_005f: 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_007b: 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)
			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 $"{((Object)gui.m_crafting).GetInstanceID()}|{((Object)group).GetInstanceID()}|{position.x:0.###}|{position.y:0.###}|{size.x:0.###}|{size.y:0.###}|{buttonSize:0.###}|{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);
			}
			_craftingSortModeButtonsSignature = "";
			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;
			}
			_craftingSortModeButtonsSignature = "";
			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 bool TryGetCraftingTabRowBounds(InventoryGui gui, out CraftingTabRowBounds bounds)
		{
			//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_0075: 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_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_0090: 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_0124: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			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)
				{
					Transform parent = ((Component)gui.m_tabCraft).transform.parent;
					if ((Object)(object)parent == (Object)null)
					{
						return false;
					}
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					val.GetWorldCorners(array);
					Vector3 val2 = ((Transform)gui.m_crafting).InverseTransformPoint(array[1]);
					Vector3 val3 = ((Transform)gui.m_crafting).InverseTransformPoint(array[0]);
					float rowCenter = (val2.y + val3.y) * 0.5f;
					float num = Mathf.Max(1f, Mathf.Abs(val2.y - val3.y));
					float tolerance = Mathf.Max(num * 1.25f, 24f);
					float num2 = float.MaxValue;
					float num3 = float.MinValue;
					float num4 = float.MinValue;
					float num5 = float.MaxValue;
					Button[] componentsInChildren = ((Component)gui.m_crafting).GetComponentsInChildren<Button>(true);
					foreach (Button tab in componentsInChildren)
					{
						if (TryGetCraftingTabButtonBounds(gui, tab, parent, val, rowCenter, num, tolerance, array, out var localBottomLeft, out var localTopLeft, out var localTopRight))
						{
							num2 = Mathf.Min(num2, localTopLeft.x);
							num3 = Mathf.Max(num3, localTopRight.x);
							num4 = Mathf.Max(num4, localTopLeft.y);
							num5 = Mathf.Min(num5, localBottomLeft.y);
						}
					}
					if (num3 <= num2 || num4 <= num5)
					{
						return false;
					}
					bounds = new CraftingTabRowBounds(num2, num3, num4, num5);
					return true;
				}
			}
			return false;
		}

		private static bool TryGetCraftingTabButtonBounds(InventoryGui gui, Button? tab, Transform tabRoot, RectTransform craftTab, float rowCenter, float rowHeight, float tolerance, Vector3[] corners, out Vector3 localBottomLeft, out Vector3 localTopLeft, out Vector3 localTopRight)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			localBottomLeft = default(Vector3);
			localTopLeft = default(Vector3);
			localTopRight = default(Vector3);
			if (!((Object)(object)tab == (Object)null) && !IsUnityNull((Object?)(object)tab) && ((Component)tab).gameObject.activeInHierarchy)
			{
				Transform transform = ((Component)tab).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val != null)
				{
					bool flag = (Object)(object)tab == (Object)(object)gui.m_tabCraft || (Object)(object)tab == (Object)(object)gui.m_tabUpgrade;
					bool flag2 = (Object)(object)((Component)tab).transform.parent == (Object)(object)tabRoot || ((Component)tab).transform.IsChildOf(tabRoot);
					if (!flag && IsOwnedCraftingUiTransform(((Component)tab).transform))
					{
						return false;
					}
					if (!flag && !flag2 && !((Selectable)tab).interactable)
					{
						return false;
					}
					if (!flag && IsKnownNonTabCraftingButton(gui, tab))
					{
						return false;
					}
					val.GetWorldCorners(corners);
					localBottomLeft = ((Transform)gui.m_crafting).InverseTransformPoint(corners[0]);
					localTopLeft = ((Transform)gui.m_crafting).InverseTransformPoint(corners[1]);
					localTopRight = ((Transform)gui.m_crafting).InverseTransformPoint(corners[2]);
					Vector3 val2 = ((Transform)gui.m_crafting).InverseTransformPoint(corners[3]);
					if (Mathf.Abs((localTopLeft.y + localBottomLeft.y) * 0.5f - rowCenter) > tolerance)
					{
						return false;
					}
					float num = Mathf.Abs(localTopRight.x - localTopLeft.x);
					float num2 = Mathf.Abs(localTopLeft.y - localBottomLeft.y);
					if (num < 36f || num > 260f || num2 < rowHeight * 0.55f || num2 > rowHeight * 1.75f)
					{
						return false;
					}
					float num3 = Mathf.Max(localTopRight.x, val2.x);
					float num4 = Mathf.Min(localTopLeft.x, localBottomLeft.x);
					return num3 > num4;
				}
			}
			return false;
		}

		private static bool IsKnownNonTabCraftingButton(InventoryGui gui, Button button)
		{
			Transform transform = ((Component)button).transform;
			if ((Object)(object)gui.m_craftButton != (Object)null && !IsUnityNull((Object?)(object)gui.m_craftButton) && transform.IsChildOf(((Component)gui.m_craftButton).transform))
			{
				return true;
			}
			if ((Object)(object)gui.m_repairButton != (Object)null && !IsUnityNull((Object?)(object)gui.m_repairButton) && transform.IsChildOf(((Component)gui.m_repairButton).transform))
			{
				return true;
			}
			if ((Object)(object)gui.m_recipeListScroll != (Object)null && !IsUnityNull((Object?)(object)gui.m_recipeListScroll) && transform.IsChildOf(((Component)gui.m_recipeListScroll).transform))
			{
				return true;
			}
			if ((Object)(object)_craftingRecipeGrid != (Object)null && !IsUnityNull((Object?)(object)_craftingRecipeGrid) && transform.IsChildOf((Transform)(object)_craftingRecipeGrid))
			{
				return true;
			}
			if ((Object)(object)_craftingGroupRail != (Object)null && !IsUnityNull((Object?)(object)_craftingGroupRail) && transform.IsChildOf((Transform)(object)_craftingGroupRail))
			{
				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();
				MarkCraftingSearchInputDirty();
				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 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)
		{
			string sectionId2 = sectionId;
			return sectionId2 switch
			{
				"melee" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"ranged" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"magic" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"tool" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"armor" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"food" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"consumable" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"meadbase" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				"misc" => (ItemData item) => ItemMatchesTopLevelGroup(item, sectionId2), 
				_ => throw new InvalidOperationException("Unknown built-in item group section '" + sectionId2 + "'."), 
			};
		}

		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)_craftingQueueRecipe == (Object)null || (Object)(object)recipe != (Object)(object)_craftingQueueRecipe || gui.m_selectedVariant != _craftingQueueVariant || ((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;
			}
			if (!((Humanoid)localPlayer).GetInventory().CanAddItem(((Component)recipe.m_item).gameObject, amount))
			{
				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;
		}

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

		internal static void OnCraftingRecipeListUpdated(InventoryGui gui)
		{
			if (!((Object)(object)gui == (Object)null))
			{
				string craftingRecipeListChangeSignature = GetCraftingRecipeListChangeSignature(gui);
				if (!string.Equals(_craftingRecipeListChangeSignature, craftingRecipeListChangeSignature, StringComparison.Ordinal))
				{
					_craftingRecipeListChangeSignature = craftingRecipeListChangeSignature;
					UpdateCraftingPanelRedesign(gui, CraftingPanelUpdateReason.RecipeListChanged);
				}
			}
		}

		internal static void OnCraftingRecipeUpdated(InventoryGui gui)
		{
			if (!((Object)(object)gui == (Object)null))
			{
				string craftingSelectedRecipeChangeSignature = GetCraftingSelectedRecipeChangeSignature(gui);
				if (!string.Equals(_craftingSelectedRecipeChangeSignature, craftingSelectedRecipeChangeSignature, StringComparison.Ordinal))
				{
					_craftingSelectedRecipeChangeSignature = craftingSelectedRecipeChangeSignature;
					UpdateCraftingPanelRedesign(gui, CraftingPanelUpdateReason.RecipeChanged);
				}
			}
		}

		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 string GetCraftingSelectedRecipeChangeSignature(InventoryGui gui)
		{
			//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)
			int num = 17;
			num = num * 31 + ((Object)gui).GetInstanceID();
			num = num * 31 + (IsCraftingCraftTabSelected(gui) ? 1 : 0);
			num = num * 31 + (IsCraftingUpgradeTabSelected(gui) ? 1 : 0);
			num = num * 31 + GetCraftingTabAdapterState(gui).Kind.GetHashCode();
			num = num * 31 + GetSelectedCraftingRecipeIndexSafe(gui);
			num = num * 31 + gui.m_selectedVariant;
			num = num * 31 + GetCraftingRecipePairChangeHash(gui.m_selectedRecipe);
			num = num * 31 + GetCraftingSelectedRequirementAvailabilityHash(gui);
			int selectedCraftingRecipeIndexSafe = GetSelectedCraftingRecipeIndexSafe(gui);
			if (gui.m_availableRecipes != null && selectedCraftingRecipeIndexSafe >= 0 && selectedCraftingRecipeIndexSafe < gui.m_availableRecipes.Count)
			{
				num = num * 31 + GetCraftingRecipePairChangeHash(gui.m_availableRecipes[selectedCraftingRecipeIndexSafe]);
			}
			return num.ToString();
		}

		private static int GetCraftingSelectedRequirementAvailabilityHash(InventoryGui gui)
		{
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			if (recipe?.m_resources == null)
			{
				return 0;
			}
			int num = 17;
			int num2 = ((((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData == null) ? 1 : (((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData.m_quality + 1));
			int num3 = Mathf.Max(1, GetEffectiveCraftingCount(gui));
			num = num * 31 + num2;
			num = num * 31 + num3;
			num = num * 31 + (HasNoCraftCost() ? 1 : 0);
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (val != null && !((Object)(object)val.m_resItem == (Object)null))
				{
					num = num * 31 + ((Object)val.m_resItem).GetInstanceID();
					num = num * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(val.m_resItem.m_itemData?.m_shared?.m_name ?? "");
					num = num * 31 + Mathf.Max(0, val.GetAmount(num2) * num3);
					num = num * 31 + GetAvailableCraftingRequirementAmount(val);
				}
			}
			return num;
		}

		private static int GetCraftingRecipePairChangeHash(RecipeDataPair pair)
		{
			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 + ((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_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_0092: 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_00af: 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)
			if (gui.m_availableRecipes == null)
			{
				CraftingRecipes.View.Clear();
				CraftingRecipes.ViewIndexByOriginal.Clear();
				_craftingRecipeViewSignature = "";
				_craftingRecipeViewDirty = false;
				InvalidateCraftingRecipeGridLayout();
				return true;
			}
			CraftingTabAdapterState craftingTabAdapterState = GetCraftingTabAdapterState(gui);
			string craftingRecipeViewSignature = GetCraftingRecipeViewSignature(gui);
			if (!_craftingRecipeViewDirty && string.Equals(_craftingRecipeViewSignature, craftingRecipeViewSignature, StringComparison.Ordinal))
			{
				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(craftingTabAdapterState, pair))
				{
					CraftingRecipes.View.Add(new CraftingRecipeViewEntry(i, pair, !craftingTabAdapterState.IsRecycleNReclaim && IsFavoriteCraftingRecipe(pair), GetCraftingRecipeSortKey(pair)));
				}
			}
			CraftingRecipes.View.Sort(CompareCraftingRecipeViewEntries);
			RebuildCraftingRecipeViewIndexCache();
			_craftingRecipeViewSignature = craftingRecipeViewSignature;
			_craftingRecipeViewDirty = false;
			InvalidateCraftingRecipeGridLayout();
			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)
		{
			string text = _craftingRecipeSortMode?.Value.ToString() ?? "";
			return $"{GetCraftingRecipeListContextSignature(gui)}|{_selectedCraftingGroupId}|{_craftingSearchQuery}|{text}|{AreFavoritesEnabled()}|{_craftingFavoritesVersion}|{_loadedCraftingFavoritesPlayerId}";
		}

		private static string GetCraftingRecipeListContextSignature(InventoryGui gui)
		{
			int num = ((gui.m_availableRecipes != null) ? RuntimeHelpers.GetHashCode(gui.m_availableRecipes) : 0);
			int num2 = gui.m_availableRecipes?.Count ?? (-1);
			int selectedCraftingRecipeIndexSafe = GetSelectedCraftingRecipeIndexSafe(gui);
			CraftingTabAdapterState craftingTabAdapterState = 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}|selected={selectedCraftingRecipeIndexSafe}";
		}

		private static int GetSelectedCraftingRecipeIndexSafe(InventoryGui gui)
		{
			try
			{
				return gui.GetSelectedRecipeIndex(true);
			}
			catch
			{
				return -1;
			}
		}

		private static int CompareCraftingRecipeViewEntries(CraftingRecipeViewEntry a, CraftingRecipeViewEntry b)
		{
			return CompareCraftingRecipeViewEntriesForAdapter(GetCraftingTabAdapterState(InventoryGui.instance), a, b);
		}

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

		[IteratorStateMachine(typeof(<GetResourceTokens>d__672))]
		private static IEnumerable<string> GetResourceTokens(ItemDrop itemDrop)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetResourceTokens>d__672(-2)
			{
				<>3__itemDrop = itemDrop
			};
		}

		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)
		{
			ItemData itemData = ((RecipeDataPair)(ref pair)).ItemData;
			string itemKey = ((itemData?.m_shared == null) ? "" : $"{GetItemPrefabName(itemData)}|{itemData.m_shared.m_name}|{itemData.m_variant}|{itemData.m_quality}");
			return new CraftingRecipePairCacheKey(((RecipeDataPair)(ref pair)).Recipe, itemKey);
		}

		private static void UpdateCraftingRecipeScrollbar(InventoryGui gui, RectTransform grid)
		{
			//IL_005d: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = EnsureCraftingRecipeScrollbar(gui);
			if ((Object)(object)val == (Object)null || (Object)(object)_craftingRecipeScrollbarComponent == (Object)null)
			{
				return;
			}
			EnsureCraftingVanillaRecipeScrollbarsHidden(gui);
			int craftingRecipePageCount = GetCraftingRecipePageCount(gui);
			bool flag = craftingRecipePageCount > 1;
			string text = $"{craftingRecipePageCount}|{_craftingRecipePage}|{flag}|{grid.anchoredPosition}";
			if (!_craftingRecipeScrollbarDirty && string.Equals(_craftingRecipeScrollbarSignature, text, StringComparison.Ordinal))
			{
				return;
			}
			((Component)val).gameObject.SetActive(flag);
			if (!flag)
			{
				_craftingRecipeScrollbarSignature = text;
				_craftingRecipeScrollbarDirty = false;
				return;
			}
			Scrollbar craftingRecipeScrollbarComponent = _craftingRecipeScrollbarComponent;
			CraftingRecipeScrollbarMarker craftingRecipeScrollbarMarker = ((Component)val).GetComponent<CraftingRecipeScrollbarMarker>() ?? ((Component)val).gameObject.AddComponent<CraftingRecipeScrollbarMarker>();
			if (!craftingRecipeScrollbarMarker.Initialized)
			{
				((UnityEvent<float>)(object)craftingRecipeScrollbarComponent.onValueChanged).AddListener((UnityAction<float>)OnCraftingRecipeScrollbarChanged);
				craftingRecipeScrollbarMarker.Initialized = true;
			}
			SetCraftingTopLeftRect(gui.m_crafting, val, GetCraftingRecipeScrollbarPosition(gui, grid), new Vector2(16f, 570f));
			SetCraftingRecipeScrollbarGraphicsVisible(val, visible: true);
			craftingRecipeScrollbarComponent.direction = (Direction)2;
			craftingRecipeScrollbarComponent.size = Mathf.Clamp01(1f / (float)craftingRecipePageCount);
			_updatingCraftingRecipeScrollbar = true;
			craftingRecipeScrollbarComponent.value = ((craftingRecipePageCount <= 1) ? 1f : (1f - (float)_craftingRecipePage / (float)(craftingRecipePageCount - 1)));
			_updatingCraftingRecipeScrollbar = false;
			_craftingRecipeScrollbarSignature = text;
			_craftingRecipeScrollbarDirty = false;
		}

		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)
			{
				_craftingRecipeScrollbarComponent = ((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);
			_craftingRecipeScrollbarComponent = ((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)_craftingRecipeScrollbarComponent))
				{
					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 (_updatingCraftingRecipeScrollbar || (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();
				InvalidateCraftingRecipeGridLayout();
				int num2 = _craftingRecipePage * GetCraftingRecipeGridCapacity();
				UpdateCraftingRecipeView(instance);
				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_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_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)
			if (adapter.IsRecycleNReclaim)
			{
				return CompareRecycleNReclaimRecipeViewEntries(a, b);
			}
			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_0019: 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)
			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_0046: 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 (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_008d: 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_005d: 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 ((Object)(object)((RecipeDataPair)(ref pair)).Recipe == (Object)null || (Object)(object)((RecipeDataPair)(ref pair)).Recipe.m_item == (Object)null)
			{
				return "";
			}
			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_007f: 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_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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: 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_0245: Unknown result type (might be due to invalid IL or missing references)
			if (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;
			}
			CraftingHoverTooltipContent craftingHoverTooltipContent = GetCraftingHoverTooltipContent(pair);
			ItemData? craftingJewelcraftingTooltipItem = GetCraftingJewelcraftingTooltipItem(pair);
			string craftingHoverGemIconSignature = GetCraftingHoverGemIconSignature(craftingJewelcraftingTooltipItem);
			List<JewelcraftingGemIconData> craftingHoverGemIcons = GetCraftingHoverGemIcons(craftingJewelcraftingTooltipItem, craftingHoverGemIconSignature);
			bool 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 = effectiveSlotSize + 16f + (flag ? (5f + effectiveGemIconSize) : 0f);
			RectTransform val3 = EnsureCraftingTooltipRecipeOverlay(val2, hoverTooltipPanel);
			LayoutCraftingHoverTooltipPanel(hoverTooltipPanel, val3, num2, overlayHeight, 8f);
			DisableCraftingTooltipRecipeOverlayBackground(((Component)val3).GetComponent<Image>());
			((Transform)hoverTooltipPanel).position = ZInput.mousePosition;
			Utils.ClampUIToScreen(hoverTooltipPanel);
			val.transform.SetAsLastSibling();
			((Transform)val3).SetAsLastSibling();
			((Component)val3).gameObject.SetActive(true);
			string craftingHoverTooltipVisualSignature = GetCraftingHoverTooltipVisualSignature(pair, craftingHoverGemIconSignature, effectiveSlotSize, effectiveGap, effectiveGemIconSize, effectiveGemGap, flag);
			if (!string.Equals(CraftingUi.HoverTooltipVisualSignature, craftingHoverTooltipVisualSignature, StringComparison.Ordinal) || (Object)(object)((Transform)val3).Find("RecipeRow") == (Object)null || (flag && (Object)(object)((Transform)val3).Find("InventorySlots_CraftingGemIconRow") == (Object)null))
			{
				ConfigureCraftingTooltipRecipeRow(val3, pair, Vector2.zero, effectiveSlotSize, effectiveGap, enableSlotTooltips: false);
				if (flag)
				{
					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 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)
		{
			//IL_0000: 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)
			string craftingHoverTooltipContentKey = GetCraftingHoverTooltipContentKey(pair);
			if (!string.IsNullOrEmpty(craftingHoverTooltipContentKey) && CraftingRecipes.HoverTooltipContentCache.TryGetValue(craftingHoverTooltipContentKey, out var value))
			{
				CraftingUi.HoverTooltipContentKey = craftingHoverTooltipContentKey;
				return value;
			}
			CraftingHoverTooltipContent craftingHoverTooltipContent = new CraftingHoverTooltipContent(GetCraftingRecipeDisplayName(pair), GetCraftingRecipeTooltip(pair));
			if (!string.IsNullOrEmpty(craftingHoverTooltipContentKey))
			{
				CraftingRecipes.HoverTooltipContentCache[craftingHoverTooltipContentKey] = craftingHoverTooltipContent;
				CraftingUi.HoverTooltipContentKey = craftingHoverTooltipContentKey;
			}
			return craftingHoverTooltipContent;
		}

		private static string GetCraftingHoverTooltipContentKey(RecipeDataPair pair)
		{
			//IL_0000: 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)
			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);
			string itemRequiresSkillLevelCraftingTooltipSignature = GetItemRequiresSkillLevelCraftingTooltipSignature(pair);
			if (itemData == null)
			{
				return $"{craftingRecipePairCacheKey.RecipeId}|{craftingRecipePairCacheKey.ItemKey}|craft|{num}|{worldLevel}|irsl:{itemRequiresSkillLevelCraftingTooltipSignature}";
			}
			string text = (((Object)(object)InventoryGui.instance != (Object)null && IsJewelcraftingSocketTabActive(InventoryGui.instance)) ? "socket" : "upgrade");
			return $"{craftingRecipePairCacheKey.RecipeId}|{craftingRecipePairCacheKey.ItemKey}|{text}|{num}|{worldLevel}|{GetCraftingTooltipItemSignature(itemData)}|irsl:{itemRequiresSkillLevelCraftingTooltipSignature}";
		}

		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 = "";
			CraftingController.ClearHoverTooltipContentKey();
			CraftingUi.HoverTooltipLayoutSignature = "";
			CraftingUi.HoverTooltipVisualSignature = "";
			return CraftingUi.HoverTooltip;
		}

		private static RectTransform? ResolveCraftingHoverTooltipPanel(GameObject tooltip)
		{
			if (tooltip.transform.childCount > 0)
			{
				Transform child = tooltip.transform.GetChild(0);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null)
				{
					return val;
				}
			}
			Transform transform = tooltip.transform;
			return (RectTransform?)(object)((transform is RectTransform) ? transform : null);
		}

		private static TMP_Text? FindTooltipText(GameObject tooltip, string name)
		{
			Transform val = Utils.FindChild(tooltip.transform, name, (IterativeSearchType)0);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).GetComponent<TMP_Text>();
		}

		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)
		{
			//IL_017b: 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_01a5: 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_01be: 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_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: 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_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			string craftingHoverTooltipLayoutSignature = GetCraftingHoverTooltipLayoutSignature(width, overlayHeight, padding);
			if (string.Equals(CraftingUi.HoverTooltipLayoutSignature, craftingHoverTooltipLayoutSignature, StringComparison.Ordinal))
			{
				ApplyCraftingHoverTooltipScrollPosition();
				return;
			}
			float num = Mathf.Max(40f, width - padding * 2f);
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 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, num);
				hoverTooltipTopic.ForceMeshUpdate(true, false);
				num2 = 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(true);
				hoverTooltipText.rectTransform.SetSizeWithCurrentAnchors((Axis)0, num);
				hoverTooltipText.ForceMeshUpdate(true, false);
				num4 = GetCraftingHoverTooltipPreferredTextHeight(hoverTooltipText, num);
			}
			float num5 = padding + num2 + 6f;
			float num6 = num5 + 8f + overlayHeight + padding;
			float num7 = Mathf.Max(80f, GetCraftingHoverTooltipMaxPanelHeight() - num6);
			num3 = ((num4 > 0f) ? Mathf.Min(num4, num7) : 0f);
			float num8 = num5 + num3 + 8f + 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, num8);
			((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, num2);
			}
			if ((Object)(object)CraftingUi.HoverTooltipText != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.HoverTooltipText))
			{
				LayoutCraftingHoverTooltipTextScroll(panel, num, padding, num5, num3, num4);
			}
			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)
		{
			return string.Join("|", CraftingUi.HoverTooltipSignature, Screen.width, Screen.height, GetCraftingHoverTooltipMaxPanelHeight().ToString("0.###"), width.ToString("0.###"), overlayHeight.ToString("0.###"), padding.ToString("0.###"));
		}

		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 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_002a: 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));
			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);
							stringBuilder.Append('|').Append(((Object)val.m_resItem).name).Append(':')
								.Append(availableCraftingRequirementAmount)
								.Append('/')
								.Append(amount);
							num2++;
						}
					}
				}
			}
			CraftingStation val2 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStation(num) : null);
			int num3 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStationLevel(num) : 0);
			CraftingStation val3 = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetCurrentCraftingStation() : null);
			bool value = (Object)(object)val2 == (Object)null || HasNoCraftCost() || ((Object)(object)val3 != (Object)null && val3.m_name == val2.m_name && val3.GetLevel(true) >= num3);
			stringBuilder.Append("|station:").Append(((Object)(object)val2 != (Object)null) ? val2.m_name : "").Append(':')
				.Append(num3)
				.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 void ApplyCraftingTooltipNativePanelLayout(RectTransform tooltipRect, RectTransform panel, float overlayHeight)
		{
			//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_0081: 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_0103: 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)
			if ((Object)(object)CraftingUi.TooltipExpandedPanel != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.TooltipExpandedPanel) && (Object)(object)CraftingUi.TooltipExpandedPanel != (Object)(object)panel)
			{
				RestoreCraftingTooltipNativePanelLayout(restoreAnyPanel: true);
			}
			CraftingTooltipNativePanelLayoutState craftingTooltipNativePanelLayoutState = ((Component)panel).GetComponent<CraftingTooltipNativePanelLayoutState>() ?? ((Component)panel).gameObject.AddComponent<CraftingTooltipNativePanelLayoutState>();
			if (Mathf.Abs(craftingTooltipNativePanelLayoutState.AppliedOffsetMinYDelta) > 0.001f)
			{
				panel.offsetMin = new Vector2(panel.offsetMin.x, panel.offsetMin.y - craftingTooltipNativePanelLayoutState.AppliedOffsetMinYDelta);
				craftingTooltipNativePanelLayoutState.AppliedOffsetMinYDelta = 0f;
			}
			Transform parent = ((Transform)panel).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			float num3;
			if ((Object)(object)val != (Object)null && TryGetHoverTooltipTextBounds(tooltipRect, val, out var bounds) && TryGetRectTransformBounds(panel, val, out var bounds2))
			{
				float num = ((Rect)(ref bounds)).yMin - 6f - overlayHeight;
				float num2 = ((Rect)(ref bounds2)).yMax - overlayHeight - 1f;
				num3 = Mathf.Min(num, num2) - ((Rect)(ref bounds2)).yMin;
			}
			else
			{
				num3 = 0f - overlayHeight;
			}
			panel.offsetMin = new Vector2(panel.offsetMin.x, panel.offsetMin.y + num3);
			craftingTooltipNativePanelLayoutState.AppliedOffsetMinYDelta = num3;
			CraftingUi.TooltipExpandedPanel = panel;
		}

		private static void RestoreCraftingTooltipNativePanelLayout(bool restoreAnyPanel)
		{
			//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)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CraftingUi.TooltipExpandedPanel;
			if (!restoreAnyPanel && (Object)(object)CraftingUi.TooltipRecipeOverlay != (Object)null && !IsUnityNull((Object?)(object)CraftingUi.TooltipRecipeOverlay))
			{
				Transform parent = ((Transform)CraftingUi.TooltipRecipeOverlay).parent;
				val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			}
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val))
			{
				CraftingUi.TooltipExpandedPanel = null;
				return;
			}
			CraftingTooltipNativePanelLayoutState component = ((Component)val).GetComponent<CraftingTooltipNativePanelLayoutState>();
			if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component) && Mathf.Abs(component.AppliedOffsetMinYDelta) > 0.001f)
			{
				val.offsetMin = new Vector2(val.offsetMin.x, val.offsetMin.y - component.AppliedOffsetMinYDelta);
				component.AppliedOffsetMinYDelta = 0f;
			}
			if ((Object)(object)CraftingUi.TooltipExpandedPanel == (Object)(object)val)
			{
				CraftingUi.TooltipExpandedPanel = null;
			}
		}

		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 RectTransform ResolveCraftingTooltipRecipeOverlayParent(RectTransform tooltipRect, RectTransform fallback)
		{
			if (TryGetHoverTooltipAttachmentRect(tooltipRect, out RectTransform attachmentRect))
			{
				return attachmentRect;
			}
			return fallback;
		}

		private static void ConfigureCraftingTooltipRecipeOverlayBackground(RectTransform tooltipRect, Image? image)
		{
			//IL_00ad: 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_00d9: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				Image val = FindTooltipBackgroundImageSource(tooltipRect);
				if ((Object)(object)val != (Object)null && !IsUnityNull((Object?)(object)val) && (Object)(object)val.sprite != (Object)null)
				{
					image.sprite = val.sprite;
					((Graphic)image).material = ((Graphic)val).material;
					((Graphic)image).color = ((Graphic)val).color;
					image.type = val.type;
					image.preserveAspect = val.preserveAspect;
					image.fillCenter = val.fillCenter;
					image.pixelsPerUnitMultiplier = val.pixelsPerUnitMultiplier;
				}
				else
				{
					image.sprite = GetSolidUiSprite();
					((Graphic)image).material = null;
					((Graphic)image).color = new Color(0f, 0f, 0f, GetCraftingHoverTooltipBackgroundAlpha());
					image.type = (Type)1;
					image.fillCenter = true;
				}
				Color color = ((Graphic)image).color;
				color.a = GetCraftingHoverTooltipBackgroundAlpha();
				((Graphic)image).color = color;
				((Behaviour)image).enabled = true;
				((Graphic)image).raycastTarget = false;
			}
		}

		private static void DisableCraftingTooltipRecipeOverlayBackground(Image? image)
		{
			if (!((Object)(object)image == (Object)null))
			{
				((Behaviour)image).enabled = false;
				((Graphic)image).raycastTarget = false;
			}
		}

		private static Image? FindTooltipBackgroundImageSource(RectTransform tooltipRect)
		{
			//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_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)
			Image val = null;
			float num = 0f;
			Image[] componentsInChildren = ((Component)tooltipRect).GetComponentsInChildren<Image>(false);
			foreach (Image val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsUnityNull((Object?)(object)val2) && ((Behaviour)val2).enabled && !((Object)(object)val2.sprite == (Object)null) && !IsOwnedCraftingUiTransform(((Component)val2).transform))
				{
					Rect rect = ((Graphic)val2).rectTransform.rect;
					float width = ((Rect)(ref rect)).width;
					rect = ((Graphic)val2).rectTransform.rect;
					float num2 = width * ((Rect)(ref rect)).height;
					if ((Object)(object)val == (Object)null || num2 > num)
					{
						val = val2;
						num = num2;
					}
				}
			}
			return val;
		}

		private static void PlaceCraftingTooltipRecipeOverlayBelowTooltip(RectTransform tooltipRect, RectTransform overlay, Rect? tooltipBounds)
		{
			//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_0067: 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_006b: 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_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)
			Transform parent = ((Transform)overlay).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (!((Object)(object)val == (Object)null))
			{
				if (tooltipBounds.HasValue)
				{
					Rect value = tooltipBounds.Value;
					((Transform)overlay).position = ((Transform)val).TransformPoint(new Vector3(((Rect)(ref value)).xMin, ((Rect)(ref value)).yMin, 0f));
					return;
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				tooltipRect.GetWorldCorners(array);
				Vector3 val2 = ((Transform)val).InverseTransformPoint(array[0]);
				((Transform)overlay).position = ((Transform)val).TransformPoint(val2);
			}
		}

		private static bool TryGetHoverTooltipPanelBounds(RectTransform tooltipRect, RectTransform parent, out Rect bounds)
		{
			if (TryGetHoverTooltipContentBounds(tooltipRect, parent, out bounds))
			{
				return true;
			}
			return TryGetTooltipVisualBounds(tooltipRect, parent, out bounds);
		}

		private static bool TryGetHoverTooltipContentBounds(RectTransform tooltipRect, RectTransform parent, out Rect bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			bounds = default(Rect);
			if (!TryGetHoverTooltipTextBounds(tooltipRect, parent, out var bounds2))
			{
				return false;
			}
			if (TryGetHoverTooltipMainPanelBounds(tooltipRect, parent, bounds2, out bounds))
			{
				return true;
			}
			if (TryGetHoverTooltipBackgroundBounds(tooltipRect, parent, bounds2, out bounds))
			{
				return true;
			}
			if (TryGetHoverTooltipTextRectBounds(tooltipRect, parent, bounds2, out var bounds3))
			{
				bounds = Rect.MinMaxRect(((Rect)(ref bounds3)).xMin, ((Rect)(ref bounds2)).yMin - 16f, ((Rect)(ref bounds3)).xMax, ((Rect)(ref bounds2)).yMax + 18f);
				return true;
			}
			bounds = Rect.MinMaxRect(((Rect)(ref bounds2)).xMin - 26f, ((Rect)(ref bounds2)).yMin - 16f, ((Rect)(ref bounds2)).xMax + 26f, ((Rect)(ref bounds2)).yMax + 18f);
			return true;
		}

		private static bool TryGetHoverTooltipTextBounds(RectTransform tooltipRect, RectTransform parent, out Rect bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_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_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_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_0120: 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_0138: 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_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_0157: 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_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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_01d4: 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)
			bounds = default(Rect);
			bool flag = false;
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			TMP_Text[] componentsInChildren = ((Component)tooltipRect).GetComponentsInChildren<TMP_Text>(false);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Behaviour)val).enabled || !((Component)val).gameObject.activeInHierarchy || string.IsNullOrWhiteSpace(val.text) || IsOwnedCraftingUiTransform(val.transform))
				{
					continue;
				}
				val.ForceMeshUpdate(false, false);
				Bounds textBounds = val.textBounds;
				Vector3 size = ((Bounds)(ref textBounds)).size;
				if (((Vector3)(ref size)).sqrMagnitude <= 0.001f)
				{
					continue;
				}
				Vector3 min = ((Bounds)(ref textBounds)).min;
				Vector3 max = ((Bounds)(ref textBounds)).max;
				float preferredHeight = val.preferredHeight;
				if (!float.IsNaN(preferredHeight) && !float.IsInfinity(preferredHeight) && preferredHeight > ((Bounds)(ref textBounds)).size.y)
				{
					min.y = Mathf.Min(min.y, max.y - preferredHeight);
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4]
				{
					new Vector3(min.x, min.y, 0f),
					new Vector3(min.x, max.y, 0f),
					new Vector3(max.x, min.y, 0f),
					new Vector3(max.x, max.y, 0f)
				};
				for (int j = 0; j < array.Length; j++)
				{
					Vector3 val2 = ((Transform)parent).InverseTransformPoint(val.transform.TransformPoint(array[j]));
					if (!flag)
					{
						num = val2.x;
						num2 = val2.y;
						num3 = val2.x;
						num4 = val2.y;
						flag = true;
					}
					else
					{
						num = Mathf.Min(num, val2.x);
						num2 = Mathf.Min(num2, val2.y);
						num3 = Mathf.Max(num3, val2.x);
						num4 = Mathf.Max(num4, val2.y);
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			bounds = Rect.MinMaxRect(num, num2, num3, num4);
			return true;
		}

		private static bool TryGetHoverTooltipMainPanelBounds(RectTransform tooltipRect, RectTransform parent, Rect textBounds, out Rect bounds)
		{
			//IL_0001: 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)
			bounds = default(Rect);
			if (((Transform)tooltipRect).childCount == 0)
			{
				return false;
			}
			Transform child = ((Transform)tooltipRect).GetChild(0);
			RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Component)val).gameObject.activeInHierarchy || IsOwnedCraftingUiTransform((Transform)(object)val))
			{
				return false;
			}
			if (TryGetRectTransformBounds(val, parent, out bounds))
			{
				return IsHoverTooltipPanelBoundsCandidate(bounds, textBounds);
			}
			return false;
		}

		private static bool TryGetHoverTooltipAttachmentRect(RectTransform tooltipRect, out RectTransform attachmentRect)
		{
			//IL_0029: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			attachmentRect = null;
			Transform parent = ((Transform)tooltipRect).parent;
			RectTransform parent2 = (RectTransform)(((object)((parent is RectTransform) ? parent : null)) ?? ((object)tooltipRect));
			if (!TryGetHoverTooltipTextBounds(tooltipRect, parent2, out var bounds))
			{
				return TryGetHoverTooltipMainPanelRect(tooltipRect, out attachmentRect);
			}
			if (TryGetHoverTooltipBackgroundRect(tooltipRect, parent2, bounds, out attachmentRect))
			{
				return true;
			}
			if (TryGetHoverTooltipMainPanelRect(tooltipRect, out RectTransform panel) && TryGetRectTransformBounds(panel, parent2, out var bounds2) && IsHoverTooltipPanelBoundsCandidate(bounds2, bounds))
			{
				attachmentRect = panel;
				return true;
			}
			return false;
		}

		private static bool TryGetHoverTooltipMainPanelRect(RectTransform tooltipRect, out RectTransform panel)
		{
			panel = null;
			if (((Transform)tooltipRect).childCount == 0)
			{
				return false;
			}
			Transform child = ((Transform)tooltipRect).GetChild(0);
			RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
			if (val == null || IsUnityNull((Object?)(object)val) || !((Component)val).gameObject.activeInHierarchy || IsOwnedCraftingUiTransform((Transform)(object)val))
			{
				return false;
			}
			panel = val;
			return true;
		}

		private static bool TryGetHoverTooltipTextRectBounds(RectTransform tooltipRect, RectTransform parent, Rect textBounds, out Rect bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Rect);
			bool flag = false;
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			TMP_Text[] componentsInChildren = ((Component)tooltipRect).GetComponentsInChildren<TMP_Text>(false);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Behaviour)val).enabled || !((Component)val).gameObject.activeInHierarchy || string.IsNullOrWhiteSpace(val.text) || IsOwnedCraftingUiTransform(val.transform))
				{
					continue;
				}
				RectTransform rectTransform = val.rectTransform;
				if (!((Object)(object)rectTransform == (Object)null) && !IsUnityNull((Object?)(object)rectTransform) && TryGetRectTransformBounds(rectTransform, parent, out var bounds2) && !(((Rect)(ref bounds2)).width < ((Rect)(ref textBounds)).width * 0.65f) && !(((Rect)(ref bounds2)).height < ((Rect)(ref textBounds)).height * 0.35f))
				{
					if (!flag)
					{
						num = ((Rect)(ref bounds2)).xMin;
						num2 = ((Rect)(ref bounds2)).yMin;
						num3 = ((Rect)(ref bounds2)).xMax;
						num4 = ((Rect)(ref bounds2)).yMax;
						flag = true;
					}
					else
					{
						num = Mathf.Min(num, ((Rect)(ref bounds2)).xMin);
						num2 = Mathf.Min(num2, ((Rect)(ref bounds2)).yMin);
						num3 = Mathf.Max(num3, ((Rect)(ref bounds2)).xMax);
						num4 = Mathf.Max(num4, ((Rect)(ref bounds2)).yMax);
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			bounds = Rect.MinMaxRect(num, num2, num3, num4);
			return true;
		}

		private static bool TryGetHoverTooltipBackgroundBounds(RectTransform tooltipRect, RectTransform parent, Rect textBounds, out Rect bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_00a3: 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_00cf: 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)
			bounds = default(Rect);
			bool flag = false;
			float num = 0f;
			Vector2 center = ((Rect)(ref textBounds)).center;
			Image[] componentsInChildren = ((Component)tooltipRect).GetComponentsInChildren<Image>(false);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsUnityNull((Object?)(object)val) && ((Behaviour)val).enabled && ((Component)val).gameObject.activeInHierarchy && !(((Graphic)val).color.a <= 0.02f) && !((Object)(object)((Graphic)val).rectTransform == (Object)null) && !IsOwnedCraftingUiTransform(((Component)val).transform) && TryGetRectTransformBounds(((Graphic)val).rectTransform, parent, out var bounds2) && IsHoverTooltipPanelBoundsCandidate(bounds2, textBounds) && ((Rect)(ref bounds2)).Contains(center))
				{
					float num2 = ((Rect)(ref bounds2)).width * ((Rect)(ref bounds2)).height;
					if (!flag || num2 < num)
					{
						bounds = bounds2;
						num = num2;
						flag = true;
					}
				}
			}
			return flag;
		}

		private static bool TryGetHoverTooltipBackgroundRect(RectTransform tooltipRect, RectTransform parent, Rect textBounds, out RectTransform attachmentRect)
		{
			//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_005e: 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_00a3: 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)
			attachmentRect = null;
			bool flag = false;
			float num = 0f;
			Vector2 center = ((Rect)(ref textBounds)).center;
			Image[] componentsInChildren = ((Component)tooltipRect).GetComponentsInChildren<Image>(false);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Behaviour)val).enabled || !((Component)val).gameObject.activeInHierarchy || ((Graphic)val).color.a <= 0.02f || (Object)(object)((Graphic)val).rectTransform == (Object)null || IsOwnedCraftingUiTransform(((Component)val).transform))
				{
					continue;
				}
				RectTransform rectTransform = ((Graphic)val).rectTransform;
				if (TryGetRectTransformBounds(rectTransform, parent, out var bounds) && IsHoverTooltipPanelBoundsCandidate(bounds, textBounds) && ((Rect)(ref bounds)).Contains(center))
				{
					float num2 = ((Rect)(ref bounds)).width * ((Rect)(ref bounds)).height;
					if (!flag || num2 < num)
					{
						attachmentRect = rectTransform;
						num = num2;
						flag = true;
					}
				}
			}
			return flag;
		}

		private static bool IsHoverTooltipPanelBoundsCandidate(Rect bounds, Rect textBounds)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (((Rect)(ref bounds)).width >= ((Rect)(ref textBounds)).width * 0.75f && ((Rect)(ref bounds)).height >= ((Rect)(ref textBounds)).height * 0.75f && ((Rect)(ref bounds)).height <= ((Rect)(ref textBounds)).height + 220f)
			{
				return ((Rect)(ref bounds)).Overlaps(textBounds, false);
			}
			return false;
		}

		private static bool TryGetRectTransformBounds(RectTransform rect, RectTransform parent, out Rect bounds)
		{
			//IL_0001: 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_0054: 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_008c: 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_00a9: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Rect);
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rect.GetWorldCorners(array);
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val = ((Transform)parent).InverseTransformPoint(array[i]);
				if (i == 0)
				{
					num = val.x;
					num2 = val.y;
					num3 = val.x;
					num4 = val.y;
				}
				else
				{
					num = Mathf.Min(num, val.x);
					num2 = Mathf.Min(num2, val.y);
					num3 = Mathf.Max(num3, val.x);
					num4 = Mathf.Max(num4, val.y);
				}
			}
			if (num3 - num < 1f || num4 - num2 < 1f)
			{
				return false;
			}
			bounds = Rect.MinMaxRect(num, num2, num3, num4);
			return true;
		}

		private static bool TryGetTooltipVisualBounds(RectTransform tooltipRect, RectTransform parent, out Rect bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c8: 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_0101: 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_011e: 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_00d5: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Rect);
			bool flag = false;
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			Graphic[] componentsInChildren = ((Component)tooltipRect).GetComponentsInChildren<Graphic>(false);
			foreach (Graphic val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || !((Behaviour)val).enabled || !((Component)val).gameObject.activeInHierarchy || IsOwnedCraftingUiTransform(((Component)val).transform))
				{
					continue;
				}
				RectTransform rectTransform = val.rectTransform;
				if ((Object)(object)rectTransform == (Object)null || IsUnityNull((Object?)(object)rectTransform))
				{
					continue;
				}
				rectTransform.GetWorldCorners(array);
				for (int j = 0; j < array.Length; j++)
				{
					Vector3 val2 = ((Transform)parent).InverseTransformPoint(array[j]);
					if (!flag)
					{
						num = val2.x;
						num2 = val2.y;
						num3 = val2.x;
						num4 = val2.y;
						flag = true;
					}
					else
					{
						num = Mathf.Min(num, val2.x);
						num2 = Mathf.Min(num2, val2.y);
						num3 = Mathf.Max(num3, val2.x);
						num4 = Mathf.Max(num4, val2.y);
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			bounds = Rect.MinMaxRect(num, num2, num3, num4);
			return true;
		}

		private static void HideCraftingTooltipRecipeOverlay()
		{
			RestoreCraftingTooltipNativePanelLayout(restoreAnyPanel: true);
			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 = "";
			CraftingController.ClearHoverTooltipContentKey();
			CraftingUi.HoverTooltipLayoutSignature = "";
			CraftingUi.HoverTooltipVisualSignature = "";
			CraftingUi.HoverGemIconSignature = "";
			CraftingRecipes.HoverGemIconCache.Clear();
			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);
			}
			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_00b1: 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)
			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));
			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);
				string requirementDisplayName = GetRequirementDisplayName(requirement);
				ConfigureCraftingTooltipRecipeSlot(val, num2, requirement.m_resItem.m_itemData.GetIcon(), $"{availableCraftingRequirementAmount}/{amount}", HasNoCraftCost() || availableCraftingRequirementAmount >= amount, slotSize, requirementDisplayName, enableSlotTooltips);
			}
			CraftingStation val2 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStation(num) : null);
			int num3 = (((Object)(object)recipe != (Object)null) ? recipe.GetRequiredStationLevel(num) : 0);
			CraftingStation val3 = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetCurrentCraftingStation() : null);
			bool available = (Object)(object)val2 == (Object)null || HasNoCraftCost() || ((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) ? num3.ToString() : "", available, slotSize, ((Object)(object)val2 != (Object)null) ? GetCraftingStationDisplayName(val2) : "", enableSlotTooltips);
		}

		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)
		{
			//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_0171: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			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)(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 = (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;
		}

		[IteratorStateMachine(typeof(<GetKnownVanillaCraftingRoots>d__909))]
		private static IEnumerable<Transform?> GetKnownVanillaCraftingRoots(InventoryGui gui)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetKnownVanillaCraftingRoots>d__909(-2)
			{
				<>3__gui = gui
			};
		}

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

		[IteratorStateMachine(typeof(<FindCraftingVanillaPanelBackgroundImages>d__921))]
		private static IEnumerable<Image> FindCraftingVanillaPanelBackgroundImages(InventoryGui gui)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindCraftingVanillaPanelBackgroundImages>d__921(-2)
			{
				<>3__gui = gui
			};
		}

		[IteratorStateMachine(typeof(<FindCraftingPanelNamedBackgroundImages>d__922))]
		private static IEnumerable<Image> FindCraftingPanelNamedBackgroundImages(InventoryGui gui)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindCraftingPanelNamedBackgroundImages>d__922(-2)
			{
				<>3__gui = gui
			};
		}

		[IteratorStateMachine(typeof(<FindCraftingPanelFieldBackgroundImages>d__923))]
		private static IEnumerable<Image> FindCraftingPanelFieldBackgroundImages(InventoryGui gui)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindCraftingPanelFieldBackgroundImages>d__923(-2)
			{
				<>3__gui = gui
			};
		}

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

		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_00cb: 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))
					{
						list.Add(new KeepOnDeathItemState(val, gridPos, originalSlotId, originalSlotKind));
					}
				}
			}
			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;
				if (item?.m_shared != null && !inventory.ContainsItem(item))
				{
					flag |= RestoreKeepOnDeathItem(player, inventory, keptItem);
				}
			}
			keptItems.Clear();
			if (flag)
			{
				inventory.Changed();
				if (!player.m_isLoading)
				{
					EnsureInventoryState(player, InventoryStateEnsureReason.Tombstone);
				}
			}
		}

		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)
			KeepOnDeathItemState state2 = state;
			ItemData item = state2.Item;
			Vector2i val = (item.m_gridPos = state2.OriginalGridPos);
			SlotDefinition slot2;
			bool originalSlotAvailable = TryGetKeepOnDeathOriginalSlot(state2, item, out slot2) && CanRestoreKeepOnDeathItemToSlot(player, inventory, item, slot2);
			SlotDefinition foundSlot;
			bool emptyQuickSlotAvailable = TryFindKeepOnDeathEmptySpecialSlot(player, inventory, item, (SlotDefinition slot) => slot.Kind == SlotKind.Quick, out foundSlot);
			SlotDefinition foundSlot2 = null;
			bool emptySameSpecialKindSlotAvailable = !state2.WasQuickSlot && TryFindKeepOnDeathEmptySpecialSlot(player, inventory, item, (SlotDefinition slot) => slot.Kind == state2.OriginalSlotKind, out foundSlot2);
			bool originalCellAvailable = CanRestoreKeepOnDeathItemAtCell(player, inventory, item, val, state2);
			Vector2i pos;
			bool freeRegularCellAvailable = TryFindFreeRegularCell(player, inventory, out pos);
			SlotDefinition foundSlot3;
			bool emptyNonQuickSpecialSlotAvailable = TryFindKeepOnDeathEmptySpecialSlot(player, inventory, item, (SlotDefinition slot) => slot.Kind != SlotKind.Quick, out foundSlot3);
			switch (InventorySlotSafetyCore.SelectKeepOnDeathRestorePlan(new InventorySlotSafetyCore.KeepOnDeathRestoreOptions(state2.WasSpecialSlot, state2.WasQuickSlot, originalSlotAvailable, emptyQuickSlotAvailable, emptySameSpecialKindSlotAvailable, originalCellAvailable, freeRegularCellAvailable, emptyNonQuickSpecialSlotAvailable)))
			{
			case InventorySlotSafetyCore.KeepOnDeathRestorePlan.OriginalSlot:
				if (slot2 != null)
				{
					return TryRestoreKeepOnDeathItemToSlot(player, inventory, item, slot2);
				}
				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, state2);
			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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0026: 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)
			if (slot == null || !slot.Accepts(item))
			{
				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);
			return true;
		}

		private static bool TryFindKeepOnDeathEmptySpecialSlot(Player player, Inventory inventory, ItemData item, Func<SlotDefinition, bool>? slotFilter, out SlotDefinition? foundSlot)
		{
			//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_0037: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			foundSlot = null;
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if ((slotFilter == null || slotFilter(slotDefinition)) && slotDefinition.Accepts(item))
				{
					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)
			Inventory inventory2 = inventory;
			EnsureInventoryHeightForLoad(inventory2);
			InventorySlotSafetyCore.GridCell gridCell = InventorySlotSafetyCore.SelectNonOverlappingPreservationCell(inventory2.GetWidth(), inventory2.GetHeight(), new InventorySlotSafetyCore.GridCell(originalGridPos.x, originalGridPos.y), (int x, int y) => inventory2.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);
			inventory2.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_003b: 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 slot.Accepts(item);
			}
			return IsUsableRegularCell(inventory, player, target);
		}

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

		internal static bool TryPrepareCustomEquipmentProjection(Humanoid humanoid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)humanoid != (Object)(object)localPlayer || (Object)(object)localPlayer == (Object)null)
			{
				ClearPreparedCustomEquipmentStatusEffects();
				return false;
			}
			PrepareCustomEquipmentStatusEffects(humanoid, localPlayer);
			return true;
		}

		internal static void ApplyCustomEquipmentProjection(Humanoid humanoid)
		{
			ApplyPreparedCustomEquipmentStatusEffects(humanoid);
		}

		internal static void ClearCustomEquipmentProjection()
		{
			ClearPreparedCustomEquipmentStatusEffects();
		}

		internal static bool ShouldBlockCustomEquipmentStatusRemoval(SEMan seMan, int nameHash)
		{
			return ShouldPreventCustomEquipmentStatusRemoval(seMan, 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 GetProjectedCustomEquipmentArmor(Player player)
		{
			return GetCustomEquipmentArmor(player);
		}

		internal static void ApplyProjectedCustomEquipmentDamageModifiers(Player player, ref DamageModifiers modifiers)
		{
			ApplyCustomEquipmentDamageModifiers(player, ref modifiers);
		}

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

		internal static void FilterCustomEquipmentStatusRemoval(SEMan statusEffects, ref int nameHash)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null && ShouldBlockCustomEquipmentStatusRemoval(statusEffects, nameHash))
			{
				nameHash = 0;
			}
		}

		internal static void AddProjectedEquipmentWeight(Humanoid humanoid, ref float result)
		{
			if (IsLocalPlayerHumanoid(humanoid, out Player player) && (Object)(object)player != (Object)null)
			{
				result += GetProjectedCustomEquipmentWeight(player);
			}
		}

		internal static void AddProjectedEquipmentEitrRegenModifier(Player player, ref float result)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				result += GetProjectedCustomEquipmentEitrRegenModifier(player);
			}
		}

		internal static void AddProjectedBodyArmor(Player player, ref float result)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				result += GetProjectedCustomEquipmentArmor(player);
			}
		}

		internal static void ApplyProjectedArmorDamageModifiers(Player player, ref DamageModifiers mods)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				ApplyProjectedCustomEquipmentDamageModifiers(player, ref mods);
			}
		}

		internal static void OnHumanoidUpdateEquipment(Humanoid humanoid, float dt)
		{
			if (IsLocalPlayerHumanoid(humanoid, out Player player) && (Object)(object)player != (Object)null)
			{
				DrainProjectedCustomEquipmentDurability(humanoid, player, dt);
			}
		}

		internal static void AddProjectedEquipmentSetCount(Humanoid humanoid, string setName, ref int result)
		{
			if (IsLocalPlayerHumanoid(humanoid, out Player player) && (Object)(object)player != (Object)null)
			{
				result += GetProjectedCustomEquipmentSetCount(player, setName);
			}
		}

		internal static void OnPlayerUpdateModifiers(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer && Player.s_equipmentModifierSourceFields != null)
			{
				ApplyProjectedEquipmentModifierValues(player);
			}
		}

		private static bool IsEpicLootLoaded()
		{
			bool valueOrDefault = _epicLootLoaded.GetValueOrDefault();
			if (!_epicLootLoaded.HasValue)
			{
				valueOrDefault = Chainloader.PluginInfos.ContainsKey("randyknapp.mods.epicloot");
				_epicLootLoaded = valueOrDefault;
			}
			return _epicLootLoaded.Value;
		}

		internal static bool IsEpicLootLoadedForPatches()
		{
			return IsEpicLootLoaded();
		}

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

		private static int EnsureForeignSlotItemsPreserved(Player player, Inventory inventory, int minimumHeight, bool recoverToRegularCells, bool warnLockedRows, out bool changed)
		{
			//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_0062: 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_00a6: 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 (TryMoveToFirstFreeRegularCell(player, inventory, item))
						{
							ClearForeignSlotItemState(player, item);
							changed = true;
							InventorySafety.ForeignSlotPreservationWarnings.Remove(GetForeignSlotPreservationWarningKey(item, gridPos));
							Log.LogDebug((object)("Recovered legacy/foreign slot item " + GetForeignSlotItemName(item) + " from " + FormatGridPos(gridPos) + " to regular inventory cell " + FormatGridPos(item.m_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)
			if (item == null)
			{
				return false;
			}
			if (ShouldPreserveForeignSlotHeight(item, expectedFullHeight))
			{
				return true;
			}
			SlotDefinition slot;
			if (IsLegacyExtraSlotsItem(item) && item.m_gridPos.y >= GetFixedRegularRows())
			{
				return !TryGetSlotAtGridPos(inventory, item.m_gridPos, out slot);
			}
			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);
			ForceClearEquipmentReference(player, item);
			if (num)
			{
				ClearSlotActionState(item);
			}
		}

		private static bool ClearLegacyExtraSlotsItemState(ItemData item)
		{
			if (item?.m_customData == null)
			{
				return false;
			}
			return false | item.m_customData.Remove("ExtraSlotsEquippedBy") | item.m_customData.Remove("ExtraSlotsEquippedSlot") | item.m_customData.Remove("ExtraSlotsEquippedWeaponShield");
		}

		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 string GetInventoryItemBigGroupId(ItemData item)
		{
			return ItemClassifierController.GetInventoryItemBigGroupId(ItemClassifierRuntime, item, CraftingRecipeGroupFilters);
		}

		private static bool ItemMatchesBuiltInPredefinedGroup(ItemData item, string groupId)
		{
			return ItemClassifierController.ItemMatchesBuiltInPredefinedGroup(ItemClassifierRuntime, item, groupId);
		}

		private static bool ItemMatchesBuiltInPredefinedGroupUncached(ItemData item, string id)
		{
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Invalid comparison between Unknown and I4
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Invalid comparison between Unknown and I4
			//IL_0592: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Invalid comparison between Unknown and I4
			return id switch
			{
				"all" => true, 
				"healthfood" => MatchHealthFoodCategory(item), 
				"staminafood" => MatchStaminaFoodCategory(item), 
				"eitrfood" => MatchEitrFoodCategory(item), 
				"consumable" => MatchConsumableCategory(item), 
				"mead" => MatchMeadCategory(item), 
				"potion" => MatchPotionCategory(item), 
				"meadbase" => MatchMeadBaseCategory(item), 
				"trophy" => (int)item.m_shared.m_itemType == 13, 
				"valuable" => item.m_shared.m_value > 0, 
				"melee" => MatchMeleeCategory(item), 
				"ranged" => MatchRangedCategory(item), 
				"magic" => MatchMagicCategory(item), 
				"armor" => MatchArmorCategory(item), 
				"equipment" => MatchArmorCategory(item), 
				"food" => MatchFoodCategory(item), 
				"misc" => MatchMiscCategory(item), 
				"legs" => MatchLegsCategory(item), 
				"chest" => MatchChestCategory(item), 
				"helmet" => MatchHelmetCategory(item), 
				"cape" => MatchCapeCategory(item), 
				"utility" => MatchUtilityCategory(item), 
				"trinket" => MatchTrinketCategory(item), 
				"shield" => MatchShieldCategory(item), 
				"axe" => MatchAxeCategory(item), 
				"club" => MatchClubCategory(item), 
				"knife" => MatchKnifeCategory(item), 
				"pickaxe" => MatchPickaxeCategory(item), 
				"polearm" => MatchPolearmCategory(item), 
				"spear" => MatchSpearCategory(item), 
				"sword" => MatchSwordCategory(item), 
				"fists" => MatchFistsCategory(item), 
				"bow" => MatchBowWeaponCategory(item), 
				"crossbow" => MatchCrossbowWeaponCategory(item), 
				"elementalmagic" => (int)item.m_shared.m_skillType == 9, 
				"bloodmagic" => (int)item.m_shared.m_skillType == 10, 
				"tool" => MatchToolCategory(item), 
				"bomb" => MatchBombCategory(item), 
				"arrow" => MatchArrowAmmo(item), 
				"bolt" => MatchBoltAmmo(item), 
				"ammo" => MatchAmmoCategory(item), 
				_ => false, 
			};
		}

		private static string GetItemClassifierCacheSignature()
		{
			return $"{PredefinedGroupDefinitions.Count}|{PredefinedGroupOrders.Count}|{PredefinedGroupOrder.Count}|{CookingStationInputTokens.Count}|{CraftingRecipeFoodInputTokens.Count}|{CraftingRecipeHealthFoodInputTokens.Count}|{CraftingRecipeStaminaFoodInputTokens.Count}|{CraftingRecipeEitrFoodInputTokens.Count}|{CookingStationFoodInputTokens.Count}|{CookingStationHealthFoodInputTokens.Count}|{CookingStationStaminaFoodInputTokens.Count}|{CookingStationEitrFoodInputTokens.Count}|{FermenterInputTokens.Count}|{FermenterOutputTokens.Count}|{FermenterFoodInputTokens.Count}|{FermenterHealthFoodInputTokens.Count}|{FermenterStaminaFoodInputTokens.Count}|{FermenterEitrFoodInputTokens.Count}";
		}

		private static string GetItemClassifierCacheKey(ItemData item)
		{
			return string.Join("|", GetItemPrefabName(item), GetSharedName(item), ((object)(ItemType)(ref item.m_shared.m_itemType)).ToString(), ((object)(SkillType)(ref item.m_shared.m_skillType)).ToString(), ((object)(ItemType)(ref item.m_shared.m_attachOverride)).ToString(), ((object)(AnimationState)(ref item.m_shared.m_animationState)).ToString(), ((object)(AttackType)(ref item.m_shared.m_attack.m_attackType)).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()
		{
			ItemClassifierController.ClearCaches(ItemClassifierRuntime);
		}

		private static bool IsWeaponItemType(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_0014: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)itemType <= 15)
			{
				if (itemType - 3 <= 1 || itemType - 14 <= 1)
				{
					goto IL_001e;
				}
			}
			else if ((int)itemType == 20 || (int)itemType == 22)
			{
				goto IL_001e;
			}
			return false;
			IL_001e:
			return true;
		}

		private static bool ItemTypeTokenMatches(ItemType itemType, string token)
		{
			//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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_007c: 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: Invalid comparison between Unknown and I4
			//IL_006f: 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_0073: Invalid comparison between Unknown and I4
			//IL_0092: 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_0086: Invalid comparison between Unknown and I4
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Invalid comparison between Unknown and I4
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			if (Enum.TryParse<ItemType>(token, ignoreCase: true, out ItemType result))
			{
				return itemType == result;
			}
			bool result2;
			switch (NormalizeGroupId(token))
			{
			case "legs":
				return (int)itemType == 11;
			case "cape":
				return (int)itemType == 17;
			case "armor":
				if ((int)itemType <= 11)
				{
					if (itemType - 6 <= 1 || (int)itemType == 11)
					{
						goto IL_0088;
					}
				}
				else if (itemType - 17 <= 1 || (int)itemType == 24)
				{
					goto IL_0088;
				}
				result2 = false;
				goto IL_008e;
			case "weapon":
				return IsWeaponItemType(itemType);
			case "ammo":
				return (int)itemType == 9 || (int)itemType == 23;
			default:
				{
					return false;
				}
				IL_008e:
				return result2;
				IL_0088:
				result2 = true;
				goto IL_008e;
			}
		}

		private static bool SkillTypeTokenMatches(SkillType skillType, string token)
		{
			//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_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Invalid comparison between Unknown and I4
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Invalid comparison between Unknown and I4
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Invalid comparison between Unknown and I4
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Invalid comparison between Unknown and I4
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Invalid comparison between Unknown and I4
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Invalid comparison between Unknown and I4
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Invalid comparison between Unknown and I4
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Invalid comparison between Unknown and I4
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Invalid comparison between Unknown and I4
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Invalid comparison between Unknown and I4
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Invalid comparison between Unknown and I4
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Invalid comparison between Unknown and I4
			if (Enum.TryParse<SkillType>(token, ignoreCase: true, out SkillType result))
			{
				return skillType == result;
			}
			return NormalizeGroupId(token) switch
			{
				"axe" => (int)skillType == 7, 
				"club" => (int)skillType == 3, 
				"knife" => (int)skillType == 2, 
				"pickaxe" => (int)skillType == 12, 
				"polearm" => (int)skillType == 4, 
				"spear" => (int)skillType == 5, 
				"sword" => (int)skillType == 1, 
				"fists" => (int)skillType == 11, 
				"bow" => (int)skillType == 8, 
				"crossbow" => (int)skillType == 14, 
				"elementalmagic" => (int)skillType == 9, 
				"bloodmagic" => (int)skillType == 10, 
				_ => false, 
			};
		}

		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 (!IsNativeFoodCategory(item) && !MatchStationFoodInputCategory(item))
			{
				return MatchConfiguredCustomGroupInCraftingGroup(item, "food");
			}
			return true;
		}

		private static bool MatchHealthFoodCategory(ItemData item)
		{
			if (!IsNativeFoodCategory(item) || !TryGetDominantFoodStat(item, out var stat) || stat != FoodStat.Health)
			{
				return MatchStationFoodInputStat(item, FoodStat.Health);
			}
			return true;
		}

		private static bool MatchStaminaFoodCategory(ItemData item)
		{
			if (!IsNativeFoodCategory(item) || !TryGetDominantFoodStat(item, out var stat) || stat != FoodStat.Stamina)
			{
				return MatchStationFoodInputStat(item, FoodStat.Stamina);
			}
			return true;
		}

		private static bool MatchEitrFoodCategory(ItemData item)
		{
			if (!IsNativeFoodCategory(item) || !TryGetDominantFoodStat(item, out var stat) || stat != FoodStat.Eitr)
			{
				return MatchStationFoodInputStat(item, FoodStat.Eitr);
			}
			return true;
		}

		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 MatchStationFoodInputCategory(ItemData item)
		{
			if (!ItemMatchesStationInput(CraftingRecipeFoodInputTokens, item) && !ItemMatchesStationInput(CookingStationFoodInputTokens, item))
			{
				return ItemMatchesStationInput(FermenterFoodInputTokens, item);
			}
			return true;
		}

		private static bool MatchStationFoodInputStat(ItemData item, FoodStat stat)
		{
			return stat switch
			{
				FoodStat.Health => ItemMatchesStationInput(CraftingRecipeHealthFoodInputTokens, item) || ItemMatchesStationInput(CookingStationHealthFoodInputTokens, item) || ItemMatchesStationInput(FermenterHealthFoodInputTokens, item), 
				FoodStat.Stamina => ItemMatchesStationInput(CraftingRecipeStaminaFoodInputTokens, item) || ItemMatchesStationInput(CookingStationStaminaFoodInputTokens, item) || ItemMatchesStationInput(FermenterStaminaFoodInputTokens, item), 
				FoodStat.Eitr => ItemMatchesStationInput(CraftingRecipeEitrFoodInputTokens, item) || ItemMatchesStationInput(CookingStationEitrFoodInputTokens, item) || ItemMatchesStationInput(FermenterEitrFoodInputTokens, item), 
				_ => false, 
			};
		}

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

		[IteratorStateMachine(typeof(<GetItemIdentityTokens>d__1036))]
		private static IEnumerable<string> GetItemIdentityTokens(ItemData item)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetItemIdentityTokens>d__1036(-2)
			{
				<>3__item = item
			};
		}

		private static bool MatchConsumableCategory(ItemData item)
		{
			if (!MatchMeadBaseCategory(item) && !MatchStationFoodInputCategory(item))
			{
				if (!MatchMeadCategory(item) && !MatchPotionCategory(item))
				{
					return MatchConfiguredCustomGroupInCraftingGroup(item, "consumable");
				}
				return true;
			}
			return false;
		}

		private static bool MatchMeadCategory(ItemData item)
		{
			if (!MatchMeadBaseCategory(item) && !MatchStationFoodInputCategory(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 (!MatchFoodCategory(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 (!MatchStationFoodInputCategory(item))
			{
				if (!ItemMatchesStationInput(FermenterInputTokens, item))
				{
					return MatchConfiguredCustomGroupInCraftingGroup(item, "meadbase");
				}
				return true;
			}
			return false;
		}

		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 (!MatchFoodCategory(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 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;
		}

		private static bool TryGetDominantFoodStat(ItemData item, out FoodStat stat)
		{
			stat = FoodStat.None;
			float foodHealth = GetFoodHealth(item);
			float foodStamina = GetFoodStamina(item);
			float foodEitr = GetFoodEitr(item);
			if (foodHealth <= 0f && foodStamina <= 0f && foodEitr <= 0f)
			{
				return false;
			}
			if (foodHealth > foodStamina && foodHealth > foodEitr)
			{
				stat = FoodStat.Health;
				return true;
			}
			if (foodStamina > foodHealth && foodStamina > foodEitr)
			{
				stat = FoodStat.Stamina;
				return true;
			}
			if (foodEitr > foodHealth && foodEitr > foodStamina)
			{
				stat = FoodStat.Eitr;
				return true;
			}
			return false;
		}

		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 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;
			}
			ItemSortController.EnsureRecipeOutputLookupCache(InventorySort);
			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 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(InventorySort, "prefab", GetItemPrefabName(itemData), recipe);
				AddRecipeOutputLookupToken(InventorySort, "prefab", CleanPrefabName(((Object)recipe.m_item).name), recipe);
				AddRecipeOutputLookupToken(InventorySort, "name", itemData.m_shared.m_name, recipe);
			}
		}

		private static void AddRecipeOutputLookupToken(InventorySortRuntimeState state, string kind, string? token, Recipe recipe)
		{
			if (!string.IsNullOrWhiteSpace(token))
			{
				string text = CleanPrefabName(token);
				string recipeOutputLookupKey = GetRecipeOutputLookupKey(kind, text);
				if (!string.IsNullOrWhiteSpace(text) && !state.RecipeOutputLookupCache.ContainsKey(recipeOutputLookupKey))
				{
					state.RecipeOutputLookupCache[recipeOutputLookupKey] = recipe;
				}
			}
		}

		[IteratorStateMachine(typeof(<GetItemRecipeLookupTokens>d__1094))]
		private static IEnumerable<string> GetItemRecipeLookupTokens(ItemData item)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetItemRecipeLookupTokens>d__1094(-2)
			{
				<>3__item = item
			};
		}

		private static string GetRecipeOutputLookupKey(string kind, string token)
		{
			return kind + ":" + CleanPrefabName(token);
		}

		private static void ClearInventorySortCaches()
		{
			ItemSortController.ClearCaches(InventorySort);
		}

		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 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 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 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 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()
		{
			CompatRuntime.LastJewelcraftingRingSlotEnabled = IsJewelcraftingRingSlotEnabled();
			CompatRuntime.LastJewelcraftingNecklaceSlotEnabled = IsJewelcraftingNecklaceSlotEnabled();
			CompatRuntime.JewelcraftingSlotStateInitialized = true;
		}

		private static void RefreshJewelcraftingSlotDefinitionsIfNeeded(Player? player)
		{
			if (!HasJewelcraftingActive)
			{
				return;
			}
			bool flag = IsJewelcraftingRingSlotEnabled();
			bool flag2 = IsJewelcraftingNecklaceSlotEnabled();
			if (!CompatRuntime.JewelcraftingSlotStateInitialized)
			{
				CompatRuntime.LastJewelcraftingRingSlotEnabled = flag;
				CompatRuntime.LastJewelcraftingNecklaceSlotEnabled = flag2;
				CompatRuntime.JewelcraftingSlotStateInitialized = true;
			}
			else if (flag != CompatRuntime.LastJewelcraftingRingSlotEnabled || flag2 != CompatRuntime.LastJewelcraftingNecklaceSlotEnabled)
			{
				CompatRuntime.LastJewelcraftingRingSlotEnabled = flag;
				CompatRuntime.LastJewelcraftingNecklaceSlotEnabled = flag2;
				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 ex)
			{
				Log.LogDebug((object)("Failed to clear Jewelcrafting " + (isRing ? "ring" : "necklace") + " visual state: " + ex.Message));
			}
		}

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

		private static void SanitizeJewelcraftingElementClone(GameObject? root, bool restoreVanillaEquipped)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null || IsUnityNull((Object?)(object)root))
			{
				return;
			}
			if (restoreVanillaEquipped)
			{
				RestoreVanillaEquippedOverlay(root.transform);
			}
			Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)(object)root.transform || !IsJewelcraftingUiDecoration(val))
				{
					continue;
				}
				((Component)val).gameObject.SetActive(false);
				Graphic[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Graphic>(true);
				foreach (Graphic obj in componentsInChildren2)
				{
					Image val2 = (Image)(object)((obj is Image) ? obj : null);
					if (val2 != null)
					{
						val2.sprite = null;
					}
					obj.color = Color.clear;
					obj.raycastTarget = false;
				}
			}
		}

		private static void RestoreVanillaEquippedOverlay(Transform root)
		{
			Transform val = root.Find("equiped_jc_disabled");
			if (!((Object)(object)val == (Object)null))
			{
				Transform val2 = root.Find("equiped");
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)val)
				{
					((Object)val2).name = "InventorySlots_JewelcraftingEquippedDisabled";
					((Component)val2).gameObject.SetActive(false);
				}
				((Object)val).name = "equiped";
				((Component)val).gameObject.SetActive(false);
				Image val3 = default(Image);
				if (((Component)val).TryGetComponent<Image>(ref val3))
				{
					((Behaviour)val3).enabled = true;
					((Graphic)val3).raycastTarget = false;
				}
			}
		}

		private static bool IsJewelcraftingUiDecoration(Transform transform)
		{
			string name = ((Object)transform).name;
			if (!string.Equals(name, "JC_ItemBackground", StringComparison.Ordinal) && !string.Equals(name, "JC_SelectedItem", StringComparison.Ordinal) && !string.Equals(name, "InventorySlots_JewelcraftingEquippedDisabled", StringComparison.Ordinal) && !string.Equals(name, "TrannyHoles", StringComparison.Ordinal) && !string.Equals(name, "Transmute_Press_Interact", StringComparison.Ordinal) && !string.Equals(name, "Bkg (1)", StringComparison.Ordinal) && !name.StartsWith("Transmute_", StringComparison.Ordinal) && name.IndexOf("Socket", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.StartsWith("JC_", StringComparison.Ordinal);
			}
			return true;
		}

		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 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 ex)
			{
				Log.LogDebug((object)("Jewelcrafting API.GetGems icon read failed for " + GetItemPrefabName(item) + ": " + ex.Message));
			}
			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 int GetJewelcraftingSocketEntryCountFromCustomData(ItemData item)
		{
			int num = 0;
			if (item.m_customData == null || item.m_customData.Count == 0)
			{
				return num;
			}
			foreach (KeyValuePair<string, string> customDatum in item.m_customData)
			{
				if (IsJewelcraftingSocketDataKey(customDatum.Key) && !string.IsNullOrWhiteSpace(customDatum.Value))
				{
					string text = customDatum.Value.Split(new char[1] { '|' })[0];
					if (!string.IsNullOrEmpty(text))
					{
						num = Math.Max(num, text.Split(new char[1] { ',' }).Length);
					}
				}
			}
			return num;
		}

		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 void ConfigureInventoryJewelcraftingGemIconTooltips(RectTransform root, ItemData item)
		{
			List<JewelcraftingGemIconData> jewelcraftingGemIconData = GetJewelcraftingGemIconData(item);
			if (jewelcraftingGemIconData.Count == 0)
			{
				return;
			}
			bool[] array = new bool[jewelcraftingGemIconData.Count];
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(false);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)val.sprite == (Object)null || IsUnityNull((Object?)(object)val.sprite))
				{
					continue;
				}
				int num = FindMatchingJewelcraftingGemIcon(jewelcraftingGemIconData, array, val.sprite);
				if (num >= 0 && !string.IsNullOrWhiteSpace(jewelcraftingGemIconData[num].DisplayName))
				{
					array[num] = true;
					if (IsPinnedTooltipTransform(((Component)val).transform))
					{
						ConfigurePinnedGemIconTooltip(((Graphic)val).rectTransform, jewelcraftingGemIconData[num].DisplayName);
					}
					else
					{
						ConfigureCraftingGemIconTooltip(((Graphic)val).rectTransform, jewelcraftingGemIconData[num].DisplayName);
					}
				}
			}
		}

		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)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)
		{
			if (item?.m_shared == null)
			{
				HideJewelcraftingTooltipRoot(ref cachedRoot);
				return false;
			}
			string jewelcraftingTooltipUpdateSignature = 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, jewelcraftingTooltipUpdateSignature, 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, jewelcraftingTooltipUpdateSignature, out var visible2))
			{
				return visible2;
			}
			return RebuildJewelcraftingNativeTooltip(val, item, item, showInteract, jewelcraftingTooltipUpdateSignature, 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 ShouldLetNativeJewelcraftingInventoryTooltipOwnHover(UITooltip tooltip)
		{
			if (!HasJewelcraftingActive || (Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip) || !IsInventoryContainerTooltipSource(tooltip))
			{
				return false;
			}
			InventoryHoverTooltipItemSource? inventoryContainerHoverTooltipItemSource = GetInventoryContainerHoverTooltipItemSource(tooltip);
			if (inventoryContainerHoverTooltipItemSource?.Item?.m_shared == null || !ShouldAttemptJewelcraftingPinnedTooltip(inventoryContainerHoverTooltipItemSource.Value.Item))
			{
				return false;
			}
			RectTransform sourceRoot;
			if (!IsJewelcraftingSocketTooltipSource(tooltip))
			{
				return TryGetLiveJewelcraftingTooltipSource(tooltip, inventoryContainerHoverTooltipItemSource.Value.Item, out sourceRoot);
			}
			return true;
		}

		private static bool TryGetLiveJewelcraftingTooltipSource(UITooltip? tooltip, ItemData? item, out RectTransform? sourceRoot)
		{
			sourceRoot = null;
			if (!HasJewelcraftingActive || (Object)(object)tooltip == (Object)null || IsUnityNull((Object?)(object)tooltip) || item?.m_shared == null || !IsJewelcraftingSocketTooltipSource(tooltip))
			{
				return false;
			}
			InventoryHoverTooltipItemSource? inventoryContainerHoverTooltipItemSource = GetInventoryContainerHoverTooltipItemSource(tooltip);
			if (inventoryContainerHoverTooltipItemSource?.Item?.m_shared != null && !CanUseJewelcraftingTooltipSourceItem(item, inventoryContainerHoverTooltipItemSource.Value.Item))
			{
				return false;
			}
			GameObject tooltip2 = UITooltip.m_tooltip;
			Transform val = (((Object)(object)tooltip2 != (Object)null && !IsUnityNull((Object?)(object)tooltip2)) ? tooltip2.transform.Find("Bkg (1)") : null);
			sourceRoot = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)sourceRoot != (Object)null)
			{
				return !IsUnityNull((Object?)(object)sourceRoot);
			}
			return false;
		}

		private static bool IsJewelcraftingSocketTooltipSource(UITooltip tooltip)
		{
			if (!TryGetJewelcraftingTooltipApi(out JewelcraftingTooltipApi api) || api == null)
			{
				return false;
			}
			GameObject socketTooltip = api.GetSocketTooltip();
			if ((Object)(object)socketTooltip == (Object)null || IsUnityNull((Object?)(object)socketTooltip))
			{
				return false;
			}
			if ((Object)(object)tooltip.m_tooltipPrefab == (Object)(object)socketTooltip)
			{
				return true;
			}
			GameObject tooltip2 = UITooltip.m_tooltip;
			if ((Object)(object)tooltip2 == (Object)null || IsUnityNull((Object?)(object)tooltip2))
			{
				return false;
			}
			return string.Equals(Utils.GetPrefabName(tooltip2), ((Object)socketTooltip).name, StringComparison.Ordinal);
		}

		private static bool CanUseJewelcraftingTooltipSourceItem(ItemData requested, ItemData source)
		{
			if (requested == source)
			{
				return true;
			}
			if (requested.m_shared != null && source.m_shared != null && string.Equals(GetItemPrefabName(requested), GetItemPrefabName(source), StringComparison.Ordinal) && string.Equals(requested.m_shared.m_name, source.m_shared.m_name, StringComparison.Ordinal) && requested.m_variant == source.m_variant && requested.m_quality == source.m_quality)
			{
				return GetItemCustomDataOrderIndependentHash(requested) == GetItemCustomDataOrderIndependentHash(source);
			}
			return false;
		}

		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 ex)
			{
				Log.LogDebug((object)("Jewelcrafting API.GetGems preflight failed for " + GetItemPrefabName(item) + ": " + ex.Message));
				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_00b4: 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_00d6: 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)
			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 num = Mathf.Max(1f, text.GetPreferredValues(text.text ?? "", width, 0f).y);
			text.ForceMeshUpdate(true, false);
			float num2 = num;
			Bounds textBounds = text.textBounds;
			num = Mathf.Max(num2, ((Bounds)(ref textBounds)).size.y);
			rectTransform.sizeDelta = new Vector2(width, num);
			return num;
		}

		private static float LayoutJewelcraftingNativeSocketRow(RectTransform row, float width, float y)
		{
			//IL_018a: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: 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_01e9: 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_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_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: 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_028d: 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_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: 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_0323: 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_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0158: 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)
			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 = Mathf.Max(1f, text.GetPreferredValues(text.text ?? "", num2, 0f).y);
				text.ForceMeshUpdate(true, false);
				float num4 = num3;
				Bounds textBounds = text.textBounds;
				num3 = Mathf.Max(num4, ((Bounds)(ref textBounds)).size.y);
			}
			float num5 = 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, num5);
			((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, num5) : new Vector2(num2, num5));
			}
			return num5;
		}

		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))
			{
				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 ex)
			{
				Log.LogDebug((object)("Jewelcrafting tooltip update failed: " + ex.Message));
				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)
		{
			cache.Signature = signature;
			cache.Visible = visible;
			cache.HasResolvedSocketGems = hasSocketRows;
			UpdateJewelcraftingTooltipCacheItemIdentity(cache, item);
			((Component)root).gameObject.SetActive(visible);
		}

		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 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)
			{
				CompatRuntime.LastMagicSupremacyBeltCompatItem = null;
				return;
			}
			ItemData val = FindCustomEquippedItem(player, IsMagicSupremacyBeltItem);
			if (val != CompatRuntime.LastMagicSupremacyBeltCompatItem)
			{
				if (CompatRuntime.LastMagicSupremacyBeltCompatItem != null)
				{
					api.ClearBeltIfCurrent(player, CompatRuntime.LastMagicSupremacyBeltCompatItem);
				}
				CompatRuntime.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);
				CompatRuntime.LastMagicSupremacyBeltCompatItem = item;
			}
		}

		private static void OnMagicSupremacyBeltUnequipping(Player player, ItemData item)
		{
			if (!((Object)(object)player == (Object)null) && item != null && (CompatRuntime.LastMagicSupremacyBeltCompatItem == item || IsMagicSupremacyBeltItem(item)) && TryGetMagicSupremacyApi(out MagicSupremacyApi api) && api != null)
			{
				api.ClearBeltIfCurrent(player, item);
				if (CompatRuntime.LastMagicSupremacyBeltCompatItem == item)
				{
					CompatRuntime.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);
		}

		private static void ApplyMyLittleUICraftingCompatibility()
		{
			if (CompatRuntime.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);
				}
			}
			CompatRuntime.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)
		{
			InventoryGui gui2 = gui;
			return $"{rootSignature}|{adapter.Kind}|applied={_craftingRedesignApplied}|craft={SafeReadBool(() => gui2.InCraftTab())}|upgrade={SafeReadBool(() => gui2.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)
		{
			string name2 = name;
			if (!MyLittleUICraftingObjectNames.Contains<string>(name2, StringComparer.Ordinal))
			{
				return MyLittleUICraftingObjectPrefixes.Any((string prefix) => name2.StartsWith(prefix, StringComparison.Ordinal));
			}
			return true;
		}

		private static bool IsMyLittleUIActive()
		{
			if (!_myLittleUIPluginPresenceResolved)
			{
				_myLittleUIPluginDetected = HasPlugin("shudnal.MyLittleUI");
				_myLittleUIPluginPresenceResolved = true;
			}
			return _myLittleUIPluginDetected;
		}

		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_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)
			Inventory inventory2 = inventory;
			Player player2 = player;
			InventorySlotSafetyCore.GridCell cell;
			bool result = InventorySlotSafetyCore.TrySelectFirstFreeCell(inventory2.GetWidth(), GetUsableRegularRows(player2), (int x, int y) => IsUsableRegularCell(inventory2, player2, new Vector2i(x, y)), (int x, int y) => inventory2.GetItemAt(x, y) != null, 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_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_0070: 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)
			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))
			{
				Log.LogDebug((object)string.Format("Redirected unsafe inventory insert for {0} from {1} to {2}.", item.m_shared?.m_name ?? "<unknown>", pos, pos2));
				pos = pos2;
				return true;
			}
			return false;
		}

		private static bool TryFindSafeInsertCell(Player player, Inventory inventory, ItemData item, out Vector2i pos)
		{
			//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_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_0048: 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_005b: 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 (TryFindFreeRegularCell(player, inventory, out pos))
			{
				return true;
			}
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (IsQuickSlotUnlocked(player, slotDefinition) && slotDefinition.Accepts(item) && FindItemForSlot(player, inventory, slotDefinition) == null)
				{
					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_001f: 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;
			}
			if (flag)
			{
				if (TryGetSlotAtGridPos(inventory, pos, out SlotDefinition slot))
				{
					return slot.Accepts(item);
				}
				return false;
			}
			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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			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;
				}
				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 IsRegularActionItem(Player player, Inventory inventory, ItemData item, bool includeHotbar)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			InventoryCellKind inventoryCellKind = GetInventoryCellKind(player, inventory, item.m_gridPos);
			if (inventoryCellKind != InventoryCellKind.RegularUnlocked)
			{
				if (includeHotbar)
				{
					return inventoryCellKind == InventoryCellKind.Hotbar;
				}
				return false;
			}
			return true;
		}

		private static bool IsFavoriteProtected(Player player, Inventory inventory, ItemData item)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (AreFavoritesEnabled())
			{
				return IsFavoriteSlot(player, item.m_gridPos);
			}
			return false;
		}

		private static bool IsFavoriteSlot(Player player, Vector2i pos)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!AreFavoritesEnabled())
			{
				return false;
			}
			EnsureFavoritesLoaded(player);
			return FavoriteSlots.Contains(pos);
		}

		private static bool AreFavoritesEnabled()
		{
			return true;
		}

		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 (!LoadPreservationInventoryDepth.ContainsKey(inventory))
			{
				return InventoryPlacementScope.General;
			}
			return InventoryPlacementScope.LoadPreservation;
		}

		internal static bool TryOverrideFindEmptySlot(Inventory inventory, ref Vector2i result)
		{
			//IL_0034: 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_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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Player player;
			switch (GetInventoryPlacementScope(inventory, out player))
			{
			case InventoryPlacementScope.LoadPreservation:
				result = FindTopFirstRegularLoadPreservationSlot(inventory);
				return false;
			case InventoryPlacementScope.LocalPlayer:
			{
				result = (Vector2i)(TryFindFreeRegularCell(player, inventory, out var pos) ? pos : new Vector2i(-1, -1));
				return false;
			}
			default:
				result = FindTopFirstEmptySlot(inventory);
				return false;
			}
		}

		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 FindTopFirstEmptySlot(Inventory inventory)
		{
			//IL_0005: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null)
			{
				return new Vector2i(-1, -1);
			}
			for (int i = 0; i < inventory.GetHeight(); i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					if (inventory.GetItemAt(j, i) == null)
					{
						return new Vector2i(j, i);
					}
				}
			}
			return new Vector2i(-1, -1);
		}

		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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory2 = inventory;
			int rowCount = Math.Min(GetFixedRegularRows(), inventory2.GetHeight());
			InventorySlotSafetyCore.GridCell cell;
			bool result = InventorySlotSafetyCore.TrySelectFirstFreeCell(inventory2.GetWidth(), rowCount, (int x, int y) => !IsExternalReservedForCompat(new Vector2i(x, y)), (int x, int y) => inventory2.GetItemAt(x, y) != null, 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_001d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = Math.Min(GetFixedRegularRows(), inventory.GetHeight());
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					if (!IsExternalReservedForCompat(new Vector2i(j, i)) && inventory.GetItemAt(j, i) == null)
					{
						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)
		{
			InventoryAddItemDataStackLookupItems.Push(item);
			return true;
		}

		internal static void EndInventoryAddItemDataStackLookup(bool active)
		{
			if (active && InventoryAddItemDataStackLookupItems.Count > 0)
			{
				InventoryAddItemDataStackLookupItems.Pop();
			}
		}

		private static ItemData? GetCurrentInventoryAddItemDataStackLookupItem()
		{
			if (InventoryAddItemDataStackLookupItems.Count <= 0)
			{
				return null;
			}
			return InventoryAddItemDataStackLookupItems.Peek();
		}

		internal static bool TryOverrideGetEmptySlots(Inventory inventory, ref int result)
		{
			Player player;
			switch (GetInventoryPlacementScope(inventory, out player))
			{
			case InventoryPlacementScope.LoadPreservation:
				result = CountRegularLoadPreservationEmptyCells(inventory);
				return false;
			case InventoryPlacementScope.LocalPlayer:
				result = CountUsableRegularEmptyCells(inventory, player);
				return false;
			default:
				return true;
			}
		}

		private static int CountUsableRegularEmptyCells(Inventory inventory, Player player)
		{
			//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) && inventory.GetItemAt(j, i) == null)
					{
						num++;
					}
				}
			}
			return num;
		}

		internal static bool TryOverrideHaveEmptySlot(Inventory inventory, ref bool result)
		{
			Player player;
			Vector2i pos;
			switch (GetInventoryPlacementScope(inventory, out player))
			{
			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 void OnInventoryCanAddItem(Inventory inventory, ItemData item, int stack, ref bool result)
		{
			if (!result && item != null && stack <= 1 && TryGetLocalPlayerInventory(inventory, out Player player))
			{
				result = CanAutoPlaceItemInSpecialSlot(player, inventory, item);
			}
		}

		internal static void OnInventoryAddItemData(Inventory inventory, ItemData item, ref bool result)
		{
			if (!result && item != null && TryGetLocalPlayerInventory(inventory, out Player player))
			{
				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)
			Inventory inventory2 = inventory;
			ItemData item2 = item;
			if (item2 == null || !TryPrepareLoadPreservationTailInsert(inventory2, target))
			{
				return false;
			}
			EnsureInventoryHeightForLoad(inventory2);
			if (target.y >= inventory2.GetHeight())
			{
				inventory2.m_height = target.y + 1;
			}
			if (InventorySlotSafetyCore.TrySelectLoadPreservationTailCell(inventory2.GetWidth(), inventory2.GetHeight(), GetFixedRegularRows(), new InventorySlotSafetyCore.GridCell(target.x, target.y), (int x, int y) => IsInventoryCellOccupiedByOtherItem(inventory2, item2, x, y), out var selectedCell))
			{
				target = new Vector2i(selectedCell.X, selectedCell.Y);
				if (target.y >= inventory2.GetHeight())
				{
					inventory2.m_height = target.y + 1;
				}
			}
			item2.m_gridPos = target;
			if (!inventory2.ContainsItem(item2))
			{
				inventory2.m_inventory.Add(item2);
			}
			result = true;
			return true;
		}

		private static bool TryPrepareLoadPreservationTailInsert(Inventory inventory, Vector2i target)
		{
			//IL_0011: 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)
			if (inventory == null || !LoadPreservationInventoryDepth.ContainsKey(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, ItemData item, ref int x, ref int y)
		{
			//IL_0018: 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)
			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);
			}
		}

		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 && LoadPreservationInventoryDepth.TryGetValue(inventory, out var value))
			{
				if (value <= 1)
				{
					LoadPreservationInventoryDepth.Remove(inventory);
				}
				else
				{
					LoadPreservationInventoryDepth[inventory] = value - 1;
				}
			}
		}

		internal static void PreparePlayerInventoryForLoad(Player player)
		{
			if (!IsUnityNull((Object?)(object)player))
			{
				EnsureInventoryHeightForLoad(((Humanoid)player).GetInventory());
			}
		}

		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 BeginInventoryLoadPreservation(Inventory? inventory)
		{
			if (inventory == null)
			{
				return false;
			}
			LoadPreservationInventoryDepth.TryGetValue(inventory, out var value);
			LoadPreservationInventoryDepth[inventory] = value + 1;
			return true;
		}

		private static bool ShouldPreserveProgressiveRowsDuringLoad(Inventory inventory, Player? player)
		{
			if (inventory != null)
			{
				if (!LoadPreservationInventoryDepth.ContainsKey(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)
		{
			InvalidateCustomEquipmentProjectionCache();
			EnsureInventoryState(player, InventoryStateEnsureReason.PlayerAwake);
		}

		internal static void OnPlayerSpawned(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				InvalidateCustomEquipmentProjectionCache();
				EnsureInventoryState(player, InventoryStateEnsureReason.PlayerSpawned);
			}
		}

		internal static void OnPlayerLoaded(Player player)
		{
			InvalidateCustomEquipmentProjectionCache();
			ClearPendingSlotActions();
			EnsureInventoryState(player, InventoryStateEnsureReason.PlayerLoad);
			TryRestoreSlotBackup(player);
			EnsureInventoryState(player, InventoryStateEnsureReason.BackupRestore);
		}

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

		internal static void OnPlayerInventoryChanged(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer && !player.m_isLoading)
			{
				InvalidateCustomEquipmentProjectionCache();
				ClearCraftingRequirementAvailabilityCache();
				RequestInventoryStateEnsure(player, InventoryStateEnsureReason.InventoryChanged, 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))
			{
				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()
		{
			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()
		{
			StartQuickSlotPanelOutroAnimation();
			PrunePendingSlotActions();
			RestoreContainerPanelPosition();
			RestoreContainerWeightPanelPosition();
			RestorePlayerStatPanels();
			HideInventoryActionPanels();
			HideCraftingPanelRedesign();
			HideInventoryPinnedTooltips();
			HideInventoryOwnedHoverTooltips();
			ClearInventoryHoverTooltipSources();
		}

		internal static void OnInventoryGuiCloseContainer()
		{
			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 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_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_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_0229: 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_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Expected O, but got Unknown
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: 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_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: 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;
			bool num = CanMutateContainerDirectly(currentContainer, allowLocalWithoutZNetView: true);
			bool flag = num || CanUseContainerThroughOwnerOrMultiUserChest(currentContainer);
			SetActionButtonLabel(gui.m_takeAllButton, LocalizeUi("$inventoryslots_button_take_all", "Take all"));
			SetActionButtonLabel(gui.m_stackAllButton, LocalizeUi("$inventoryslots_button_place_stacks", "Place stacks"));
			if (!num)
			{
				HideContainerMutationButtons();
				InventoryPanels.ContainerSortButton = EnsureContainerSortButton(val4, takeAllButton, GetContainerSortButtonSize(gui), Vector2.op_Implicit(ContainerSortButtonFixedOffset));
				SetButtonActive(InventoryPanels.ContainerSortButton, flag);
				SetButtonInteractable(InventoryPanels.ContainerSortButton, flag);
				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__1489_0;
			if (obj == null)
			{
				UnityAction val5 = delegate
				{
					StoreAllToCurrentContainer(Player.m_localPlayer);
				};
				<>c.<>9__1489_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__1489_1;
			if (obj2 == null)
			{
				UnityAction val6 = delegate
				{
					RestockFromCurrentContainer(Player.m_localPlayer);
				};
				<>c.<>9__1489_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__1491_0;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					SortPlayerInventory(Player.m_localPlayer);
				};
				<>c.<>9__1491_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__1498_0;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					SortCurrentContainer(Player.m_localPlayer);
				};
				<>c.<>9__1498_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;
		}

		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 = slot.Name;
					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);
			if ((Object)(object)inventoryGridElementUiCache != (Object)null && 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))
					{
						Log.LogInfo((object)string.Format("[TooltipDiag] custom slot CreateItemTooltip produced empty text for prefab={0}, topicLen={1}. Falling back to ItemData.GetTooltip.", GetItemPrefabName(item), (element.m_tooltip.m_topic ?? "").Length));
						SetDirectEquipmentSlotTooltip(element, item);
					}
					if ((Object)(object)inventoryGridElementUiCache != (Object)null)
					{
						inventoryGridElementUiCache.EquipmentTooltipSignature = equipmentSlotTooltipSignature;
					}
					return;
				}
			}
			catch (Exception ex)
			{
				Log.LogDebug((object)("Custom slot tooltip refresh fell back to direct item tooltip: " + ex.Message));
			}
			SetDirectEquipmentSlotTooltip(element, item);
			if ((Object)(object)inventoryGridElementUiCache != (Object)null)
			{
				inventoryGridElementUiCache.EquipmentTooltipSignature = equipmentSlotTooltipSignature;
			}
		}

		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))
			{
				Log.LogInfo((object)string.Format("[TooltipDiag] InventoryGrid.CreateItemTooltip has empty text and fallback was empty for prefab={0}, topicLen={1}.", GetItemPrefabName(item), (tooltip.m_topic ?? "").Length));
				return;
			}
			EnsureTooltipPrefab(tooltip);
			if (string.IsNullOrWhiteSpace(tooltip.m_topic))
			{
				tooltip.m_topic = item.m_shared.m_name;
			}
			tooltip.m_text = tooltip2;
			Log.LogInfo((object)$"[TooltipDiag] Filled empty InventoryGrid.CreateItemTooltip text for prefab={GetItemPrefabName(item)}, fallbackLen={tooltip2.Length}.");
		}

		private static void ResetEquipmentSlotTooltipCache(Element element)
		{
			InventoryGridElementUiCache inventoryGridElementUiCache = GetInventoryGridElementUiCache(element);
			if ((Object)(object)inventoryGridElementUiCache != (Object)null)
			{
				inventoryGridElementUiCache.EquipmentTooltipSignature = "";
			}
		}

		private static string GetEquipmentSlotTooltipSignature(ItemData item)
		{
			string itemPrefabName = GetItemPrefabName(item);
			Dictionary<string, string> customData = item.m_customData;
			string text = ((customData != null && customData.Count > 0) ? string.Join(";", from pair in item.m_customData.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key, StringComparer.Ordinal)
				select pair.Key + "=" + pair.Value) : "");
			int num = Mathf.RoundToInt(item.m_durability * 1000f);
			return string.Join("|", itemPrefabName, 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, text);
		}

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

		private static void EnsureClientStateLoaded()
		{
			if (InventoryClient.ClientStateLoaded)
			{
				return;
			}
			InventoryClient.ClientStateLoaded = true;
			InventoryClient.ClientState = new InventorySlotsClientState();
			if (!File.Exists(ClientStateFilePath))
			{
				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(Paths.ConfigPath);
				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 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 (!AreFavoritesEnabled() || (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)
			InventoryCellKind inventoryCellKind = GetInventoryCellKind(player, inventory, pos);
			if (inventoryCellKind != InventoryCellKind.Hotbar)
			{
				return inventoryCellKind == InventoryCellKind.RegularUnlocked;
			}
			return true;
		}

		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_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!AreFavoritesEnabled() || (Object)(object)player == (Object)null)
			{
				return;
			}
			string playerId = GetPlayerId(player);
			if (string.Equals(_loadedFavoritesPlayerId, playerId, StringComparison.Ordinal))
			{
				return;
			}
			FavoriteSlots.Clear();
			_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 SaveFavorites(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			string playerId2 = (_loadedFavoritesPlayerId = GetPlayerId(player));
			try
			{
				GetClientPlayerState(playerId2, 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_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_0048: 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_012f: 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_0134: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: 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_01b4: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = (((Object)(object)Hud.instance != (Object)null) ? Hud.instance.m_rootObject : null);
			if (_showHotbarSwitchHint != null && _showHotbarSwitchHint.Value.IsOn() && _hotbarSwitchKey != null)
			{
				KeyboardShortcut value = _hotbarSwitchKey.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0 && (Object)(object)val != (Object)null)
				{
					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));
						KeyboardShortcut value2 = _hotbarSwitchKey.Value;
						TooltipUi.HotbarSwitchHudHintText.text = LocalizeUi("$inventoryslots_hotbar_switch_hint", "Switch\n[{key}]").Replace("{key}", GetCompactShortcutText(value2));
						TooltipUi.HotbarSwitchHudHintText.fontSize = 16f;
						TooltipUi.HotbarSwitchHudHintText.lineSpacing = -10f;
						TooltipUi.HotbarSwitchHudHintText.overflowMode = (TextOverflowModes)0;
						((Graphic)TooltipUi.HotbarSwitchHudHintText).color = HotbarSwitchHintColor;
						SetHintActive(TooltipUi.HotbarSwitchHudHint, active: true);
					}
					return;
				}
			}
			SetHintActive(TooltipUi.HotbarSwitchHudHint, active: false);
		}

		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 RectTransform EnsureWheelHintBackground(RectTransform parent, float size)
		{
			//IL_0136: 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_0160: 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_0176: 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_01ae: 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_011b: 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_0062: Expected O, but got Unknown
			Transform val = ((Transform)parent).Find("KeyBkg");
			RectTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				Transform val3 = FindVanillaKeyBackgroundTemplate();
				if ((Object)(object)val3 != (Object)null)
				{
					GameObject val4 = Object.Instantiate<GameObject>(((Component)val3).gameObject, (Transform)(object)parent, false);
					((Object)val4).name = "KeyBkg";
					val2 = (RectTransform)val4.transform;
					TMP_Text[] componentsInChildren = val4.GetComponentsInChildren<TMP_Text>(true);
					foreach (TMP_Text obj in componentsInChildren)
					{
						obj.text = "";
						((Graphic)obj).raycastTarget = false;
					}
					Image[] componentsInChildren2 = val4.GetComponentsInChildren<Image>(true);
					for (int i = 0; i < componentsInChildren2.Length; i++)
					{
						((Graphic)componentsInChildren2[i]).raycastTarget = false;
					}
				}
				else
				{
					val2 = new GameObject("KeyBkg", new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					}).GetComponent<RectTransform>();
					((Transform)val2).SetParent((Transform)(object)parent, false);
					Image component = ((Component)val2).GetComponent<Image>();
					component.sprite = GetSolidUiSprite();
					((Graphic)component).color = new Color(0f, 0f, 0f, 0.45f);
					((Graphic)component).raycastTarget = 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;
			((Transform)val2).localPosition = Vector3.zero;
			val2.sizeDelta = new Vector2(Mathf.Max(18f, size * 0.88f), Mathf.Max(24f, size * 1.18f));
			((Component)val2).gameObject.SetActive(true);
			return val2;
		}

		private static Transform? FindVanillaKeyBackgroundTemplate()
		{
			KeyHints instance = KeyHints.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			GameObject[] array = (GameObject[])(object)new GameObject[4] { instance.m_inventoryHints, instance.m_inventoryWithContainerHints, instance.m_buildHints, instance.m_combatHints };
			foreach (GameObject val in array)
			{
				if (IsUnityNull((Object?)(object)val))
				{
					continue;
				}
				Transform val2 = FindKeyboardHintParent(val.transform);
				if (!((Object)(object)val2 == (Object)null))
				{
					Transform val3 = ((IEnumerable<Transform>)((Component)val2).GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform child) => ((Object)child).name.StartsWith("key_bkg", StringComparison.OrdinalIgnoreCase) && (Object)(object)((Component)child).GetComponent<Image>() != (Object)null));
					if ((Object)(object)val3 != (Object)null)
					{
						return val3;
					}
				}
			}
			return null;
		}

		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 GetCompactShortcutText(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 96)
			{
				return "`";
			}
			string displayText = shortcut.GetDisplayText();
			if (!string.IsNullOrWhiteSpace(displayText))
			{
				return displayText;
			}
			return "";
		}

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

		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.8f);
		}

		private static float GetInventoryContainerHoverTooltipBackgroundAlpha()
		{
			return Mathf.Clamp01((_inventoryContainerHoverTooltipBackgroundAlpha != null) ? _inventoryContainerHoverTooltipBackgroundAlpha.Value : 1f);
		}

		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 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_014d: 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);
			bool flag2 = UpdateInventoryContainerCustomTooltipText(text, text2, resetScroll, GetInventoryHoverTooltipItemSignature(item));
			bool flag3 = UpdateInventoryHoverJewelcraftingTooltip(inventoryHoverTooltipPanel, item, ShouldShowJewelcraftingInventoryInteract(inventoryContainerHoverTooltipItemSource?.Grid));
			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 GetLightweightInventoryHoverItemSignature(item);
			}
			return "";
		}

		private static string GetLightweightInventoryHoverItemSignature(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 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 ex)
			{
				Log.LogDebug((object)("Tooltip font copy skipped: " + ex.Message));
				ApplyDefaultFontAsset(target);
			}
		}

		private static bool UpdateInventoryHoverJewelcraftingTooltip(RectTransform panel, ItemData? item, bool showInteract)
		{
			if (item?.m_shared == null)
			{
				return HideInventoryHoverJewelcraftingTooltip();
			}
			string inventoryHoverJewelcraftingTooltipSignature = GetInventoryHoverJewelcraftingTooltipSignature(item, showInteract);
			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 || (component.HasResolvedSocketGems && HasNativeJewelcraftingTooltipRows(_inventoryHoverJewelcraftingTooltipRoot)))
				{
					return false;
				}
			}
			RectTransform cachedRoot = _inventoryHoverJewelcraftingTooltipRoot;
			bool num = UpdateJewelcraftingTooltip(panel, item, ref cachedRoot, showInteract);
			_inventoryHoverJewelcraftingTooltipRoot = cachedRoot;
			if (num)
			{
				_inventoryHoverJewelcraftingTooltipSignature = inventoryHoverJewelcraftingTooltipSignature;
				ApplyInventoryHoverJewelcraftingSourceFonts();
				return true;
			}
			return HideInventoryHoverJewelcraftingTooltip();
		}

		private static string GetInventoryHoverJewelcraftingTooltipSignature(ItemData item, bool showInteract)
		{
			return string.Join("|", showInteract, IsJewelcraftingAdvancedTooltipPressed(), IsJewelcraftingProphecyTooltipPressed(), _uiLocalizationVersion, GetEquipmentSlotTooltipSignature(item), 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 = "";
			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_013a: 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)
			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>();
			SetTopLeftRectLayoutCached(component, component.anchoredPosition, component.sizeDelta, "inventory-hover-panel-base");
			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_01c5: 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)
			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;
			SetTopLeftRectLayoutCached(panel, panel.anchoredPosition, new Vector2(num, num12), "inventory-hover-panel-size");
			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_00af: 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);
			}
			SetTopLeftRectLayoutCached(inventoryHoverJewelcraftingTooltipRoot, new Vector2(0f, 0f - textHeight - 12f), new Vector2(textWidth, Mathf.Max(1f, inventoryHoverJewelcraftingTooltipRoot.sizeDelta.y)), "inventory-hover-jewelcrafting-root");
			((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_0064: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			string text = ((((Object)rect).name == "Topic") ? "inventory-hover-topic-text" : "inventory-hover-body-text");
			string signature = $"{text}|{horizontalPadding:0.###}|{top:0.###}|{height:0.###}";
			if (!CanReuseRectLayout(rect, signature))
			{
				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));
				SetRectLayoutSignature(rect, signature);
			}
		}

		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);
			for (int i = 0; i < 3; i++)
			{
				PerformInventoryStateAudit(player, reason2, auditLevel2);
				if (!ConsumePendingInventoryEnsure(out reason2, out auditLevel2) || IsUnityNull((Object?)(object)player))
				{
					return;
				}
			}
			Log.LogDebug((object)$"Inventory safety audit reached follow-up pass limit; deferred reason {reason2} will wait for the next normal inventory event.");
		}

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

		private static void ProcessDeferredInventoryStateEnsure(Player player)
		{
			if (InventorySafety.DeferredAuditLevel != 0 && InventorySafety.DeferredEnsureReason != 0)
			{
				InventoryStateEnsureReason deferredEnsureReason = InventorySafety.DeferredEnsureReason;
				InventoryStateAuditLevel deferredAuditLevel = InventorySafety.DeferredAuditLevel;
				InventorySafety.DeferredEnsureReason = InventoryStateEnsureReason.Unknown;
				InventorySafety.DeferredAuditLevel = InventoryStateAuditLevel.None;
				EnsureInventoryState(player, deferredEnsureReason, deferredAuditLevel);
			}
		}

		private static void PerformInventoryStateAudit(Player player, InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			RecordInventoryEnsureReason(reason);
			InventorySafety.PendingEnsureReason = InventoryStateEnsureReason.Unknown;
			InventorySafety.PendingAuditLevel = InventoryStateAuditLevel.None;
			InventorySafety.EnsuringInventoryState = true;
			try
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				if (inventory == null)
				{
					return;
				}
				InventoryStateAuditLevel inventoryStateAuditLevel = NormalizeAuditLevel(auditLevel, reason);
				bool flag = IsSyncedStateReady();
				int fullHeightForWidth = GetFullHeightForWidth(inventory.m_width);
				bool flag2 = false;
				if (inventory.m_height < fullHeightForWidth)
				{
					inventory.m_height = fullHeightForWidth;
					flag2 = true;
				}
				bool changed;
				int num = EnsureForeignSlotItemsPreserved(player, inventory, fullHeightForWidth, inventoryStateAuditLevel >= InventoryStateAuditLevel.FullIntegrity && flag, ShouldWarnLockedRowsDuringAudit(reason), out changed);
				flag2 = flag2 || changed;
				if (inventory.m_height != num)
				{
					inventory.m_height = num;
					flag2 = true;
				}
				if (flag2)
				{
					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 && flag)
				{
					if (ShouldRunFullIntegrityValidation(reason, player, inventory))
					{
						ValidateAndProjectInventory(player, inventory);
						RefreshInventoryStateSignature(player, inventory);
					}
					else
					{
						ProjectSlotDisplayState(player, inventory);
					}
				}
				else if (inventoryStateAuditLevel >= InventoryStateAuditLevel.SlotLight && flag)
				{
					ProjectSlotDisplayState(player, inventory);
				}
				if (inventoryStateAuditLevel >= InventoryStateAuditLevel.SlotLight)
				{
					UpdateCustomEquipmentVisuals(player);
				}
			}
			finally
			{
				InventorySafety.EnsuringInventoryState = false;
			}
		}

		private static void QueuePendingInventoryEnsure(InventoryStateEnsureReason reason, InventoryStateAuditLevel auditLevel)
		{
			if (reason != 0)
			{
				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.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 != 0)
			{
				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 != 0)
			{
				return InventoryStateEnsureReason.ReentrantFollowUp;
			}
			return current;
		}

		private static void RecordInventoryEnsureReason(InventoryStateEnsureReason reason)
		{
			InventorySafety.EnsureCounts.TryGetValue(reason, out var value);
			InventorySafety.EnsureCounts[reason] = value + 1;
			if (value == 0 && reason != 0)
			{
				Log.LogDebug((object)$"Inventory safety audit reason observed: {reason}");
			}
		}

		private static void ProjectSlotDisplayState(Player player, Inventory inventory)
		{
			bool flag = false;
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (slotDefinition.Kind == SlotKind.Quick)
				{
					continue;
				}
				ItemData val = FindItemForSlot(player, inventory, slotDefinition);
				if (val == null)
				{
					continue;
				}
				if (slotDefinition.Kind == SlotKind.CustomEquipment)
				{
					if (!val.m_equipped)
					{
						val.m_equipped = true;
						flag = true;
					}
					string playerId = GetPlayerId(player);
					if (val.m_customData == null || !val.m_customData.TryGetValue("InventorySlotsSlotId", out var value) || !string.Equals(value, slotDefinition.Id, StringComparison.OrdinalIgnoreCase) || !val.m_customData.TryGetValue("InventorySlotsEquippedBy", out var value2) || value2 != playerId)
					{
						MarkItemSlot(player, val, slotDefinition);
						flag = true;
					}
					OnCustomEquipmentCompatEquipped(player, val);
				}
				else
				{
					flag |= SyncBuiltInSlotEquippedFlag(player, val, slotDefinition);
					if (val.m_customData != null && (val.m_customData.ContainsKey("InventorySlotsSlotId") || val.m_customData.ContainsKey("InventorySlotsEquippedBy")))
					{
						ClearItemSlot(val);
						flag = true;
					}
				}
			}
			if (flag)
			{
				inventory.Changed();
			}
		}

		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 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_019c: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: 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_020d: 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.Kind == SlotKind.Quick && !IsQuickSlotUnlocked(player, 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 = FindItemForSlot(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;
				}
				if (slotDefinition.Kind == SlotKind.CustomEquipment)
				{
					if (!val.m_equipped)
					{
						val.m_equipped = true;
						flag = true;
					}
					MarkItemSlot(player, val, slotDefinition);
					OnCustomEquipmentCompatEquipped(player, val);
				}
				else
				{
					flag |= SyncBuiltInSlotEquippedFlag(player, val, slotDefinition);
					ClearItemSlot(val);
				}
			}
			if (flag | ClearMissingCustomEquipment(player, inventory))
			{
				inventory.Changed();
			}
		}

		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 && slotDefinition.Accepts(item) && FindItemForSlot(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++;
						}
					}
				}
			}
			if (num > 0 || num2 > 0)
			{
				Log.LogDebug((object)$"Inventory safety audit overlap recovery: moved {num} item(s), unresolved {num2} item(s).");
			}
			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 = FindItemForSlot(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)
			Inventory inventory2 = inventory;
			ItemData item2 = item;
			if (inventory2 == null || item2 == null || !inventory2.ContainsItem(item2))
			{
				return false;
			}
			InventorySlotSafetyCore.GridCell gridCell = InventorySlotSafetyCore.SelectNonOverlappingPreservationCell(inventory2.GetWidth(), inventory2.GetHeight(), new InventorySlotSafetyCore.GridCell(item2.m_gridPos.x, item2.m_gridPos.y), delegate(int x, int y)
			{
				foreach (ItemData item3 in inventory2.m_inventory)
				{
					if (item3 != null && item3 != item2 && item3.m_gridPos.x == x && item3.m_gridPos.y == y)
					{
						return true;
					}
				}
				return false;
			});
			Vector2i val = default(Vector2i);
			((Vector2i)(ref val))..ctor(gridCell.X, gridCell.Y);
			if (val == item2.m_gridPos)
			{
				return false;
			}
			item2.m_gridPos = val;
			return true;
		}

		private static bool TryMoveOverlappingQuickSlotItemToEmptyQuickSlot(Player player, Inventory inventory, ItemData item)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0049: 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_005d: 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)
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (slotDefinition.Kind == SlotKind.Quick && slotDefinition.Accepts(item))
				{
					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;
		}

		private static bool SyncBuiltInSlotEquippedFlag(Player player, ItemData item, SlotDefinition slot)
		{
			if (slot.Kind != 0 || item == null)
			{
				return false;
			}
			if (!IsSlotItemEquippedForDisplay(player, item, slot) || item.m_equipped)
			{
				return false;
			}
			item.m_equipped = true;
			return true;
		}

		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 = AreFavoritesEnabled() && _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)
			//IL_002c: 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_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_003d: Invalid comparison between Unknown and I4
			//IL_0048: 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";
			}
			KeyboardShortcut value = _favoriteModifierKey.Value;
			KeyCode mainKey = ((KeyboardShortcut)(ref value)).MainKey;
			bool flag = mainKey - 307 <= 1;
			return JoinShortcutDisplayTexts(flag ? "Alt" : value.GetDisplayText(), controllerHotkeyDisplayText);
		}

		private static string GetFavoriteKeyHintDisplayText()
		{
			return GetFavoriteModifierDisplayText() + "+Mouse-1";
		}

		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_0013: Unknown result type (might be due to invalid IL or missing references)
			return JoinShortcutDisplayTexts((_pinnedTooltipKey != null) ? _pinnedTooltipKey.Value.GetDisplayText() : "Mouse-3", GetControllerHotkeyDisplayText(_controllerPinnedTooltipButton));
		}

		private static void SetFavoriteKeyHintsActive(GameObject? activeHint)
		{
			foreach (GameObject item in InventoryPanels.FavoriteKeyHintObjects.Values.Concat(InventoryPanels.PinnedTooltipKeyHintObjects.Values))
			{
				if (!IsUnityNull((Object?)(object)item))
				{
					item.SetActive((Object)(object)activeHint != (Object)null && (Object)(object)item == (Object)(object)activeHint);
				}
			}
		}

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

		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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//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)
			if (!((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))
			{
				RectTransform component = Hud.instance.m_rootObject.GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					Vector3 localPosition = ((Transform)quickPanel).localPosition;
					((Transform)quickPanel).localPosition = targetPosition;
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					quickPanel.GetWorldCorners(array);
					((Transform)quickPanel).localPosition = localPosition;
					InventoryPanels.QuickSlotHudAnchoredPosition = ((Transform)component).InverseTransformPoint(array[1]);
					InventoryPanels.QuickSlotHudElementSpace = Mathf.Max(1f, elementSpace);
					InventoryPanels.QuickSlotHudAnchorValid = true;
				}
			}
		}

		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_00ec: 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_012e: 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_0175: 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_0197: 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_01b7: 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)
			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;
			CreateCleanQuickHudImageChild("equiped", val.transform, new Color(0.42f, 0.68f, 0.92f, 0.34f), active: false);
			CreateCleanQuickHudImageChild("queued", val.transform, new Color(1f, 0.68f, 0.18f, 0.28f), active: false);
			CreateCleanQuickHudImageChild("selected", val.transform, new Color(1f, 1f, 1f, 0.16f), active: false);
			((Graphic)((Component)CreateCleanQuickHudImageChild("icon", val.transform, Color.white, active: false)).GetComponent<Image>()).raycastTarget = false;
			RectTransform val2 = CreateCleanQuickHudImageChild("durability", val.transform, new Color(0f, 0f, 0f, 0.7f), active: false);
			RectTransform val3 = CreateCleanQuickHudImageChild("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 RectTransform CreateCleanQuickHudImageChild(string name, Transform parent, Color color, bool active)
		{
			//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 = false;
			val.SetActive(active);
			return component;
		}

		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_00ff: 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 text = GetQuickSlotBindingText(slot).Replace(" + ", "+");
				string text2 = slot.Id + "|" + text;
				if (!string.Equals(marker.BindingSignature, text2, StringComparison.Ordinal))
				{
					ApplyDefaultFontAsset(val);
					val.text = text;
					((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 = text2;
				}
			}
		}

		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 GetQuickPanelColumns(int slotCount)
		{
			if (slotCount <= 0)
			{
				return 0;
			}
			return 3;
		}

		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)
		{
			InventoryPanels.PlayerInventoryMaxScroll = 0;
			InventoryPanels.PlayerInventoryScrollOffset = 0;
			StopPlayerInventoryRowsDrag();
			HidePlayerInventoryScrollbar();
			HidePlayerInventoryResizeHandle(stopDragging: false);
			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(_clientState.Inventory.LastExpandableRows, 4, 9);
			}
			catch (Exception ex)
			{
				Log.LogDebug((object)("Failed to load InventorySlots client state: " + ex.Message));
			}
		}

		private static void SaveLastExpandableInventoryRows()
		{
			try
			{
				EnsureClientStateLoaded();
				_clientState.Inventory.LastExpandableRows = InventoryPanels.LastExpandableInventoryRows;
				SaveClientState();
			}
			catch (Exception ex)
			{
				Log.LogDebug((object)("Failed to save InventorySlots client state: " + ex.Message));
			}
		}

		private static void UpdatePlayerInventoryRowsDragging(int totalRegularRows, float elementSpace)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (InventoryPanels.PlayerInventoryRowsDragging)
			{
				if (!InventoryGui.IsVisible() || !Input.GetMouseButton(0))
				{
					StopPlayerInventoryRowsDrag();
					return;
				}
				float num = Mathf.Max(1f, elementSpace);
				int num2 = Mathf.RoundToInt((InventoryPanels.PlayerInventoryRowsDragStartMouse.y - GetUiMousePosition().y) / num);
				SetExpandableInventoryRows(InventoryPanels.PlayerInventoryRowsDragStartRows + num2, totalRegularRows);
			}
		}

		private static void StartPlayerInventoryRowsDrag()
		{
			//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)
			if (InventoryGui.IsVisible())
			{
				InventoryPanels.PlayerInventoryRowsDragging = true;
				InventoryPanels.PlayerInventoryRowsDragStartMouse = Vector2.op_Implicit(GetUiMousePosition());
				InventoryPanels.PlayerInventoryRowsDragStartRows = GetLastExpandableInventoryRows(9);
			}
		}

		private static void StopPlayerInventoryRowsDrag()
		{
			InventoryPanels.PlayerInventoryRowsDragging = false;
		}

		private static void HandlePlayerInventoryMouseWheel(InventoryGrid playerGrid)
		{
			if (InventoryPanels.PlayerInventoryMaxScroll > 0 && InventoryGui.IsVisible() && !ShouldSuppressInventoryContainerRowsWheel() && (IsMouseOverPlayerInventory(playerGrid) || IsGamepadUiScrollActive()))
			{
				float uiScrollDelta = GetUiScrollDelta(UiScrollInputMode.Discrete);
				if (!(Mathf.Abs(uiScrollDelta) < 0.01f))
				{
					int num = ((!(uiScrollDelta > 0f)) ? 1 : (-1));
					InventoryPanels.PlayerInventoryScrollOffset = Mathf.Clamp(InventoryPanels.PlayerInventoryScrollOffset + num, 0, InventoryPanels.PlayerInventoryMaxScroll);
				}
			}
		}

		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_0061: 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_00d0: 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)InventoryPanels.PlayerInventoryScrollbar != (Object)null && ((Component)InventoryPanels.PlayerInventoryScrollbar).gameObject.activeInHierarchy && RectContainsScreenPoint(InventoryPanels.PlayerInventoryScrollbar, uiMousePosition))
			{
				return true;
			}
			if ((Object)(object)InventoryPanels.PlayerInventoryResizeHandle != (Object)null && ((Component)InventoryPanels.PlayerInventoryResizeHandle).gameObject.activeInHierarchy && RectContainsScreenPoint(InventoryPanels.PlayerInventoryResizeHandle, 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 bool TryGetLocalPointInRect(RectTransform rectTransform, Vector2 screenPoint, out Vector2 localPoint)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//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)
			localPoint = Vector2.op_Implicit(((Transform)rectTransform).InverseTransformPoint(Vector2.op_Implicit(screenPoint)));
			return true;
		}

		private static void HidePlayerInventoryScrollbar()
		{
			if ((Object)(object)InventoryPanels.PlayerInventoryScrollbar != (Object)null)
			{
				((Component)InventoryPanels.PlayerInventoryScrollbar).gameObject.SetActive(false);
			}
		}

		private static void UpdatePlayerInventoryResizeHandle(InventoryGrid playerGrid, int viewportRows, int totalRegularRows)
		{
			//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_0041: 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)
			if (totalRegularRows <= 4)
			{
				HidePlayerInventoryResizeHandle();
				return;
			}
			RectTransform obj = EnsurePlayerInventoryResizeHandle(playerGrid);
			Vector3 gridOrigin = GetGridOrigin(playerGrid);
			float elementSpace = playerGrid.m_elementSpace;
			float num = (float)playerGrid.m_width * elementSpace;
			float num2 = Mathf.Clamp(elementSpace * 0.18f, 12f, 18f);
			((Transform)obj).localPosition = gridOrigin + new Vector3((float)(playerGrid.m_width - 1) * elementSpace / 2f, (0f - ((float)viewportRows - 0.55f)) * elementSpace, 0f);
			obj.SetSizeWithCurrentAnchors((Axis)0, num);
			obj.SetSizeWithCurrentAnchors((Axis)1, num2);
			((Transform)obj).SetAsLastSibling();
			((Component)obj).gameObject.SetActive(true);
			if ((Object)(object)InventoryPanels.PlayerInventoryResizeHandleLabel != (Object)null)
			{
				int num3 = Mathf.Max(0, totalRegularRows - viewportRows);
				InventoryPanels.PlayerInventoryResizeHandleLabel.text = ((num3 > 0) ? "..." : "---");
			}
		}

		private static RectTransform EnsurePlayerInventoryResizeHandle(InventoryGrid playerGrid)
		{
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: 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_0253: 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_0108: 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_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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)InventoryPanels.PlayerInventoryResizeHandle != (Object)null && (Object)(object)((Transform)InventoryPanels.PlayerInventoryResizeHandle).parent == (Object)(object)playerGrid.m_gridRoot)
			{
				return InventoryPanels.PlayerInventoryResizeHandle;
			}
			Transform val = ((Transform)playerGrid.m_gridRoot).Find("InventorySlots_PlayerInventoryResizeHandle");
			InventoryPanels.PlayerInventoryResizeHandle = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)InventoryPanels.PlayerInventoryResizeHandle == (Object)null)
			{
				InventoryPanels.PlayerInventoryResizeHandle = new GameObject("InventorySlots_PlayerInventoryResizeHandle", new Type[4]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(UIInputHandler),
					typeof(PlayerInventoryRowsHandleMarker)
				}).GetComponent<RectTransform>();
				((Transform)InventoryPanels.PlayerInventoryResizeHandle).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
				Image component = ((Component)InventoryPanels.PlayerInventoryResizeHandle).GetComponent<Image>();
				((Graphic)component).color = new Color(0f, 0f, 0f, 0.35f);
				((Graphic)component).raycastTarget = true;
				TMP_Text text;
				RectTransform obj = CreateTextRect("label", (Transform)(object)InventoryPanels.PlayerInventoryResizeHandle, out text);
				obj.anchorMin = Vector2.zero;
				obj.anchorMax = Vector2.one;
				obj.offsetMin = Vector2.zero;
				obj.offsetMax = Vector2.zero;
				InventoryPanels.PlayerInventoryResizeHandleLabel = text;
				InventoryPanels.PlayerInventoryResizeHandleLabel.alignment = (TextAlignmentOptions)514;
				InventoryPanels.PlayerInventoryResizeHandleLabel.fontSize = 14f;
				((Graphic)InventoryPanels.PlayerInventoryResizeHandleLabel).color = new Color(0.75f, 0.86f, 1f, 0.9f);
				((Graphic)InventoryPanels.PlayerInventoryResizeHandleLabel).raycastTarget = false;
			}
			((Transform)InventoryPanels.PlayerInventoryResizeHandle).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
			InventoryPanels.PlayerInventoryResizeHandle.anchorMin = new Vector2(0.5f, 0.5f);
			InventoryPanels.PlayerInventoryResizeHandle.anchorMax = new Vector2(0.5f, 0.5f);
			InventoryPanels.PlayerInventoryResizeHandle.pivot = new Vector2(0.5f, 0.5f);
			((Transform)InventoryPanels.PlayerInventoryResizeHandle).localScale = Vector3.one;
			((Transform)InventoryPanels.PlayerInventoryResizeHandle).localRotation = Quaternion.identity;
			PlayerInventoryRowsHandleMarker component2 = ((Component)InventoryPanels.PlayerInventoryResizeHandle).GetComponent<PlayerInventoryRowsHandleMarker>();
			if (!component2.Initialized)
			{
				UIInputHandler component3 = ((Component)InventoryPanels.PlayerInventoryResizeHandle).GetComponent<UIInputHandler>();
				component3.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(component3.m_onLeftDown, (Action<UIInputHandler>)delegate
				{
					StartPlayerInventoryRowsDrag();
				});
				component3.m_onLeftUp = (Action<UIInputHandler>)Delegate.Combine(component3.m_onLeftUp, (Action<UIInputHandler>)delegate
				{
					StopPlayerInventoryRowsDrag();
				});
				component2.Initialized = true;
			}
			InventoryPanelRuntimeState inventoryPanels = InventoryPanels;
			Transform obj2 = ((Transform)InventoryPanels.PlayerInventoryResizeHandle).Find("label");
			inventoryPanels.PlayerInventoryResizeHandleLabel = (TMP_Text?)(object)((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
			ApplyDefaultFontAsset(InventoryPanels.PlayerInventoryResizeHandleLabel);
			return InventoryPanels.PlayerInventoryResizeHandle;
		}

		private static void HidePlayerInventoryResizeHandle(bool stopDragging = true)
		{
			if (stopDragging)
			{
				StopPlayerInventoryRowsDrag();
			}
			if ((Object)(object)InventoryPanels.PlayerInventoryResizeHandle != (Object)null)
			{
				((Component)InventoryPanels.PlayerInventoryResizeHandle).gameObject.SetActive(false);
			}
		}

		private static void UpdatePlayerInventoryScrollbar(InventoryGrid playerGrid, int viewportRows, int totalRegularRows)
		{
			//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_0058: 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)
			if (InventoryPanels.PlayerInventoryMaxScroll <= 0)
			{
				if ((Object)(object)InventoryPanels.PlayerInventoryScrollbar != (Object)null)
				{
					((Component)InventoryPanels.PlayerInventoryScrollbar).gameObject.SetActive(false);
				}
				return;
			}
			RectTransform obj = EnsurePlayerInventoryScrollbar(playerGrid);
			Scrollbar playerInventoryScrollbarComponent = InventoryPanels.PlayerInventoryScrollbarComponent;
			Vector3 gridOrigin = GetGridOrigin(playerGrid);
			float num = (float)viewportRows * playerGrid.m_elementSpace;
			((Transform)obj).localPosition = gridOrigin + new Vector3((float)playerGrid.m_width * playerGrid.m_elementSpace + 12f, (0f - num) / 2f + playerGrid.m_elementSpace / 2f, 0f);
			obj.SetSizeWithCurrentAnchors((Axis)0, 12f);
			obj.SetSizeWithCurrentAnchors((Axis)1, num);
			playerInventoryScrollbarComponent.size = Mathf.Clamp01((float)viewportRows / (float)Mathf.Max(viewportRows, totalRegularRows));
			InventoryPanels.UpdatingPlayerInventoryScrollbar = true;
			playerInventoryScrollbarComponent.value = ((InventoryPanels.PlayerInventoryMaxScroll == 0) ? 1f : (1f - (float)InventoryPanels.PlayerInventoryScrollOffset / (float)InventoryPanels.PlayerInventoryMaxScroll));
			InventoryPanels.UpdatingPlayerInventoryScrollbar = false;
			((Component)obj).gameObject.SetActive(true);
		}

		private static RectTransform EnsurePlayerInventoryScrollbar(InventoryGrid playerGrid)
		{
			//IL_0283: 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_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: 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_00b2: 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_0123: 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_014b: 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_0175: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: 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_01ff: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)InventoryPanels.PlayerInventoryScrollbar != (Object)null && (Object)(object)((Transform)InventoryPanels.PlayerInventoryScrollbar).parent == (Object)(object)playerGrid.m_gridRoot)
			{
				return InventoryPanels.PlayerInventoryScrollbar;
			}
			Transform val = ((Transform)playerGrid.m_gridRoot).Find("InventorySlots_PlayerInventoryScrollbar");
			InventoryPanels.PlayerInventoryScrollbar = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<RectTransform>() : null);
			if ((Object)(object)InventoryPanels.PlayerInventoryScrollbar == (Object)null)
			{
				InventoryPanels.PlayerInventoryScrollbar = new GameObject("InventorySlots_PlayerInventoryScrollbar", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Scrollbar)
				}).GetComponent<RectTransform>();
				((Transform)InventoryPanels.PlayerInventoryScrollbar).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
				Image component = ((Component)InventoryPanels.PlayerInventoryScrollbar).GetComponent<Image>();
				((Graphic)component).color = new Color(0f, 0f, 0f, 0.45f);
				((Graphic)component).raycastTarget = true;
				RectTransform component2 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)component2).SetParent((Transform)(object)InventoryPanels.PlayerInventoryScrollbar, false);
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.offsetMin = new Vector2(2f, 2f);
				component2.offsetMax = new Vector2(-2f, -2f);
				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>();
				((Graphic)component4).color = new Color(0.75f, 0.86f, 1f, 0.85f);
				((Graphic)component4).raycastTarget = true;
				Scrollbar component5 = ((Component)InventoryPanels.PlayerInventoryScrollbar).GetComponent<Scrollbar>();
				component5.direction = (Direction)2;
				((Selectable)component5).targetGraphic = (Graphic)(object)component4;
				component5.handleRect = component3;
				((UnityEvent<float>)(object)component5.onValueChanged).AddListener((UnityAction<float>)OnPlayerInventoryScrollbarChanged);
			}
			((Transform)InventoryPanels.PlayerInventoryScrollbar).SetParent((Transform)(object)playerGrid.m_gridRoot, false);
			InventoryPanels.PlayerInventoryScrollbar.anchorMin = new Vector2(0.5f, 0.5f);
			InventoryPanels.PlayerInventoryScrollbar.anchorMax = new Vector2(0.5f, 0.5f);
			InventoryPanels.PlayerInventoryScrollbar.pivot = new Vector2(0f, 0.5f);
			((Transform)InventoryPanels.PlayerInventoryScrollbar).localScale = Vector3.one;
			((Transform)InventoryPanels.PlayerInventoryScrollbar).localRotation = Quaternion.identity;
			((Transform)InventoryPanels.PlayerInventoryScrollbar).SetAsLastSibling();
			InventoryPanels.PlayerInventoryScrollbarComponent = ((Component)InventoryPanels.PlayerInventoryScrollbar).GetComponent<Scrollbar>();
			return InventoryPanels.PlayerInventoryScrollbar;
		}

		private static void OnPlayerInventoryScrollbarChanged(float value)
		{
			if (!InventoryPanels.UpdatingPlayerInventoryScrollbar && InventoryPanels.PlayerInventoryMaxScroll > 0)
			{
				InventoryPanels.PlayerInventoryScrollOffset = Mathf.Clamp(Mathf.RoundToInt((1f - value) * (float)InventoryPanels.PlayerInventoryMaxScroll), 0, InventoryPanels.PlayerInventoryMaxScroll);
			}
		}

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

		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.<28>__TryClickInventoryTrashPanel;
				if (obj == null)
				{
					UnityAction val5 = TryClickInventoryTrashPanel;
					<>O.<28>__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 (GetInventoryCellKind(player, inventory, item.m_gridPos) == InventoryCellKind.Hotbar)
			{
				if (showMessage)
				{
					ShowInventoryTrashMessage(player, "$inventoryslots_trash_hotbar_item", "Hotbar items cannot 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 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);
			ShowActionResult(localPlayer, LocalizeUi("$inventoryslots_trash_action", "Trash"), inventoryTrashPendingAmount);
		}

		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 bool TryGetSlotAtGridPos(Inventory inventory, Vector2i pos, out SlotDefinition? slot)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return InventoryDefinitionController.TryGetSlotAtGridPos(InventoryDefinitions, inventory, pos, GetFixedRegularRows(), out slot);
		}

		internal static bool TryGetSlotById(string id, out SlotDefinition? slot)
		{
			return InventoryDefinitionController.TryGetSlotById(InventoryDefinitions, id, out slot);
		}

		private static List<SlotDefinition> GetCustomPanelSlots()
		{
			return InventoryDefinitionController.GetCustomPanelSlots(InventoryDefinitions);
		}

		private static List<SlotDefinition> GetQuickPanelSlots(Player? player = null)
		{
			return InventoryDefinitionController.GetQuickPanelSlots(InventoryDefinitions, GetUnlockedQuickSlotCount(player));
		}

		private static bool TryGetQuickSlotDefinition(int quickSlotIndex, out SlotDefinition? slot)
		{
			return InventoryDefinitionController.TryGetQuickSlotDefinition(InventoryDefinitions, quickSlotIndex, out slot);
		}

		private static Vector2i GetSlotGridPos(Inventory inventory, SlotDefinition slot)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return InventoryDefinitionController.GetSlotGridPos(InventoryDefinitions, inventory, slot, GetFixedRegularRows());
		}

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

		private static int GetFullHeight()
		{
			return GetFullHeightForWidth(8);
		}

		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)
		{
			return InventoryDefinitionController.GetSlotTailRows(InventoryDefinitions, width);
		}

		private static int GetUsableRegularRows(Player player)
		{
			return 4 + CalculateUnlockedRows(player);
		}

		private static int CalculateUnlockedRows(Player player)
		{
			if (_progressiveRowsEnabled == null || _progressiveRowsEnabled.Value.IsOff())
			{
				return GetMaxExtraRows();
			}
			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()
		{
			if (_quickSlotCount != null)
			{
				return Mathf.Clamp(_quickSlotCount.Value, 0, 9);
			}
			return 0;
		}

		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 unlockedRows = 1;
			if (num >= 2 && _quickSlotRowUnlockItems.Length != 0 && IsRowUnlocked(player, _quickSlotRowUnlockItems[0].Value))
			{
				unlockedRows = 2;
				if (num >= 3 && _quickSlotRowUnlockItems.Length > 1 && IsRowUnlocked(player, _quickSlotRowUnlockItems[1].Value))
				{
					unlockedRows = 3;
				}
				return GetStableUnlockedQuickSlotRows(player, unlockedRows, num);
			}
			return GetStableUnlockedQuickSlotRows(player, unlockedRows, num);
		}

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

		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 void InvalidateSlotDefinitionCaches()
		{
			InventoryDefinitionController.InvalidateCaches(InventoryDefinitions);
		}

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

		[IteratorStateMachine(typeof(<SplitConfiguredList>d__1929))]
		private static IEnumerable<string> SplitConfiguredList(string value)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SplitConfiguredList>d__1929(-2)
			{
				<>3__value = value
			};
		}

		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_0224: 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.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.GetDisplayText() : "");
			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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0083: 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))
				{
					InventoryPanels.DraggedInventoryPanel = component;
					InventoryPanels.InventoryPanelDragStartMouse = Input.mousePosition;
					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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			EnsureClientStateLoaded();
			InventoryPanels.EquipmentSlotsPanelRuntimeOffset = GetClientPanelPosition(_clientState.Inventory.EquipmentSlotsPanelPosition, EquipmentSlotsPanelFixedOffset);
			InventoryPanels.QuickSlotsPanelRuntimeOffset = GetClientPanelPosition(_clientState.Inventory.QuickSlotsPanelPosition, QuickSlotsPanelFixedOffset);
		}

		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_002f: Unknown result type (might be due to invalid IL or missing references)
			if (InventoryPanels.DraggingQuickSlotsPanelOffset)
			{
				SaveInventoryPanelPosition(isQuickSlotsPanel: true, InventoryPanels.QuickSlotsPanelRuntimeOffset);
			}
			else if (InventoryPanels.DraggingEquipmentSlotsPanelOffset)
			{
				SaveInventoryPanelPosition(isQuickSlotsPanel: false, InventoryPanels.EquipmentSlotsPanelRuntimeOffset);
			}
		}

		private static void SaveInventoryPanelPosition(bool isQuickSlotsPanel, Vector2 value)
		{
			//IL_002f: 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_0069: 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)
			EnsureClientStateLoaded();
			InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition = (isQuickSlotsPanel ? _clientState.Inventory.QuickSlotsPanelPosition : _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 UpdateInventoryPanelDragging()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0075: 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_00a9: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)InventoryPanels.DraggedInventoryPanel == (Object)null || (!InventoryPanels.DraggingQuickSlotsPanelOffset && !InventoryPanels.DraggingEquipmentSlotsPanelOffset))
			{
				return;
			}
			if (!Input.GetMouseButton(0) || !((Component)InventoryPanels.DraggedInventoryPanel).gameObject.activeInHierarchy)
			{
				StopInventoryPanelDrag();
				return;
			}
			Vector3 val = Input.mousePosition - InventoryPanels.InventoryPanelDragStartMouse;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(InventoryPanels.InventoryPanelDragStartOffset.x + val.x, InventoryPanels.InventoryPanelDragStartOffset.y + val.y);
			if (InventoryPanels.DraggingQuickSlotsPanelOffset)
			{
				InventoryPanels.QuickSlotsPanelRuntimeOffset = val2;
			}
			else if (InventoryPanels.DraggingEquipmentSlotsPanelOffset)
			{
				InventoryPanels.EquipmentSlotsPanelRuntimeOffset = val2;
			}
		}

		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 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)
		{
			RectTransform root2 = root;
			MovedPlayerStatPanel movedPlayerStatPanel = InventoryPanels.MovedPlayerStatPanels.FirstOrDefault((MovedPlayerStatPanel panel) => (Object)(object)panel.Rect == (Object)(object)root2 && !IsUnityNull((Object?)(object)panel.Rect));
			if (movedPlayerStatPanel == null)
			{
				movedPlayerStatPanel = new MovedPlayerStatPanel(kind, root2, sortOrder);
				InventoryPanels.MovedPlayerStatPanels.Add(movedPlayerStatPanel);
			}
			else
			{
				movedPlayerStatPanel.Kind = kind;
				movedPlayerStatPanel.SortOrder = sortOrder;
			}
			((Transform)root2).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)
		{
			TMP_Text text2 = text;
			if ((Object)(object)text2 == (Object)null)
			{
				return null;
			}
			MovedPlayerStatPanel movedPlayerStatPanel = InventoryPanels.MovedPlayerStatPanels.FirstOrDefault((MovedPlayerStatPanel panel) => !IsUnityNull((Object?)(object)panel.Rect) && text2.transform.IsChildOf((Transform)(object)panel.Rect));
			if (movedPlayerStatPanel != null)
			{
				return movedPlayerStatPanel.Rect;
			}
			RectTransform result = ((Component)text2).GetComponent<RectTransform>();
			Transform val = text2.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);
			}
		}

		internal static void UpdateInventoryGridUi(InventoryGrid playerGrid, Player player)
		{
			//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_04ab: 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_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Expected O, but got Unknown
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: 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_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: 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_02a2: 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_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: 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);
			UpdateInventoryPanelDragging();
			List<SlotDefinition> customPanelSlots = GetCustomPanelSlots();
			List<SlotDefinition> quickPanelSlots = GetQuickPanelSlots(player);
			if (playerGrid.m_elements.Count == 0)
			{
				HideInventorySideHints();
				return;
			}
			Vector3 gridOrigin = GetGridOrigin(playerGrid);
			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 num2 = i / width;
				int num3 = i - num2 * width;
				((Vector2i)(ref pos))..ctor(num3, num2);
				if (!IsExternalReservedCell(pos, includeRestockableSlots: true) && num2 >= usableRegularRows && num2 < fixedRegularRows && !ShouldShowLockedInventoryCellForRecovery(player, inventory, pos))
				{
					val3.m_go.SetActive(false);
					val3.m_used = true;
					SetFavoriteBorderActive(val3, active: false);
					SetInventoryPinnedTooltipBorderActive(val3, active: false);
				}
				else if (num2 >= fixedRegularRows)
				{
					int num4 = (num2 - fixedRegularRows) * width + num3;
					if (num4 >= 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[num4];
					bool flag = slotDefinition.Kind == SlotKind.Quick;
					RectTransform val4 = (flag ? val2 : val);
					int num5 = (flag ? quickPanelSlots : customPanelSlots).IndexOf(slotDefinition);
					if ((Object)(object)val4 == (Object)null || num5 < 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(num5, playerGrid.m_elementSpace) : GetCustomSlotPanelElementPosition(num5, playerGrid.m_elementSpace));
					val3.m_go.SetActive(true);
					if (!val3.m_used && (Object)(object)val3.m_tooltip != (Object)null)
					{
						val3.m_tooltip.m_topic = slotDefinition.Name;
						val3.m_tooltip.m_text = "";
					}
					bool flag2 = UpdateEquipmentSlotElementState(val3, player, inventory, slotDefinition, new Vector2i(num3, num2));
					UpdateSlotBindingLabel(val3, slotDefinition, !flag && flag2);
					UpdateFavoriteBorder(val3, player, inventory, new Vector2i(num3, num2));
					UpdateInventoryPinnedTooltipBorder(playerGrid, val3, new Vector2i(num3, num2));
				}
				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 (num2 < InventoryPanels.PlayerInventoryScrollOffset || num2 >= InventoryPanels.PlayerInventoryScrollOffset + inventoryViewportRows || num2 >= num)
					{
						val3.m_go.SetActive(false);
						val3.m_used = true;
						SetFavoriteBorderActive(val3, active: false);
						SetInventoryPinnedTooltipBorderActive(val3, active: false);
					}
					else
					{
						int num6 = num2 - InventoryPanels.PlayerInventoryScrollOffset;
						((Transform)val6).localPosition = gridOrigin + new Vector3((float)num3 * playerGrid.m_elementSpace, (float)(-num6) * playerGrid.m_elementSpace, 0f);
						val3.m_go.SetActive(true);
						UpdateFavoriteBorder(val3, player, inventory, new Vector2i(num3, num2));
						UpdateInventoryPinnedTooltipBorder(playerGrid, val3, new Vector2i(num3, num2));
					}
				}
			}
			float num7 = inventoryViewportRows;
			playerGrid.m_gridRoot.SetSizeWithCurrentAnchors((Axis)1, num7 * playerGrid.m_elementSpace);
			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 num8 = (0f - (((customPanelSlots.Count > 0) ? 3f : 0f) + ((customPanelSlots.Count > 0) ? 0.35f : 0f))) * playerGrid.m_elementSpace;
				Vector3 targetGridLocalPosition = sidePanelBasePosition2 + new Vector3(0f, num8, 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 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);
				InvalidateCraftingRecipeGridLayout();
				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);
			InvalidateCraftingRecipeGridLayout();
		}

		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_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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_00ed: 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_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_0275: 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)
			if (slot < 0 || slot >= PinnedTooltips.Crafting.Panels.Length || !TryGetCraftingRecipePair(gui, index, out var pair))
			{
				return;
			}
			PinnedTooltipContext currentCraftingPinnedTooltipContext = GetCurrentCraftingPinnedTooltipContext(gui);
			if (currentCraftingPinnedTooltipContext != 0)
			{
				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;
				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 = 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 = UpdateCraftingJewelcraftingTooltip(val, pair, ref PinnedTooltips.Crafting.JewelcraftingTooltipRoots[slot]);
				bool flag = false;
				if (num)
				{
					HideCraftingGemIconRow(ref PinnedTooltips.Crafting.GemIconRows[slot]);
				}
				else
				{
					flag = UpdateCraftingGemIconRow(val, pair, ref PinnedTooltips.Crafting.GemIconRows[slot], new Vector2(18f, 82f), 28f, 6f);
				}
				SetCraftingPinnedTooltipTextReservedSpace(val, flag);
				ConfigureCraftingTooltipRecipeRow(val, pair, new Vector2(18f, 18f), 54f, 8f);
				if ((Object)(object)PinnedTooltips.Crafting.Texts[slot] != (Object)null)
				{
					float bottomReserved = (flag ? 124f : 92f);
					ApplyPinnedTooltipDynamicTextLayout(val, PinnedTooltips.Crafting.Texts[slot], slot, CraftingPinnedTooltipFixedOffset, 102f, bottomReserved, GetPinnedTooltipMaxTextViewportHeight(val, 102f, bottomReserved));
				}
				InvalidateCraftingRecipeGridLayout();
			}
		}

		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)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform crafting = gui.m_crafting;
			RectTransform val = PinnedTooltips.Crafting.Panels[slot];
			if ((Object)(object)val == (Object)null || IsUnityNull((Object?)(object)val) || (Object)(object)((Transform)val).parent != (Object)(object)crafting)
			{
				string text = "InventorySlots_CraftingPinnedTooltip_" + slot;
				Transform val2 = ((Transform)crafting).Find(text);
				val = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<RectTransform>() : null);
				if ((Object)(object)val == (Object)null)
				{
					val = new GameObject(text, new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					}).GetComponent<RectTransform>();
				}
				((Transform)val).SetParent((Transform)(object)crafting, false);
			}
			ConfigurePinnedTooltipPanelBackground(val);
			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);
			ConfigureCraftingPinnedTooltipRaycast(val);
			PinnedTooltips.Crafting.Panels[slot] = val;
			return val;
		}

		private static void ConfigureCraftingPinnedTooltipRaycast(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 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;
				InvalidateCraftingRecipeGridLayout();
			}
		}

		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)
			InventoryGrid grid2 = grid;
			ItemData item2 = item;
			if (item2?.m_shared == null)
			{
				return;
			}
			SetPinnedTooltipContext(PinnedTooltipContext.InventoryContainer);
			if (FindInventoryPinnedTooltipSlot(grid2, pos, item2) >= 0)
			{
				List<InventoryPinnedTooltipTarget> activeInventoryPinnedTooltipTargets = GetActiveInventoryPinnedTooltipTargets();
				activeInventoryPinnedTooltipTargets.RemoveAll((InventoryPinnedTooltipTarget target) => IsSameInventoryPinnedTooltipTarget(target, grid2, pos, item2));
				RebuildInventoryPinnedTooltips(gui, activeInventoryPinnedTooltipTargets);
				return;
			}
			List<InventoryPinnedTooltipTarget> activeInventoryPinnedTooltipTargets2 = GetActiveInventoryPinnedTooltipTargets();
			int activePinnedTooltipSlotCount = GetActivePinnedTooltipSlotCount();
			if (activeInventoryPinnedTooltipTargets2.Count >= activePinnedTooltipSlotCount)
			{
				activeInventoryPinnedTooltipTargets2.Insert(0, new InventoryPinnedTooltipTarget(grid2, pos, item2));
				activeInventoryPinnedTooltipTargets2.RemoveAt(activeInventoryPinnedTooltipTargets2.Count - 1);
			}
			else
			{
				activeInventoryPinnedTooltipTargets2.Add(new InventoryPinnedTooltipTarget(grid2, pos, item2));
			}
			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)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = ResolveInventoryPinnedTooltipParent(gui);
			RectTransform val2 = PinnedTooltips.Inventory.Panels[slot];
			if ((Object)(object)val2 == (Object)null || IsUnityNull((Object?)(object)val2) || (Object)(object)((Transform)val2).parent != (Object)(object)val)
			{
				string text = "InventorySlots_InventoryPinnedTooltip_" + slot;
				Transform val3 = ((Transform)val).Find(text);
				if ((Object)(object)val3 == (Object)null && (Object)(object)gui.m_player != (Object)null && !IsUnityNull((Object?)(object)gui.m_player) && (Object)(object)gui.m_player != (Object)(object)val)
				{
					val3 = ((Transform)gui.m_player).Find(text);
				}
				val2 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponent<RectTransform>() : null);
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = new GameObject(text, new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					}).GetComponent<RectTransform>();
				}
				((Transform)val2).SetParent((Transform)(object)val, false);
			}
			ConfigurePinnedTooltipPanelBackground(val2);
			PinnedTooltips.Inventory.Icons[slot] = EnsurePinnedTooltipIcon(val2);
			PinnedTooltips.Inventory.Texts[slot] = EnsurePinnedTooltipBodyText(val2, 16f);
			PinnedTooltips.Inventory.JewelcraftingTooltipRoots[slot] = FindJewelcraftingTooltipRoot(val2);
			ConfigureInventoryPinnedTooltipRaycast(val2);
			PinnedTooltips.Inventory.Panels[slot] = val2;
			return val2;
		}

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

		private static void ConfigureInventoryPinnedTooltipRaycast(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;
			}
		}

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

		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 bool IsCraftingPinnedTooltipContext()
		{
			return TooltipController.IsCraftingPinnedContext();
		}

		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)
			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);
			}
			SetTopLeftRectLayoutCached(val2, new Vector2(16f, -16f), new Vector2(72f, 72f), "pinned-tooltip-icon");
			Image obj = ((Component)val2).GetComponent<Image>() ?? ((Component)val2).gameObject.AddComponent<Image>();
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		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;
				}
				if (flag || ShouldLogPinnedTooltipDebug())
				{
					LogPinnedTooltipLayoutDebug("frame-repair", i, val, val2);
				}
				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;
			}
			LogPinnedTooltipLayoutDebug("wheel", slot, panel, FindPinnedTooltipText(panel), component.TextContentHeight, component.TextViewportHeight, true);
			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) ? 1 : 0);
					((Behaviour)component.TextScrollRect).enabled = flag;
					LogPinnedTooltipLayoutDebug("scroll-repair", Array.IndexOf(PinnedTooltips.Crafting.Panels, panel), panel, text, pinnedTooltipTextOnlyPreferredHeight, num5, 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 GetCraftingPinnedTooltipMaxTextViewportHeight(float topReserved, float bottomReserved)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Max(120f, GetPinnedTooltipPanelSize().y - topReserved - bottomReserved);
		}

		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_0424: 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) ? 1 : 0);
				((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);
			LogPinnedTooltipLayoutDebug("layout", slot, panel, text, num3, num5, flag2);
			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_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_00e6: 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_00e3: 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_0124: 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;
				SetTopLeftRectLayoutCached(textScrollView, new Vector2(18f, 0f - cache.TextTopReserved), new Vector2(textWidth, viewportHeight), "pinned-tooltip-scroll-view");
				RectTransform? textViewport = cache.TextViewport;
				SetStretchRectLayoutCached(textViewport, Vector2.zero, Vector2.zero, "pinned-tooltip-viewport");
				RectTransform textContent = cache.TextContent;
				SetTopLeftRectLayoutCached(textContent, (resetScroll || !needsScroll) ? Vector2.zero : anchoredPosition, new Vector2(textWidth, contentHeight), "pinned-tooltip-content");
				RectTransform rectTransform = text.rectTransform;
				if ((Object)(object)((Transform)rectTransform).parent != (Object)(object)textContent)
				{
					((Transform)rectTransform).SetParent((Transform)(object)textContent, false);
				}
				SetTopLeftRectLayoutCached(rectTransform, Vector2.zero, new Vector2(textWidth, contentHeight), "pinned-tooltip-text");
				((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 bool ShouldLogPinnedTooltipDebug()
		{
			return false;
		}

		private static void LogPinnedTooltipLayoutDebug(string reason, int slot, RectTransform? panel, TMP_Text? text, float preferredHeight = -1f, float availableHeight = -1f, bool? needsScroll = null)
		{
			if (ShouldLogPinnedTooltipDebug())
			{
				float unscaledTime = Time.unscaledTime;
				string text2 = BuildPinnedTooltipLayoutDebugSignature(reason, slot, panel, text, preferredHeight, availableHeight, needsScroll);
				if (!(unscaledTime < PinnedTooltips.NextDebugTime) || !string.Equals(text2, PinnedTooltips.LastDebugSignature, StringComparison.Ordinal))
				{
					PinnedTooltips.NextDebugTime = unscaledTime + 0.75f;
					PinnedTooltips.LastDebugSignature = text2;
					Log.LogInfo((object)("PinnedTooltipDebug " + text2));
				}
			}
		}

		private static string BuildPinnedTooltipLayoutDebugSignature(string reason, int slot, RectTransform? panel, TMP_Text? text, float preferredHeight, float availableHeight, bool? needsScroll)
		{
			InventoryGui gui = InventoryGui.instance;
			string text2 = (((Object)(object)gui != (Object)null) ? ("craftTab=" + SafeReadBool(() => gui.InCraftTab()) + " upgradeTab=" + SafeReadBool(() => gui.InUpradeTab())) : "craftTab=<no-gui> upgradeTab=<no-gui>");
			PinnedTooltipPanelUiCache cache = (((Object)(object)panel != (Object)null && !IsUnityNull((Object?)(object)panel)) ? ((Component)panel).GetComponent<PinnedTooltipPanelUiCache>() : null);
			string text3 = DescribePinnedTooltipTextState(text);
			string text4 = DescribePinnedTooltipScrollState(cache);
			return $"reason={reason} slot={slot} context={TooltipController.ActivePinnedContext} {text2} preferred={preferredHeight:0.#} available={availableHeight:0.#} needsScroll={FormatNullableBool(needsScroll)} panel={DescribePinnedTooltipRect(panel)} text={text3} scroll={text4}";
		}

		private static string DescribePinnedTooltipTextState(TMP_Text? text)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)text == (Object)null || IsUnityNull((Object?)(object)text))
			{
				return "null";
			}
			RectTransform rectTransform = text.rectTransform;
			string text2 = text.text ?? "";
			object[] obj = new object[10]
			{
				((Object)text).name,
				((Behaviour)text).enabled,
				((Component)text).gameObject.activeSelf,
				((Component)text).gameObject.activeInHierarchy,
				((Graphic)text).color.a,
				text2.Length,
				text.maxVisibleLines,
				null,
				null,
				null
			};
			Rect rect = rectTransform.rect;
			obj[7] = ((Rect)(ref rect)).width;
			rect = rectTransform.rect;
			obj[8] = ((Rect)(ref rect)).height;
			Transform parent = ((Transform)rectTransform).parent;
			obj[9] = ((parent != null) ? ((Object)parent).name : null) ?? "<null>";
			return string.Format("{0}[enabled={1},activeSelf={2},activeInHierarchy={3},alpha={4:0.###},len={5},maxLines={6},rect={7:0.#}x{8:0.#},parent={9}]", obj);
		}

		private static string DescribePinnedTooltipScrollState(PinnedTooltipPanelUiCache? cache)
		{
			//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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cache == (Object)null || IsUnityNull((Object?)(object)cache))
			{
				return "cache-null";
			}
			string text = (((Object)(object)cache.TextScrollRect != (Object)null && !IsUnityNull((Object?)(object)cache.TextScrollRect)) ? string.Format("scrollRect[enabled={0},normalized={1:0.###},bar={2}]", ((Behaviour)cache.TextScrollRect).enabled, cache.TextScrollRect.verticalNormalizedPosition, ((Object)(object)cache.TextScrollRect.verticalScrollbar != (Object)null) ? ((Object)cache.TextScrollRect.verticalScrollbar).name : "<null>") : "scrollRect=null");
			object obj;
			if (!((Object)(object)cache.TextScrollbar != (Object)null) || IsUnityNull((Object?)(object)cache.TextScrollbar))
			{
				obj = "scrollbar=null";
			}
			else
			{
				object[] obj2 = new object[7]
				{
					((Behaviour)cache.TextScrollbar).enabled,
					((Component)cache.TextScrollbar).gameObject.activeSelf,
					((Component)cache.TextScrollbar).gameObject.activeInHierarchy,
					cache.TextScrollbar.size,
					cache.TextScrollbar.value,
					null,
					null
				};
				Rect rect = ((RectTransform)((Component)cache.TextScrollbar).transform).rect;
				obj2[5] = ((Rect)(ref rect)).width;
				rect = ((RectTransform)((Component)cache.TextScrollbar).transform).rect;
				obj2[6] = ((Rect)(ref rect)).height;
				obj = string.Format("scrollbar[enabled={0},activeSelf={1},activeInHierarchy={2},size={3:0.###},value={4:0.###},rect={5:0.#}x{6:0.#}]", obj2);
			}
			string text2 = (string)obj;
			return text + "," + text2 + ",viewport=" + DescribePinnedTooltipRect(cache.TextViewport) + ",content=" + DescribePinnedTooltipRect(cache.TextContent);
		}

		private static string DescribePinnedTooltipRect(RectTransform? rect)
		{
			//IL_0054: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return "null";
			}
			object[] obj = new object[8]
			{
				((Object)rect).name,
				((Component)rect).gameObject.activeSelf,
				((Component)rect).gameObject.activeInHierarchy,
				rect.anchoredPosition,
				rect.sizeDelta,
				null,
				null,
				null
			};
			Rect rect2 = rect.rect;
			obj[5] = ((Rect)(ref rect2)).width;
			rect2 = rect.rect;
			obj[6] = ((Rect)(ref rect2)).height;
			Transform parent = ((Transform)rect).parent;
			obj[7] = ((parent != null) ? ((Object)parent).name : null) ?? "<null>";
			return string.Format("{0}[activeSelf={1},activeInHierarchy={2},anchored={3},sizeDelta={4},rect={5:0.#}x{6:0.#},parent={7}]", obj);
		}

		private static string SafeReadBool(Func<bool> read)
		{
			try
			{
				return read() ? "true" : "false";
			}
			catch
			{
				return "<error>";
			}
		}

		private static string FormatNullableBool(bool? value)
		{
			if (!value.HasValue)
			{
				return "<unknown>";
			}
			if (!value.Value)
			{
				return "false";
			}
			return "true";
		}

		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.8f));
				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_006f: 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 (CraftingController.HoveredRecipeIndex >= 0 && TryGetCraftingRecipePair(instance, CraftingController.HoveredRecipeIndex, out var _))
				{
					SelectCraftingRecipeFromGrid(CraftingController.HoveredRecipeIndex);
					ToggleCraftingRecipeTooltip(instance, CraftingController.HoveredRecipeIndex);
					ResetHoverTooltipAfterPinnedTooltipToggle();
				}
				else if (TryGetInventoryPinnedTooltipHoverTarget(out grid, out pos, out item))
				{
					ToggleInventoryItemTooltip(instance, grid, pos, item);
					ResetHoverTooltipAfterPinnedTooltipToggle();
				}
			}
		}

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

		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_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0150: 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_0181: 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_0194: 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);
				}
				MarkCraftingBottomControlsDirty();
				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 = _craftingBottomControlsDirty || !string.Equals(_craftingBottomControlsSignature, recycleNReclaimBottomControlsLayoutSignature, StringComparison.Ordinal);
			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)
			{
				RectTransform rect = (RectTransform)((Component)gui.m_craftButton).transform;
				SetCraftingTopLeftRect(gui.m_crafting, rect, anchoredPosition, 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, flag, flag2 ? RecycleNReclaimHudYields : null);
			LayoutRecycleNReclaimHud(gui, grid);
			HideRecycleNReclaimVanillaDetailUi(gui);
			if ((Object)(object)gui.m_craftButton != (Object)null)
			{
				ApplyCraftingActionButtonTextStateColor(gui.m_craftButton, ((Selectable)gui.m_craftButton).interactable);
			}
			_craftingBottomControlsSignature = recycleNReclaimBottomControlsLayoutSignature;
			_craftingBottomControlsDirty = false;
		}

		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)
		{
			//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_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_0086: 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_00a2: 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_00dd: 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)
			string text = BuildRecycleNReclaimHudText(gui);
			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;
			SetStretchRectLayoutCached(val4, new Vector2(12f, 5f), new Vector2(-12f, -5f), "recycle-reclaim-hud-text");
			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, bool updateLayout, 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)
		{
			int selectedCraftingRecipeIndexSafe = GetSelectedCraftingRecipeIndexSafe(gui);
			if (selectedCraftingRecipeIndexSafe < 0)
			{
				return "";
			}
			bool flag = TryGetRecycleNReclaimSummary(selectedCraftingRecipeIndexSafe, RecycleNReclaimHudImpediments, RecycleNReclaimHudYields);
			string text = BuildRecycleNReclaimStatusText(gui, flag ? RecycleNReclaimHudImpediments : null);
			string text2 = BuildRecycleNReclaimDetailText(gui);
			if (string.IsNullOrWhiteSpace(text2) && !HasVisibleRecycleNReclaimYieldIcons(gui))
			{
				text2 = BuildRecycleNReclaimYieldText(flag ? RecycleNReclaimHudYields : null, gui);
			}
			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, InventoryGui gui)
		{
			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 BindConfigs()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Expected O, but got Unknown
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Expected O, but got Unknown
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Expected O, but got Unknown
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Expected O, but got Unknown
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Expected O, but got Unknown
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_0582: Expected O, but got Unknown
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Expected O, but got Unknown
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Expected O, but got Unknown
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Expected O, but got Unknown
			//IL_0898: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Expected O, but got Unknown
			//IL_08d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f5: Expected O, but got Unknown
			//IL_090e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0922: Unknown result type (might be due to invalid IL or missing references)
			//IL_092d: Expected O, but got Unknown
			//IL_0946: Unknown result type (might be due to invalid IL or missing references)
			//IL_095a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0965: Expected O, but got Unknown
			//IL_0984: Unknown result type (might be due to invalid IL or missing references)
			//IL_0998: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a3: Expected O, but got Unknown
			//IL_09b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d6: Expected O, but got Unknown
			//IL_09ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a09: Expected O, but got Unknown
			//IL_0a26: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a45: Expected O, but got Unknown
			//IL_0a62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a76: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a81: Expected O, but got Unknown
			//IL_0a9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abd: Expected O, but got Unknown
			//IL_0ada: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af9: Expected O, but got Unknown
			//IL_0b16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b35: Expected O, but got Unknown
			//IL_0b52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b71: Expected O, but got Unknown
			_serverConfigLocked = ConfigEntry("1 - General", "Lock Configuration", Toggle.On, "When enabled, only server admins can modify this mod's synced configuration.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			RemoveLegacyConfigEntries();
			_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", "Wishbone", "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", "DragonTear", "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", "YagluthDrop", "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", "QueenDrop", "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", "FaderDrop", "Comma-separated item prefab names or internal item names. Discovering any listed item unlocks extra row 5.")
			};
			_quickSlotCount = ConfigEntry("2 - Progressive Slots", "Quick Slot Count", 9, new ConfigDescription("Number of fixed quick slots reserved after equipment slots.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 9), 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.")
			};
			BindInventoryStateConfigInvalidation();
			_deathKeepRulesEnabled = ConfigEntry("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.");
			_enableInventoryTrashPanel = ConfigEntry("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.");
			_areaQuickStackRange = ConfigEntry("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.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			_areaRestockRange = ConfigEntry("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.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			_showHotbarSwitchHint = OrderedConfigEntry("3 - Client", "Show Hotbar Switch Hint", Toggle.On, "Show the hotbar row switch hint next to the hotbar. Not synced with server.", 800, synchronizedSetting: false);
			_inventoryRowsDisplayMode = OrderedConfigEntry("3 - 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);
			_pinnedTooltipSlots = OrderedConfigEntry("3 - Client", "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.", 700, synchronizedSetting: false);
			_showInventoryWheelButton = OrderedConfigEntry("3 - Client", "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.", 890, synchronizedSetting: false);
			_pinnedTooltipBackgroundAlpha = OrderedConfigEntry("3 - Client", "Pinned Tooltip Background Alpha", 0.8f, 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>()), 690, synchronizedSetting: false);
			_craftingHoverTooltipBackgroundAlpha = OrderedConfigEntry("3 - Client", "Crafting Hover Tooltip Background Alpha", 0.8f, 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>()), 683, synchronizedSetting: false);
			_inventoryContainerHoverTooltipBackgroundAlpha = OrderedConfigEntry("3 - Client", "Inventory Container Hover Tooltip Background Alpha", 1f, 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>()), 682, synchronizedSetting: false);
			_containerActionSuccessFxMode = OrderedConfigEntry("3 - Client", "Container Action Success FX Mode", 4, new ConfigDescription("Chest-unlock FX mode for hover hold area actions. 0 disables FX. 1 spawns FX at the interacted container. 2-12 spawns FX at each container whose stack changed, up to this many containers. Opened-container buttons do not spawn FX.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 12), Array.Empty<object>()), 670, synchronizedSetting: false);
			_containerActionSuccessFxVolume = OrderedConfigEntry("3 - Client", "Container Action Success FX Volume", 1f, new ConfigDescription("Volume multiplier for InventorySlots container action success FX audio. 0 mutes the FX sound and 1 keeps the original prefab volume.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), 669, synchronizedSetting: false);
			_inventorySortMode = OrderedConfigEntry("3 - 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.", 660, synchronizedSetting: false);
			LoadInventoryPanelPositionsFromClientState();
			_pinnedTooltipSlots.SettingChanged += delegate
			{
				InvalidatePinnedTooltipUi();
			};
			_pinnedTooltipBackgroundAlpha.SettingChanged += delegate
			{
				RefreshPinnedTooltipBackgrounds();
			};
			_craftingHoverTooltipBackgroundAlpha.SettingChanged += delegate
			{
				RefreshCraftingHoverTooltipBackground();
			};
			_inventoryContainerHoverTooltipBackgroundAlpha.SettingChanged += delegate
			{
				RefreshInventoryContainerHoverTooltipBackground();
			};
			_enableInventoryTrashPanel.SettingChanged += delegate
			{
				OnInventoryTrashPanelConfigChanged();
			};
			BindCraftingClientConfigs();
			_mouseUiScrollMultiplier = OrderedConfigEntry("3 - 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>()), 650, synchronizedSetting: false);
			_restockTargetStackLimitsConfig = ConfigEntry("5 - 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 = 100,
					CustomDrawer = DrawRestockTargetStackLimitsConfig
				}
			}), synchronizedSetting: false);
			_restockTargetStackLimitsConfig.SettingChanged += delegate
			{
				RefreshRestockTargetStackLimits();
			};
			RefreshRestockTargetStackLimits();
			_enableGamepadUiScroll = OrderedConfigEntry("6 - 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("6 - 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("6 - 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("6 - 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("6 - 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("6 - 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("6 - 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 = ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false);
			_containerRestockKey = ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false);
			_favoriteModifierKey = ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false);
			_pinnedTooltipKey = ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false);
			_quickSlotHotkeys = new ConfigEntry<KeyboardShortcut>[9]
			{
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false),
				ConfigEntry<KeyboardShortcut>("4 - 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>()), synchronizedSetting: false)
			};
		}

		private static void RemoveLegacyConfigEntries()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Expected O, but got Unknown
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("4 - Client", "Inventory Hover Tooltip Background Alpha"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Inventory Hover Tooltip Background Alpha"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("6 - Client UI Input", "Mouse UI Scroll Multiplier"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("6 - Client UI Input", "Enable Gamepad UI Scroll"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("6 - Client UI Input", "Gamepad UI Scroll Source"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("6 - Client UI Input", "Gamepad UI Scroll Sensitivity"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("6 - Client UI Input", "Gamepad UI Scroll Repeat Delay"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("6 - Client UI Input", "Gamepad UI Scroll Deadzone"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Show Container Action Success FX"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Jewelcrafting Tooltip Fallbacks"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Repair Inventory Panel Background"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Log Inventory Panel Background State"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Enable Inventory Trash Panel"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Equipment Slots Panel Position X"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Equipment Slots Panel Position Y"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Quick Slots Panel Position X"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Quick Slots Panel Position Y"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Crafting Recipe Grid Zoom Hint Size"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Crafting Recipe Grid Zoom Hint Offset X"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Crafting Recipe Grid Zoom Hint Offset Y"));
			((BaseUnityPlugin)_instance).Config.Remove(new ConfigDefinition("3 - Client", "Crafting Recipe Grid Zoom Hint Text Icon Gap"));
		}

		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>(_quickSlotCount);
			AddInventoryStateConfigInvalidation<Toggle>(_quickSlotProgressionEnabled);
			rowUnlockItems = _quickSlotRowUnlockItems;
			for (int i = 0; i < rowUnlockItems.Length; i++)
			{
				AddInventoryStateConfigInvalidation<string>(rowUnlockItems[i]);
			}
		}

		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();
			EnsureDefaultYamlFile();
			InitializeJewelcraftingSlotCompatibility();
			InitializeBackpackCompatibility();
			InitializeMagicSupremacyCompatibility();
			InitializeYamlSync();
			RebuildSlotDefinitions();
			_harmony.PatchAll();
			ApplyMyLittleUICraftingCompatibility();
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			Log.LogInfo((object)"InventorySlots loaded.");
		}

		private void Update()
		{
			ProcessYamlHotReload();
			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);
			HandleContainerRestockHotkey(localPlayer);
			UpdateQuickSlotsHud(localPlayer);
			UpdateHotbarSwitchHud();
			ApplyPinnedTooltipSlotLimit();
			RefreshJewelcraftingPinnedTooltips();
			HandlePinnedTooltipHotkey();
			HandleInventoryPinnedTooltipWheel();
			if (Time.time < _nextRefreshTime)
			{
				return;
			}
			float num = Mathf.Max(0.25f, 1f);
			_nextRefreshTime = Time.time + num;
			RefreshItemNameTokens();
			RebuildStationInputTokens();
			RefreshJewelcraftingSlotDefinitionsIfNeeded(localPlayer);
			PrunePendingSlotActions(localPlayer);
			if (PeriodicInventorySafetyAuditEnabled)
			{
				EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PeriodicAudit, InventoryStateAuditLevel.HeightOnly);
				float num2 = Mathf.Max(num, 5f);
				float num3 = Mathf.Max(num2, 30f);
				bool num4 = _nextHeavyAuditTime <= 0f || Time.time >= _nextHeavyAuditTime;
				bool flag = _nextLightAuditTime <= 0f || Time.time >= _nextLightAuditTime;
				if (num4)
				{
					_nextHeavyAuditTime = Time.time + num3;
					_nextLightAuditTime = Time.time + num2;
					EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PeriodicAudit, InventoryStateAuditLevel.FullIntegrity);
				}
				else if (flag)
				{
					_nextLightAuditTime = Time.time + num2;
					EnsureInventoryState(localPlayer, InventoryStateEnsureReason.PeriodicAudit, InventoryStateAuditLevel.SlotLight);
				}
			}
			else
			{
				_nextLightAuditTime = 0f;
				_nextHeavyAuditTime = 0f;
			}
		}

		private void OnDestroy()
		{
			Localizer.OnLocalizationComplete -= HandleLocalizationComplete;
			StopYamlWatcher();
			((BaseUnityPlugin)this).Config.Save();
		}

		private static void HandleLocalizationComplete()
		{
			_uiLocalizationVersion++;
			MarkCraftingSearchInputDirty();
			MarkCraftingGroupRailDirty();
			ClearCraftingEnglishLocalizationCaches();
			InvalidateCraftingRecipeGridLayout();
		}

		private static bool SetCompatCapabilityState(ref CompatCapabilityState field, CompatCapabilityState state, string capability, string detail = "")
		{
			if (field != state)
			{
				field = state;
				string arg = (string.IsNullOrWhiteSpace(detail) ? "" : (": " + detail));
				Log.LogDebug((object)$"Compatibility capability {capability}: {state}{arg}");
			}
			return state == CompatCapabilityState.Available;
		}

		private static bool IsSyncedStateReady()
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.IsSinglePlayer || ConfigSync.IsSourceOfTruth)
			{
				return true;
			}
			return ConfigSync.InitialSyncDone;
		}

		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 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("6 - 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 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 CreateSortKeyComponents(craftingRecipeItemData, GetCraftingRecipeResourceTier(((RecipeDataPair)(ref pair)).Recipe), craftingRecipeBigGroupId, localizedName).ToSortKey();
		}

		private static SortKey GetInventoryItemSortKey(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return SortKey.None;
			}
			string inventoryItemBigGroupId = GetInventoryItemBigGroupId(item);
			return CreateSortKeyComponents(item, GetInventoryItemResourceTier(item), inventoryItemBigGroupId, GetLocalizedItemName(item)).ToSortKey();
		}

		private static SortKeyComponents CreateSortKeyComponents(ItemData? item, int resourceTier, string bigGroupId, string localizedName)
		{
			int itemBigGroupRank = GetItemBigGroupRank(bigGroupId);
			int itemPredefinedGroupRank = GetItemPredefinedGroupRank(item, bigGroupId, itemBigGroupRank);
			return new SortKeyComponents(resourceTier, itemPredefinedGroupRank, itemBigGroupRank, GetCraftingEquipmentSetKey(item), GetCraftingEquipmentSlotOrder(item), localizedName);
		}

		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 (!SlotBackupEnabled || 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 inventorySlotsBackup = CreateSlotBackup(inventory);
				ISerializer serializer = new SerializerBuilder().Build();
				player.m_customData["InventorySlotsBackup"] = serializer.Serialize(inventorySlotsBackup);
				Log.LogDebug((object)$"Slot backup saved: {inventorySlotsBackup.nrOfItems} item(s), size {inventorySlotsBackup.width}x{inventorySlotsBackup.height}.");
			}
			catch (Exception arg)
			{
				Log.LogWarning((object)$"Failed to save slot backup: {arg}");
			}
		}

		internal static void TryRestoreSlotBackup(Player player)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0073: 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 (!SlotBackupEnabled || 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_0011: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			ItemData val = backupItem.Clone();
			if (!IsOutOfBounds(inventory, target) && TryGetSlotAtGridPos(inventory, target, out SlotDefinition slot) && slot.Accepts(val) && inventory.GetItemAt(target.x, target.y) == null)
			{
				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_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_003f: Unknown result type (might be due to invalid IL or missing references)
			SlotDefinition slot2 = slot;
			if (slot2.Kind == SlotKind.Quick)
			{
				if (!IsQuickSlotUnlocked(player, slot2))
				{
					return null;
				}
				Vector2i slotGridPos = GetSlotGridPos(inventory, slot2);
				ItemData itemAt = inventory.GetItemAt(slotGridPos.x, slotGridPos.y);
				if (itemAt == null || !slot2.Accepts(itemAt))
				{
					return null;
				}
				return itemAt;
			}
			ItemData val = (ItemData)(slot2.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 && slot2.Accepts(val))
			{
				return val;
			}
			string value;
			return ((IEnumerable<ItemData>)inventory.m_inventory).FirstOrDefault((Func<ItemData, bool>)((ItemData item) => item != null && IsInventorySlotsCustomEquipped(item) && item.m_customData.TryGetValue("InventorySlotsSlotId", out value) && string.Equals(value, slot2.Id, StringComparison.OrdinalIgnoreCase) && slot2.Accepts(item)));
		}

		internal static bool TryEquipIntoSlot(Player player, Inventory inventory, ItemData item, SlotDefinition slot)
		{
			//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_006d: 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_00f3: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			Player player2 = player;
			Inventory inventory2 = inventory;
			if (item == null || !slot.Accepts(item))
			{
				return false;
			}
			if (slot.Kind == SlotKind.Quick)
			{
				return TryPlaceQuickItemIntoSlot(player2, inventory2, item, slot);
			}
			if (!inventory2.ContainsItem(item))
			{
				inventory2.m_inventory.Add(item);
			}
			Vector2i slotGridPos = GetSlotGridPos(inventory2, slot);
			Vector2i gridPos = item.m_gridPos;
			bool incomingOriginalPosUsed = false;
			List<SlotEquipItemSnapshot> itemSnapshots = CaptureSlotEquipItemSnapshots(player2, inventory2, item, slot);
			HumanoidEquipmentSnapshot equipmentSnapshot = CaptureHumanoidEquipmentSnapshot(player2);
			ItemData val = FindItemForSlot(player2, inventory2, slot);
			if (val != null && val != item)
			{
				UnequipInventorySlotsItem(player2, val);
				if (!TryRelocateSlotEquipBlockingItem(player2, inventory2, val, item, gridPos, ref incomingOriginalPosUsed))
				{
					return FailSlotEquip();
				}
			}
			ItemData itemAt = inventory2.GetItemAt(slotGridPos.x, slotGridPos.y);
			if (itemAt != null && itemAt != item && itemAt != val)
			{
				UnequipInventorySlotsItem(player2, itemAt);
				if (!TryRelocateSlotEquipBlockingItem(player2, inventory2, itemAt, item, gridPos, ref incomingOriginalPosUsed))
				{
					return FailSlotEquip();
				}
			}
			UnequipConflictingCustomEquipmentItems(player2, inventory2, item, slot);
			if (slot.Kind == SlotKind.BuiltIn)
			{
				if (!((Humanoid)player2).IsItemEquiped(item) && !((Humanoid)player2).EquipItem(item, true))
				{
					return FailSlotEquip();
				}
			}
			else
			{
				item.m_equipped = true;
			}
			if (slot.Kind == SlotKind.CustomEquipment)
			{
				MarkItemSlot(player2, item, slot);
				OnCustomEquipmentCompatEquipped(player2, item);
			}
			else
			{
				ClearItemSlot(item);
			}
			item.m_gridPos = slotGridPos;
			((Humanoid)player2).SetupEquipment();
			if (slot.Kind == SlotKind.CustomEquipment)
			{
				UpdateCustomEquipmentVisuals(player2);
			}
			inventory2.Changed();
			return true;
			bool FailSlotEquip()
			{
				RestoreSlotEquipMutationSnapshots(player2, inventory2, 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)
			Inventory inventory2 = inventory;
			List<SlotEquipItemSnapshot> snapshots = new List<SlotEquipItemSnapshot>();
			HashSet<ItemData> seen = new HashSet<ItemData>();
			Add(incoming);
			Add(FindItemForSlot(player, inventory2, slot));
			Vector2i slotGridPos = GetSlotGridPos(inventory2, slot);
			Add(inventory2.GetItemAt(slotGridPos.x, slotGridPos.y));
			ItemData[] array = inventory2.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, inventory2.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(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 (TryFindDedicatedEquipmentSlot(item, out SlotDefinition slot))
			{
				return TryEquipIntoDedicatedSlot(localPlayer, inventory, item, slot);
			}
			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(ItemData item, out SlotDefinition? slot)
		{
			ItemData item2 = item;
			slot = SlotDefinitions.FirstOrDefault((SlotDefinition s) => s.Kind == SlotKind.CustomEquipment && s.Accepts(item2));
			if (slot != null)
			{
				return true;
			}
			slot = SlotDefinitions.FirstOrDefault((SlotDefinition s) => s.Kind == SlotKind.BuiltIn && s.Accepts(item2));
			return slot != null;
		}

		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_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)
			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);
			}
			if (IsInventorySlotsCustomEquipped(item))
			{
				OnCustomEquipmentCompatUnequipping(player, item);
				item.m_equipped = false;
				ClearItemSlot(item);
				((Humanoid)player).SetupEquipment();
			}
			ClearItemSlot(item);
			item.m_gridPos = slotGridPos;
			if (!inventory.ContainsItem(item))
			{
				inventory.m_inventory.Add(item);
			}
			inventory.Changed();
			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);
				}
				if (IsInventorySlotsCustomEquipped(item))
				{
					OnCustomEquipmentCompatUnequipping(player, item);
					item.m_equipped = false;
					ClearItemSlot(item);
					((Humanoid)player).SetupEquipment();
					UpdateCustomEquipmentVisuals(player);
				}
				ForceClearEquipmentReference(player, item);
			}
		}

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

		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_009b: 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 (!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)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || inventory == null || item == null || slot == null || slot.Kind == SlotKind.Quick || !slot.Accepts(item))
			{
				return false;
			}
			ClearSlotActionState(item);
			InventorySafety.PendingSlotEquips[item] = new PendingSlotEquip(item, slot, item.m_gridPos, 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 slot.Accepts(item);
			}
			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_00b3: 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(item, 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_0084: 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)
			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;
			}
			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 = false;
			}
			if (!flag)
			{
				RestoreSlotItemAfterFailedExternalRemoval(player, inventory, item, value.SourceSlot);
				((Character)player).Message((MessageType)2, "$msg_inventoryfull", 0, (Sprite)null);
			}
			inventory.Changed();
			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) && slot.Accepts(item))
			{
				TryEquipIntoSlot(player, inventory, item, slot);
			}
		}

		private static void ForceClearEquipmentReference(Player player, ItemData item)
		{
			if (!((Object)(object)player == (Object)null) && item != null)
			{
				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();
				}
			}
		}

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

		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)
		{
			Player player2 = player;
			ItemData item2 = item;
			Inventory inventory2 = inventory;
			return SlotDefinitions.Any((SlotDefinition slot) => IsQuickSlotUnlocked(player2, slot) && CanAutoAdoptGridSlot(item2, slot) && slot.Accepts(item2) && FindItemForSlot(player2, inventory2, slot) == null);
		}

		internal static bool TryAutoPlaceItemInSpecialSlot(Player player, Inventory inventory, ItemData item)
		{
			foreach (SlotDefinition slotDefinition in SlotDefinitions)
			{
				if (IsQuickSlotUnlocked(player, slotDefinition) && CanAutoAdoptGridSlot(item, slotDefinition) && slotDefinition.Accepts(item) && FindItemForSlot(player, inventory, slotDefinition) == null && TryEquipIntoSlot(player, inventory, item, slotDefinition))
				{
					return true;
				}
			}
			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 (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;
			}
			SetSlotAutoEquipSuppressed(suppressed: true);
			try
			{
				humanoid.UpdateEquipmentStatusEffects();
				UpdateCustomEquipmentVisuals(player);
			}
			finally
			{
				SetSlotAutoEquipSuppressed(suppressed: false);
			}
		}

		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 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 || CraftingRecipeHealthFoodInputTokens.Count > 0 || CraftingRecipeStaminaFoodInputTokens.Count > 0 || CraftingRecipeEitrFoodInputTokens.Count > 0 || CookingStationFoodInputTokens.Count > 0 || CookingStationHealthFoodInputTokens.Count > 0 || CookingStationStaminaFoodInputTokens.Count > 0 || CookingStationEitrFoodInputTokens.Count > 0 || FermenterInputTokens.Count > 0 || FermenterOutputTokens.Count > 0 || FermenterFoodInputTokens.Count > 0 || FermenterHealthFoodInputTokens.Count > 0 || FermenterStaminaFoodInputTokens.Count > 0 || FermenterEitrFoodInputTokens.Count > 0;
				StationTokenCookingStations.Clear();
				StationTokenFermenters.Clear();
				CookingStationInputTokens.Clear();
				CraftingRecipeFoodInputTokens.Clear();
				CraftingRecipeHealthFoodInputTokens.Clear();
				CraftingRecipeStaminaFoodInputTokens.Clear();
				CraftingRecipeEitrFoodInputTokens.Clear();
				CookingStationFoodInputTokens.Clear();
				CookingStationHealthFoodInputTokens.Clear();
				CookingStationStaminaFoodInputTokens.Clear();
				CookingStationEitrFoodInputTokens.Clear();
				FermenterInputTokens.Clear();
				FermenterOutputTokens.Clear();
				FermenterFoodInputTokens.Clear();
				FermenterHealthFoodInputTokens.Clear();
				FermenterStaminaFoodInputTokens.Clear();
				FermenterEitrFoodInputTokens.Clear();
				_stationInputTokensInitialized = false;
				_cachedStationInputObjectDbItemCount = num;
				_cachedStationInputPrefabCount = num3;
				_cachedStationInputRecipeCount = num2;
				if (num4)
				{
					ClearCraftingRecipeCaches();
				}
			}
			else if (force || !_stationInputTokensInitialized || _cachedStationInputObjectDbItemCount != num || _cachedStationInputPrefabCount != num3 || _cachedStationInputRecipeCount != num2)
			{
				RebuildStationComponentCache();
				_cachedStationInputObjectDbItemCount = num;
				_cachedStationInputPrefabCount = num3;
				_cachedStationInputRecipeCount = num2;
				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);
				HashSet<string> hashSet7 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet8 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet9 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet10 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet11 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet12 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet13 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet14 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				HashSet<string> hashSet15 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				CollectStationConversionTokens(hashSet, hashSet2, hashSet3, hashSet4, hashSet5, hashSet6, hashSet7, hashSet8, hashSet9, hashSet10, hashSet11, hashSet12, hashSet13, hashSet14, hashSet15);
				bool num5 = !CookingStationInputTokens.SetEquals(hashSet) || !CraftingRecipeFoodInputTokens.SetEquals(hashSet2) || !CraftingRecipeHealthFoodInputTokens.SetEquals(hashSet3) || !CraftingRecipeStaminaFoodInputTokens.SetEquals(hashSet4) || !CraftingRecipeEitrFoodInputTokens.SetEquals(hashSet5) || !CookingStationFoodInputTokens.SetEquals(hashSet6) || !CookingStationHealthFoodInputTokens.SetEquals(hashSet7) || !CookingStationStaminaFoodInputTokens.SetEquals(hashSet8) || !CookingStationEitrFoodInputTokens.SetEquals(hashSet9) || !FermenterInputTokens.SetEquals(hashSet10) || !FermenterOutputTokens.SetEquals(hashSet11) || !FermenterFoodInputTokens.SetEquals(hashSet12) || !FermenterHealthFoodInputTokens.SetEquals(hashSet13) || !FermenterStaminaFoodInputTokens.SetEquals(hashSet14) || !FermenterEitrFoodInputTokens.SetEquals(hashSet15);
				_stationInputTokensInitialized = true;
				if (num5)
				{
					CookingStationInputTokens.Clear();
					CookingStationInputTokens.UnionWith(hashSet);
					CraftingRecipeFoodInputTokens.Clear();
					CraftingRecipeFoodInputTokens.UnionWith(hashSet2);
					CraftingRecipeHealthFoodInputTokens.Clear();
					CraftingRecipeHealthFoodInputTokens.UnionWith(hashSet3);
					CraftingRecipeStaminaFoodInputTokens.Clear();
					CraftingRecipeStaminaFoodInputTokens.UnionWith(hashSet4);
					CraftingRecipeEitrFoodInputTokens.Clear();
					CraftingRecipeEitrFoodInputTokens.UnionWith(hashSet5);
					CookingStationFoodInputTokens.Clear();
					CookingStationFoodInputTokens.UnionWith(hashSet6);
					CookingStationHealthFoodInputTokens.Clear();
					CookingStationHealthFoodInputTokens.UnionWith(hashSet7);
					CookingStationStaminaFoodInputTokens.Clear();
					CookingStationStaminaFoodInputTokens.UnionWith(hashSet8);
					CookingStationEitrFoodInputTokens.Clear();
					CookingStationEitrFoodInputTokens.UnionWith(hashSet9);
					FermenterInputTokens.Clear();
					FermenterInputTokens.UnionWith(hashSet10);
					FermenterOutputTokens.Clear();
					FermenterOutputTokens.UnionWith(hashSet11);
					FermenterFoodInputTokens.Clear();
					FermenterFoodInputTokens.UnionWith(hashSet12);
					FermenterHealthFoodInputTokens.Clear();
					FermenterHealthFoodInputTokens.UnionWith(hashSet13);
					FermenterStaminaFoodInputTokens.Clear();
					FermenterStaminaFoodInputTokens.UnionWith(hashSet14);
					FermenterEitrFoodInputTokens.Clear();
					FermenterEitrFoodInputTokens.UnionWith(hashSet15);
					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> craftingRecipeHealthFoodInputTokens, HashSet<string> craftingRecipeStaminaFoodInputTokens, HashSet<string> craftingRecipeEitrFoodInputTokens, HashSet<string> cookingStationFoodInputTokens, HashSet<string> cookingStationHealthFoodInputTokens, HashSet<string> cookingStationStaminaFoodInputTokens, HashSet<string> cookingStationEitrFoodInputTokens, HashSet<string> fermenterInputTokens, HashSet<string> fermenterOutputTokens, HashSet<string> fermenterFoodInputTokens, HashSet<string> fermenterHealthFoodInputTokens, HashSet<string> fermenterStaminaFoodInputTokens, HashSet<string> fermenterEitrFoodInputTokens)
		{
			CollectCraftingRecipeFoodInputTokens(craftingRecipeFoodInputTokens, craftingRecipeHealthFoodInputTokens, craftingRecipeStaminaFoodInputTokens, craftingRecipeEitrFoodInputTokens);
			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, cookingStationHealthFoodInputTokens, cookingStationStaminaFoodInputTokens, cookingStationEitrFoodInputTokens);
				}
			}
			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, fermenterHealthFoodInputTokens, fermenterStaminaFoodInputTokens, fermenterEitrFoodInputTokens);
				}
			}
		}

		private static void CollectCraftingRecipeFoodInputTokens(HashSet<string> foodInputTokens, HashSet<string> healthFoodInputTokens, HashSet<string> staminaFoodInputTokens, HashSet<string> eitrFoodInputTokens)
		{
			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))
				{
					continue;
				}
				TryGetDominantFoodStat(recipe.m_item.m_itemData, out var stat);
				Requirement[] resources = recipe.m_resources;
				foreach (Requirement val in resources)
				{
					AddItemIdentityTokens(foodInputTokens, val.m_resItem);
					switch (stat)
					{
					case FoodStat.Health:
						AddItemIdentityTokens(healthFoodInputTokens, val.m_resItem);
						break;
					case FoodStat.Stamina:
						AddItemIdentityTokens(staminaFoodInputTokens, val.m_resItem);
						break;
					case FoodStat.Eitr:
						AddItemIdentityTokens(eitrFoodInputTokens, val.m_resItem);
						break;
					}
				}
			}
		}

		private static void AddStationConversionItemsWithFoodInputs(Component? station, HashSet<string>? inputTokens, HashSet<string>? outputTokens, HashSet<string>? foodInputTokens, HashSet<string>? healthFoodInputTokens, HashSet<string>? staminaFoodInputTokens, HashSet<string>? eitrFoodInputTokens)
		{
			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))
					{
						continue;
					}
					AddItemIdentityTokens(foodInputTokens, stationConversionItemDrop);
					if (TryGetDominantFoodStat(stationConversionItemDrop2.m_itemData, out var stat))
					{
						switch (stat)
						{
						case FoodStat.Health:
							AddItemIdentityTokens(healthFoodInputTokens, stationConversionItemDrop);
							break;
						case FoodStat.Stamina:
							AddItemIdentityTokens(staminaFoodInputTokens, stationConversionItemDrop);
							break;
						case FoodStat.Eitr:
							AddItemIdentityTokens(eitrFoodInputTokens, stationConversionItemDrop);
							break;
						}
					}
				}
				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 (TombstoneSafeguardsEnabled && !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_008d: 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)
			if (!TombstoneSafeguardsEnabled || (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 (inventory.GetTotalWeight() + val.GetTotalWeight() > player.GetMaxCarryWeight())
			{
				return false;
			}
			HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null)
				{
					hashSet.Add(allItem.m_gridPos);
					if (allItem.m_shared.m_maxStackSize > 1)
					{
						string stackKey = GetStackKey(allItem);
						dictionary[stackKey] = (dictionary.TryGetValue(stackKey, out var value) ? (value + allItem.m_shared.m_maxStackSize - allItem.m_stack) : (allItem.m_shared.m_maxStackSize - allItem.m_stack));
					}
				}
			}
			foreach (ItemData item in val.GetAllItemsInGridOrder())
			{
				if (item == null)
				{
					continue;
				}
				if (item.m_shared.m_maxStackSize > 1)
				{
					string stackKey2 = GetStackKey(item);
					if (dictionary.TryGetValue(stackKey2, out var value2) && value2 >= item.m_stack)
					{
						dictionary[stackKey2] = value2 - item.m_stack;
						continue;
					}
				}
				if (!TryFindVirtualFitCell(player, inventory, item, hashSet, out var pos))
				{
					return false;
				}
				hashSet.Add(pos);
			}
			return true;
		}

		internal static void CleanupTombstoneFloatingBodyForAutoPickup(TombStone? tombstone)
		{
			if (!TombstoneSafeguardsEnabled || 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);
						Log.LogDebug((object)"Destroyed detached tombstone body after take-all to prevent AutoPickup from reading stale floating terrain.");
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogDebug((object)("Tombstone floating body cleanup skipped: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static bool TryFindVirtualFitCell(Player player, Inventory inventory, ItemData item, HashSet<Vector2i> claimed, out Vector2i pos)
		{
			//IL_0032: 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_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_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_00c0: 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_0105: 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_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_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_0188: 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_0195: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			ItemData item2 = item;
			Player player2 = player;
			if (item2.m_gridPos.y >= GetFixedRegularRows() && !claimed.Contains(item2.m_gridPos) && CanUseCell(player2, inventory, item2, item2.m_gridPos))
			{
				pos = item2.m_gridPos;
				return true;
			}
			foreach (SlotDefinition item3 in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind != SlotKind.Quick && slot.Accepts(item2)))
			{
				Vector2i slotGridPos = GetSlotGridPos(inventory, item3);
				if (!claimed.Contains(slotGridPos))
				{
					pos = slotGridPos;
					return true;
				}
			}
			int usableRegularRows = GetUsableRegularRows(player2);
			Vector2i val = default(Vector2i);
			for (int i = 0; i < usableRegularRows; i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					((Vector2i)(ref val))..ctor(j, i);
					if (!claimed.Contains(val) && IsUsableRegularCell(inventory, player2, val))
					{
						pos = val;
						return true;
					}
				}
			}
			foreach (SlotDefinition item4 in SlotDefinitions.Where((SlotDefinition slot) => slot.Kind == SlotKind.Quick && IsQuickSlotUnlocked(player2, slot) && slot.Accepts(item2)))
			{
				Vector2i slotGridPos2 = GetSlotGridPos(inventory, item4);
				if (!claimed.Contains(slotGridPos2))
				{
					pos = slotGridPos2;
					return true;
				}
			}
			pos = new Vector2i(-1, -1);
			return false;
		}

		private static string GetStackKey(ItemData item)
		{
			return $"{item.m_shared.m_name}|{item.m_quality}|{item.m_worldLevel}";
		}

		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 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 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 bool SetTopLeftRectLayoutCached(RectTransform rect, Vector2 anchoredPosition, Vector2 size, string key)
		{
			//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_0052: 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_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_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_0047: Unknown result type (might be due to invalid IL or missing references)
			string signature = BuildRectLayoutSignature("top-left", key, 0, anchoredPosition, size);
			if (CanReuseRectLayout(rect, signature) && RectLayoutMatches(rect, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f), anchoredPosition, size))
			{
				return false;
			}
			bool result = SetTopLeftRectLayout(rect, anchoredPosition, size);
			SetRectLayoutSignature(rect, signature);
			return result;
		}

		private static bool SetTopLeftRectLayoutCached(RectTransform parent, RectTransform rect, Vector2 anchoredPosition, Vector2 size, string key, bool setAsLastSibling = true)
		{
			//IL_0022: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_009d: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)parent == (Object)null || IsUnityNull((Object?)(object)parent))
			{
				return false;
			}
			int instanceID = ((Object)parent).GetInstanceID();
			string signature = BuildRectLayoutSignature("top-left-parent", key, instanceID, anchoredPosition, size);
			bool flag = !setAsLastSibling || ((Object)(object)((Transform)rect).parent != (Object)null && ((Transform)rect).GetSiblingIndex() == ((Transform)rect).parent.childCount - 1);
			if (CanReuseRectLayout(rect, signature) && (Object)(object)((Transform)rect).parent == (Object)(object)parent && flag && RectLayoutMatches(rect, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f), anchoredPosition, size))
			{
				return false;
			}
			bool result = SetTopLeftRectLayout(parent, rect, anchoredPosition, size, setAsLastSibling);
			SetRectLayoutSignature(rect, signature);
			return result;
		}

		private static bool SetStretchRectLayoutCached(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax, string key)
		{
			//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_0025: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			string signature = BuildRectLayoutSignature("stretch", key, 0, offsetMin, offsetMax);
			if (CanReuseRectLayout(rect, signature) && StretchRectLayoutMatches(rect, offsetMin, offsetMax))
			{
				return false;
			}
			bool result = SetStretchRectLayout(rect, offsetMin, offsetMax);
			SetRectLayoutSignature(rect, signature);
			return result;
		}

		private static bool CanReuseRectLayout(RectTransform rect, string signature)
		{
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			RectTransformLayoutMarker component = ((Component)rect).GetComponent<RectTransformLayoutMarker>();
			if ((Object)(object)component != (Object)null && !IsUnityNull((Object?)(object)component))
			{
				return string.Equals(component.Signature, signature, StringComparison.Ordinal);
			}
			return false;
		}

		private static bool RectLayoutMatches(RectTransform rect, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPosition, Vector2 sizeDelta)
		{
			//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_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_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_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_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_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_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)
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			if (VectorApproximatelyEqual(rect.anchorMin, anchorMin) && VectorApproximatelyEqual(rect.anchorMax, anchorMax) && VectorApproximatelyEqual(rect.pivot, pivot) && VectorApproximatelyEqual(rect.anchoredPosition, anchoredPosition) && VectorApproximatelyEqual(rect.sizeDelta, sizeDelta) && ((Transform)rect).localScale == Vector3.one)
			{
				return ((Transform)rect).localRotation == Quaternion.identity;
			}
			return false;
		}

		private static bool StretchRectLayoutMatches(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || IsUnityNull((Object?)(object)rect))
			{
				return false;
			}
			if (VectorApproximatelyEqual(rect.anchorMin, Vector2.zero) && VectorApproximatelyEqual(rect.anchorMax, Vector2.one) && VectorApproximatelyEqual(rect.pivot, new Vector2(0.5f, 0.5f)) && VectorApproximatelyEqual(rect.offsetMin, offsetMin) && VectorApproximatelyEqual(rect.offsetMax, offsetMax) && ((Transform)rect).localScale == Vector3.one)
			{
				return ((Transform)rect).localRotation == Quaternion.identity;
			}
			return false;
		}

		private static bool VectorApproximatelyEqual(Vector2 left, Vector2 right)
		{
			//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)
			Vector2 val = left - right;
			return ((Vector2)(ref val)).sqrMagnitude <= 0.0001f;
		}

		private static void SetRectLayoutSignature(RectTransform rect, string signature)
		{
			if (!((Object)(object)rect == (Object)null) && !IsUnityNull((Object?)(object)rect))
			{
				(((Component)rect).GetComponent<RectTransformLayoutMarker>() ?? ((Component)rect).gameObject.AddComponent<RectTransformLayoutMarker>()).Signature = signature;
			}
		}

		private static string BuildRectLayoutSignature(string mode, string key, int parentId, Vector2 first, Vector2 second)
		{
			return mode + "|" + key + "|" + parentId + "|" + first.x.ToString("0.###", CultureInfo.InvariantCulture) + "," + first.y.ToString("0.###", CultureInfo.InvariantCulture) + "|" + second.x.ToString("0.###", CultureInfo.InvariantCulture) + "," + second.y.ToString("0.###", CultureInfo.InvariantCulture);
		}

		private static void InitializeYamlSync()
		{
			_syncedYaml = new CustomSyncedValue<string>(ConfigSync, "InventorySlotsYaml", "");
			_syncedYaml.ValueChanged += delegate
			{
				ApplyYaml(_syncedYaml.Value, fromSync: true);
			};
			EnsureBuiltInYamlStable();
			string text = ReadYamlFileOrDefault();
			if (ApplyYaml(text, fromSync: false))
			{
				_syncedYaml.AssignLocalValue(text);
			}
			else
			{
				_syncedYaml.AssignLocalValue(DefaultYaml);
			}
			StartYamlWatcher();
		}

		private static void EnsureBuiltInYamlStable()
		{
			if (!ApplyYaml(DefaultYaml, fromSync: false))
			{
				Log.LogError((object)"Built-in InventorySlots YAML failed to apply. Falling back to built-in equipment slots only.");
				_yamlConfig = new YamlRoot();
				RebuildPredefinedGroups();
				RebuildResourceMap();
				RebuildSlotDefinitions();
				ClearCraftingRecipeCaches();
			}
		}

		private static void StartYamlWatcher()
		{
			StopYamlWatcher();
			string directoryName = Path.GetDirectoryName(YamlFilePath);
			if (!string.IsNullOrWhiteSpace(directoryName))
			{
				Directory.CreateDirectory(directoryName);
				_yamlWatcher = new FileSystemWatcher(directoryName, "InventorySlots.yml")
				{
					IncludeSubdirectories = false,
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime)
				};
				FileSystemEventHandler value = delegate
				{
					QueueYamlReload();
				};
				RenamedEventHandler value2 = delegate
				{
					QueueYamlReload();
				};
				ErrorEventHandler value3 = delegate
				{
					QueueYamlReload();
				};
				_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 QueueYamlReload()
		{
			lock (YamlReloadLock)
			{
				_yamlReloadQueued = true;
				_yamlReloadAfterUtc = DateTime.UtcNow.AddMilliseconds(250.0);
			}
		}

		private static void ProcessYamlHotReload()
		{
			lock (YamlReloadLock)
			{
				if (!_yamlReloadQueued || DateTime.UtcNow < _yamlReloadAfterUtc)
				{
					return;
				}
				_yamlReloadQueued = false;
			}
			if (!CanApplyLocalYamlChanges())
			{
				return;
			}
			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();
			}
			catch (UnauthorizedAccessException ex2)
			{
				Log.LogWarning((object)("InventorySlots YAML hot reload delayed because the file cannot be read yet: " + ex2.Message));
				QueueYamlReload();
			}
		}

		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 void EnsureDefaultYamlFile()
		{
			if (!File.Exists(YamlFilePath))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(YamlFilePath));
				File.WriteAllText(YamlFilePath, DefaultYaml);
			}
		}

		private static bool ApplyYaml(string yaml, bool fromSync)
		{
			YamlApplySnapshot snapshot = CreateYamlApplySnapshot();
			try
			{
				_yamlConfig = ParseYaml(yaml);
				RebuildPredefinedGroups();
				RebuildResourceMap();
				RebuildStationInputTokens(force: true);
				RebuildSlotDefinitions();
				ClearCraftingRecipeCaches();
				Player localPlayer = Player.m_localPlayer;
				if (!IsUnityNull((Object?)(object)localPlayer))
				{
					EnsureInventoryState(localPlayer, InventoryStateEnsureReason.YamlReload);
				}
				return true;
			}
			catch (Exception arg)
			{
				RestoreYamlApplySnapshot(snapshot);
				Log.LogWarning((object)string.Format("Failed to apply {0} InventorySlots YAML; keeping the last stable configuration: {1}", fromSync ? "synced" : "local", arg));
				return false;
			}
		}

		private static YamlApplySnapshot CreateYamlApplySnapshot()
		{
			return new YamlApplySnapshot(_yamlConfig, SlotDefinitions.ToList(), new Dictionary<string, YamlPredefinedGroup>(PredefinedGroupDefinitions, 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), new Dictionary<string, int>(ResourceTierByToken, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CookingStationInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CraftingRecipeFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CraftingRecipeHealthFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CraftingRecipeStaminaFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CraftingRecipeEitrFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CookingStationFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CookingStationHealthFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CookingStationStaminaFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(CookingStationEitrFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(FermenterInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(FermenterOutputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(FermenterFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(FermenterHealthFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(FermenterStaminaFoodInputTokens, StringComparer.OrdinalIgnoreCase), new HashSet<string>(FermenterEitrFoodInputTokens, StringComparer.OrdinalIgnoreCase), _stationInputTokensInitialized, _cachedStationInputObjectDbItemCount, _cachedStationInputPrefabCount, _cachedStationInputRecipeCount);
		}

		private static void RestoreYamlApplySnapshot(YamlApplySnapshot snapshot)
		{
			_yamlConfig = snapshot.Config;
			SlotDefinitions.Clear();
			SlotDefinitions.AddRange(snapshot.SlotDefinitions);
			InvalidateSlotDefinitionCaches();
			PredefinedGroupDefinitions.Clear();
			foreach (KeyValuePair<string, YamlPredefinedGroup> predefinedGroupDefinition in snapshot.PredefinedGroupDefinitions)
			{
				PredefinedGroupDefinitions[predefinedGroupDefinition.Key] = predefinedGroupDefinition.Value;
			}
			PredefinedGroupOrder.Clear();
			PredefinedGroupOrder.AddRange(snapshot.PredefinedGroupOrder);
			PredefinedGroupOrders.Clear();
			foreach (KeyValuePair<string, List<string>> predefinedGroupOrder in snapshot.PredefinedGroupOrders)
			{
				PredefinedGroupOrders[predefinedGroupOrder.Key] = predefinedGroupOrder.Value.ToList();
			}
			ResourceTierByToken.Clear();
			foreach (KeyValuePair<string, int> item in snapshot.ResourceTierByToken)
			{
				ResourceTierByToken[item.Key] = item.Value;
			}
			CookingStationInputTokens.Clear();
			CookingStationInputTokens.UnionWith(snapshot.CookingStationInputTokens);
			CraftingRecipeFoodInputTokens.Clear();
			CraftingRecipeFoodInputTokens.UnionWith(snapshot.CraftingRecipeFoodInputTokens);
			CraftingRecipeHealthFoodInputTokens.Clear();
			CraftingRecipeHealthFoodInputTokens.UnionWith(snapshot.CraftingRecipeHealthFoodInputTokens);
			CraftingRecipeStaminaFoodInputTokens.Clear();
			CraftingRecipeStaminaFoodInputTokens.UnionWith(snapshot.CraftingRecipeStaminaFoodInputTokens);
			CraftingRecipeEitrFoodInputTokens.Clear();
			CraftingRecipeEitrFoodInputTokens.UnionWith(snapshot.CraftingRecipeEitrFoodInputTokens);
			CookingStationFoodInputTokens.Clear();
			CookingStationFoodInputTokens.UnionWith(snapshot.CookingStationFoodInputTokens);
			CookingStationHealthFoodInputTokens.Clear();
			CookingStationHealthFoodInputTokens.UnionWith(snapshot.CookingStationHealthFoodInputTokens);
			CookingStationStaminaFoodInputTokens.Clear();
			CookingStationStaminaFoodInputTokens.UnionWith(snapshot.CookingStationStaminaFoodInputTokens);
			CookingStationEitrFoodInputTokens.Clear();
			CookingStationEitrFoodInputTokens.UnionWith(snapshot.CookingStationEitrFoodInputTokens);
			FermenterInputTokens.Clear();
			FermenterInputTokens.UnionWith(snapshot.FermenterInputTokens);
			FermenterOutputTokens.Clear();
			FermenterOutputTokens.UnionWith(snapshot.FermenterOutputTokens);
			FermenterFoodInputTokens.Clear();
			FermenterFoodInputTokens.UnionWith(snapshot.FermenterFoodInputTokens);
			FermenterHealthFoodInputTokens.Clear();
			FermenterHealthFoodInputTokens.UnionWith(snapshot.FermenterHealthFoodInputTokens);
			FermenterStaminaFoodInputTokens.Clear();
			FermenterStaminaFoodInputTokens.UnionWith(snapshot.FermenterStaminaFoodInputTokens);
			FermenterEitrFoodInputTokens.Clear();
			FermenterEitrFoodInputTokens.UnionWith(snapshot.FermenterEitrFoodInputTokens);
			_stationInputTokensInitialized = snapshot.StationInputTokensInitialized;
			_cachedStationInputObjectDbItemCount = snapshot.CachedStationInputObjectDbItemCount;
			_cachedStationInputPrefabCount = snapshot.CachedStationInputPrefabCount;
			_cachedStationInputRecipeCount = snapshot.CachedStationInputRecipeCount;
		}

		private static YamlRoot ParseYaml(string yaml)
		{
			return InventorySlotsConfigCore.ParseYaml(yaml);
		}

		private static void RebuildPredefinedGroups()
		{
			PredefinedGroupDefinitions.Clear();
			PredefinedGroupOrder.Clear();
			PredefinedGroupOrders.Clear();
			AddBuiltInPredefinedGroupOrders();
			ApplyYamlGroups(_yamlConfig.Groups);
		}

		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 + "."));
					continue;
				}
				PredefinedGroupDefinitions[text] = new YamlPredefinedGroup
				{
					Id = text,
					Match = new YamlGroupMatch
					{
						Prefabs = (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 (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 RebuildResourceMap()
		{
			ResourceTierByToken.Clear();
			foreach (KeyValuePair<string, int> item in InventorySlotsConfigCore.BuildResourceTierMap(_yamlConfig))
			{
				ResourceTierByToken[item.Key] = item.Value;
			}
		}

		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)));
			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))
				{
					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 i = 0; i < GetQuickSlotCount(); i++)
			{
				int quickSlotIndex = i;
				int num = i + 1;
				string name2 = LocalizeUi("$inventoryslots_quick_slot_format", "Quick {index}").Replace("{index}", num.ToString());
				SlotDefinitions.Add(new SlotDefinition($"quick{num}", 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)
		{
			string id2 = id;
			YamlSlot yamlSlot = slots.FirstOrDefault((YamlSlot entry) => string.Equals(NormalizeSlotId(entry.Id), id2, 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 void RefreshItemNameTokens()
		{
			ObjectDB instance = ObjectDB.instance;
			if (IsUnityNull((Object?)(object)instance) || instance.m_items == null || (_cachedObjectDbItemCount == instance.m_items.Count && ItemNameTokens.Count > 0))
			{
				return;
			}
			ItemNameTokens.Clear();
			_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))
					{
						ItemNameTokens[((Object)item).name] = text;
						ItemNameTokens[text] = text;
					}
				}
			}
		}

		private static bool ItemMatchesAnyToken(ItemData? item, HashSet<string> tokens)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			foreach (string token in tokens)
			{
				if (TryGetPredefinedGroupToken(token, out string groupId) && ItemMatchesPredefinedGroup(item, groupId))
				{
					return true;
				}
			}
			if (tokens.Contains(item.m_shared.m_name))
			{
				return true;
			}
			if (!IsUnityNull((Object?)(object)item.m_dropPrefab) && tokens.Contains(((Object)item.m_dropPrefab).name))
			{
				return true;
			}
			return false;
		}

		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 TryGetPredefinedGroupToken(string token, out string groupId)
		{
			groupId = "";
			if (string.IsNullOrWhiteSpace(token))
			{
				return false;
			}
			string text = token.Trim();
			if (text.StartsWith("@", StringComparison.Ordinal))
			{
				groupId = NormalizeGroupId(text.Substring(1));
				return !string.IsNullOrWhiteSpace(groupId);
			}
			if (text.StartsWith("group:", StringComparison.OrdinalIgnoreCase))
			{
				groupId = NormalizeGroupId(text.Substring("group:".Length));
				return !string.IsNullOrWhiteSpace(groupId);
			}
			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)
		{
			return ItemMatchesPredefinedGroup(item, groupId, new HashSet<string>(StringComparer.OrdinalIgnoreCase));
		}

		private static bool ItemMatchesPredefinedGroup(ItemData? item, string groupId, HashSet<string> visiting)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			string text = NormalizeGroupId(groupId);
			if (string.IsNullOrWhiteSpace(text) || !visiting.Add(text))
			{
				return false;
			}
			try
			{
				if (PredefinedGroupDefinitions.TryGetValue(text, out YamlPredefinedGroup value))
				{
					return ItemMatchesYamlPredefinedGroup(item, value, visiting);
				}
				return ItemMatchesBuiltInPredefinedGroup(item, text);
			}
			finally
			{
				visiting.Remove(text);
			}
		}

		private static bool ItemMatchesYamlPredefinedGroup(ItemData item, YamlPredefinedGroup group, HashSet<string> visiting)
		{
			ItemData item2 = item;
			HashSet<string> visiting2 = visiting;
			YamlGroupMatch match = group.Match;
			if (match == null)
			{
				return false;
			}
			bool hasCondition = false;
			bool matched = true;
			if (HasConfiguredValues(match.Groups))
			{
				Require(match.Groups.Any((string groupId) => ItemMatchesPredefinedGroup(item2, groupId, visiting2)));
			}
			if (HasConfiguredValues(match.ItemTypes))
			{
				Require(match.ItemTypes.Any((string token) => ItemTypeTokenMatches(item2.m_shared.m_itemType, token)));
			}
			if (HasConfiguredValues(match.SkillTypes))
			{
				Require(match.SkillTypes.Any((string token) => SkillTypeTokenMatches(item2.m_shared.m_skillType, token)));
			}
			if (HasConfiguredValues(match.Prefabs))
			{
				Require(match.Prefabs.Any((string token) => ItemMatchesExactPrefabOrName(item2, token)));
			}
			if (HasConfiguredValues(match.PrefabAny))
			{
				Require(match.PrefabAny.Any((string pattern) => ItemMatchesPrefabPattern(item2, pattern)));
			}
			if (HasConfiguredValues(match.NameAny))
			{
				Require(match.NameAny.Any((string pattern) => ItemMatchesNamePattern(item2, pattern)));
			}
			if (HasConfiguredValues(match.AmmoTypes))
			{
				string ammoType = GetAmmoType(item2);
				Require(match.AmmoTypes.Any((string token) => string.Equals(ammoType, token, StringComparison.OrdinalIgnoreCase)));
			}
			if (match.MaxStackGreaterThan.HasValue)
			{
				Require(item2.m_shared.m_maxStackSize > match.MaxStackGreaterThan.Value);
			}
			if (match.ValueGreaterThan.HasValue)
			{
				Require(item2.m_shared.m_value > match.ValueGreaterThan.Value);
			}
			if (match.HasFood.HasValue)
			{
				Require(MatchFoodCategory(item2) == match.HasFood.Value);
			}
			if (match.HasStatusEffect.HasValue)
			{
				Require((Object)(object)item2.m_shared.m_consumeStatusEffect != (Object)null == match.HasStatusEffect.Value);
			}
			return hasCondition && matched;
			void Require(bool condition)
			{
				hasCondition = true;
				matched &= condition;
			}
		}

		private static bool HasConfiguredValues(List<string>? values)
		{
			return values?.Any((string value) => !string.IsNullOrWhiteSpace(value)) ?? false;
		}

		private static bool ItemMatchesExactPrefabOrName(ItemData item, string token)
		{
			if (string.IsNullOrWhiteSpace(token))
			{
				return false;
			}
			string b = CleanPrefabName(token);
			if (!string.Equals(item.m_shared.m_name, token, StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(GetItemPrefabName(item), b, StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool ItemMatchesPrefabPattern(ItemData item, string pattern)
		{
			return PatternMatches(GetItemPrefabName(item), pattern);
		}

		private static bool ItemMatchesNamePattern(ItemData item, string pattern)
		{
			string sharedName = GetSharedName(item);
			string value = ((Localization.instance != null) ? Localization.instance.Localize(sharedName) : sharedName);
			if (!PatternMatches(sharedName, pattern))
			{
				return PatternMatches(value, pattern);
			}
			return true;
		}

		private static bool ItemMatchesAnyPattern(ItemData item, IEnumerable<string> patterns)
		{
			ItemData item2 = item;
			return patterns.Any((string pattern) => ItemMatchesPrefabPattern(item2, pattern) || ItemMatchesNamePattern(item2, pattern));
		}

		private static bool PatternMatches(string value, string pattern)
		{
			if (string.IsNullOrWhiteSpace(value) || string.IsNullOrWhiteSpace(pattern))
			{
				return false;
			}
			string text = CleanPrefabName(value);
			string text2 = CleanPrefabName(pattern);
			if (text2.IndexOf("*", StringComparison.Ordinal) >= 0)
			{
				return WildcardMatches(text, text2);
			}
			return text.IndexOf(text2, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool WildcardMatches(string value, string pattern)
		{
			string[] array = pattern.Split(new char[1] { '*' }, StringSplitOptions.None);
			int startIndex = 0;
			bool flag = !pattern.StartsWith("*", StringComparison.Ordinal);
			bool flag2 = !pattern.EndsWith("*", StringComparison.Ordinal);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i];
				if (text.Length != 0)
				{
					int num = value.IndexOf(text, startIndex, StringComparison.OrdinalIgnoreCase);
					if (num < 0 || (flag && i == 0 && num != 0))
					{
						return false;
					}
					startIndex = num + text.Length;
				}
			}
			if (flag2 && array.Length != 0)
			{
				return value.EndsWith(array[^1], StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
	internal static class ClientStateCore
	{
		public static InventorySlotsClientState Normalize(InventorySlotsClientState? state)
		{
			if (state == null)
			{
				state = new InventorySlotsClientState();
			}
			InventorySlotsClientState inventorySlotsClientState = state;
			InventorySlotsClientInventoryState inventorySlotsClientInventoryState2;
			if (inventorySlotsClientState.Inventory == null)
			{
				inventorySlotsClientInventoryState2 = (inventorySlotsClientState.Inventory = new InventorySlotsClientInventoryState());
			}
			inventorySlotsClientInventoryState2 = state.Inventory;
			if (inventorySlotsClientInventoryState2.EquipmentSlotsPanelPosition == null)
			{
				InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition2 = (inventorySlotsClientInventoryState2.EquipmentSlotsPanelPosition = new InventorySlotsClientPanelPosition(-80f, 0f));
			}
			inventorySlotsClientInventoryState2 = state.Inventory;
			if (inventorySlotsClientInventoryState2.QuickSlotsPanelPosition == null)
			{
				InventorySlotsClientPanelPosition inventorySlotsClientPanelPosition2 = (inventorySlotsClientInventoryState2.QuickSlotsPanelPosition = new InventorySlotsClientPanelPosition(-80f, -552f));
			}
			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> list2 = (inventorySlotsClientPlayerState2.FavoriteSlots = new List<InventorySlotsFavoriteSlot>());
					}
					inventorySlotsClientPlayerState2 = inventorySlotsClientPlayerState;
					if (inventorySlotsClientPlayerState2.CraftingFavorites == null)
					{
						List<string> list4 = (inventorySlotsClientPlayerState2.CraftingFavorites = new List<string>());
					}
					inventorySlotsClientPlayerState2 = inventorySlotsClientPlayerState;
					if (inventorySlotsClientPlayerState2.UpgradeFavorites == null)
					{
						List<string> list4 = (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);

	}
	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(typeof(InventoryGui), "OnTakeAll")]
	internal static class InventoryGuiSafeTakeAllPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			return !InventorySlotsPlugin.TryHandleSafeTakeAll(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnStackAll")]
	internal static class InventoryGuiPlaceStacksPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			return !InventorySlotsPlugin.TryHandleVanillaPlaceStacks(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Show")]
	internal static class InventoryGuiShowValidateInventoryPatch
	{
		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 void Postfix(InventoryGui __instance, Player player)
		{
			InventorySlotsPlugin.OnInventoryGuiUpdateContainer(__instance, player);
		}
	}
	[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 Postfix(Container __instance)
		{
			InventorySlotsPlugin.UnregisterContainer(__instance);
		}
	}
	internal static class CraftingRecipeViewCore
	{
		public static int CompareFavoritesOnly(bool aIsFavorite, bool bIsFavorite, bool aCanCraft, bool bCanCraft, int aOriginalIndex, int bOriginalIndex)
		{
			int num = CompareFavoriteAndCraftable(aIsFavorite, bIsFavorite, aCanCraft, bCanCraft);
			if (num == 0)
			{
				return aOriginalIndex.CompareTo(bOriginalIndex);
			}
			return num;
		}

		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;
		}
	}
	[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.PrepareCraftingQueue(__instance);
		}

		private static void Postfix(InventoryGui __instance)
		{
			InventorySlotsPlugin.ValidateCraftingQueueStarted(__instance);
		}
	}
	[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.CaptureUpgradeFavoriteBeforeCrafting(__instance);
		}

		private static void Postfix(InventoryGui __instance, Player player)
		{
			InventorySlotsPlugin.RestoreUpgradeFavoriteAfterCrafting(__instance, player);
		}
	}
	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;
		}
	}
	[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 List<InventorySlotsPlugin.KeepOnDeathItemState> __state)
		{
			__state = InventorySlotsPlugin.PrepareKeepOnDeathItems(__instance);
		}

		private static void Postfix(Player __instance, List<InventorySlotsPlugin.KeepOnDeathItemState> __state)
		{
			InventorySlotsPlugin.RestoreKeepOnDeathItems(__instance, __state);
		}

		private static void Finalizer(Player __instance, List<InventorySlotsPlugin.KeepOnDeathItemState> __state)
		{
			InventorySlotsPlugin.RestoreKeepOnDeathItems(__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(Humanoid), "UpdateEquipmentStatusEffects")]
	internal static class HumanoidUpdateEquipmentStatusEffectsPatch
	{
		private static void Prefix(Humanoid __instance)
		{
			InventorySlotsPlugin.TryPrepareCustomEquipmentProjection(__instance);
		}

		private static void Postfix(Humanoid __instance)
		{
			InventorySlotsPlugin.ApplyCustomEquipmentProjection(__instance);
		}

		private static void Finalizer()
		{
			InventorySlotsPlugin.ClearCustomEquipmentProjection();
		}
	}
	[HarmonyPatch(typeof(SEMan), "RemoveStatusEffect", new Type[]
	{
		typeof(int),
		typeof(bool)
	})]
	internal static class SEManRemoveStatusEffectInventorySlotsPatch
	{
		private static void Prefix(SEMan __instance, ref int nameHash)
		{
			InventorySlotsPlugin.FilterCustomEquipmentStatusRemoval(__instance, ref nameHash);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "GetEquipmentWeight")]
	internal static class HumanoidGetEquipmentWeightPatch
	{
		private static void Postfix(Humanoid __instance, ref float __result)
		{
			InventorySlotsPlugin.AddProjectedEquipmentWeight(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Player), "GetEquipmentEitrRegenModifier")]
	internal static class PlayerGetEquipmentEitrRegenModifierPatch
	{
		private static void Postfix(Player __instance, ref float __result)
		{
			InventorySlotsPlugin.AddProjectedEquipmentEitrRegenModifier(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Player), "GetBodyArmor")]
	internal static class PlayerGetBodyArmorInventorySlotsPatch
	{
		private static void Postfix(Player __instance, ref float __result)
		{
			InventorySlotsPlugin.AddProjectedBodyArmor(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(Player), "ApplyArmorDamageMods")]
	internal static class PlayerApplyArmorDamageModsInventorySlotsPatch
	{
		private static void Postfix(Player __instance, ref DamageModifiers mods)
		{
			InventorySlotsPlugin.ApplyProjectedArmorDamageModifiers(__instance, ref mods);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
	internal static class HumanoidUpdateEquipmentPatch
	{
		private static void Postfix(Humanoid __instance, float dt)
		{
			InventorySlotsPlugin.OnHumanoidUpdateEquipment(__instance, dt);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "GetSetCount")]
	internal static class HumanoidGetSetCountPatch
	{
		private static void Postfix(Humanoid __instance, string setName, ref int __result)
		{
			InventorySlotsPlugin.AddProjectedEquipmentSetCount(__instance, setName, ref __result);
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateModifiers")]
	internal static class PlayerUpdateModifiersPatch
	{
		private static void Postfix(Player __instance)
		{
			InventorySlotsPlugin.OnPlayerUpdateModifiers(__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);
		}
	}
	[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);
		}
	}
	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", "ArmorRagsChest", "helmet", "chest", "legs", "cape", "utility", "trinket"),
			new BuiltInItemGroupSection("Food", "food", "Equipment", "Food", "CookedMeat", "healthfood", "staminafood", "eitrfood"),
			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")
		};

		public static readonly IReadOnlyList<string> DefaultKeepOnDeath = new string[4] { "Melee", "Ranged", "Magic", "Equipment" };

		public static readonly IReadOnlyList<string> DefaultQuickSlots = new string[8] { "Melee", "Ranged", "Magic", "healthfood", "staminafood", "eitrfood", "mead", "potion" };

		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(NormalizeId), 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(NormalizeId(groupId));
		}

		public static IEnumerable<string> GlobalSubgroupOrder()
		{
			return new string[1] { "favorite" }.Concat(Sections.SelectMany((BuiltInItemGroupSection section) => section.Subgroups)).Distinct<string>(StringComparer.OrdinalIgnoreCase);
		}

		public static string BuildDefaultYamlPrefix()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# Item groups control subgroup order for crafting, inventory, and container");
			stringBuilder.AppendLine("# sorting. Melee/Ranged/Magic/Equipment/Food/Consumable/Meadbase/Misc are");
			stringBuilder.AppendLine("# fixed top-level sections. Other keys define custom prefab groups, which can be");
			stringBuilder.AppendLine("# inserted into those sections or referenced by KeepOnDeath and QuickSlots.");
			stringBuilder.AppendLine("Groups:");
			foreach (BuiltInItemGroupSection section in Sections)
			{
				stringBuilder.AppendLine("  " + section.YamlName + ":");
				if (section.Subgroups.Count == 1 && string.Equals(section.Subgroups[0], section.Id, StringComparison.OrdinalIgnoreCase))
				{
					stringBuilder.Length -= ("  " + section.YamlName + ":" + Environment.NewLine).Length;
					stringBuilder.AppendLine("  " + section.YamlName + ": []");
					continue;
				}
				foreach (string subgroup in section.Subgroups)
				{
					stringBuilder.AppendLine("    - " + subgroup);
				}
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("# Items matching these built-in groups, custom groups, or exact prefab/internal");
			stringBuilder.AppendLine("# names stay in the player inventory instead of moving to the tombstone.");
			stringBuilder.AppendLine("KeepOnDeath:");
			foreach (string item in DefaultKeepOnDeath)
			{
				stringBuilder.AppendLine("  - " + item);
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("# Items matching these top-level groups, subgroups, custom groups, or exact");
			stringBuilder.AppendLine("# prefab/internal names can be placed in quick slots.");
			stringBuilder.AppendLine("QuickSlots:");
			foreach (string defaultQuickSlot in DefaultQuickSlots)
			{
				stringBuilder.AppendLine("  - " + defaultQuickSlot);
			}
			stringBuilder.AppendLine("#");
			return stringBuilder.ToString();
		}

		private static string NormalizeId(string? id)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				return "";
			}
			return new string(id.Trim().Where(char.IsLetterOrDigit).ToArray()).ToLowerInvariant();
		}
	}
	[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 static bool ShouldRefreshNativeTooltip(string? previousSignature, string? nextSignature, bool previousVisible, bool previousHadSocketRows)
		{
			if (!previousVisible || !previousHadSocketRows)
			{
				return true;
			}
			return !string.Equals(previousSignature ?? "", nextSignature ?? "", StringComparison.Ordinal);
		}

		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 YamlRoot
	{
		[YamlMember(Alias = "Groups", ApplyNamingConventions = false)]
		public Dictionary<string, List<string>> Groups { get; set; } = new Dictionary<string, List<string>>();


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


		public List<YamlResourceTier> ResourceMap { get; set; } = new List<YamlResourceTier>();


		[YamlMember(Alias = "Slots", ApplyNamingConventions = false)]
		public List<YamlSlot> Slots { get; set; } = new List<YamlSlot>();

	}
	internal sealed class YamlResourceTier
	{
		public string Id { get; set; } = "";


		public string Name { get; set; } = "";


		public string Biome { get; set; } = "";


		public string Biomes { get; set; } = "";


		public List<string> Materials { get; set; } = new List<string>();

	}
	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 YamlPredefinedGroup
	{
		public string Id { get; set; } = "";


		public string Name { get; set; } = "";


		public string Icon { get; set; } = "";


		public YamlGroupMatch Match { get; set; } = new YamlGroupMatch();

	}
	internal sealed class YamlGroupMatch
	{
		public List<string> Groups { get; set; } = new List<string>();


		public List<string> ItemTypes { get; set; } = new List<string>();


		public List<string> SkillTypes { get; set; } = new List<string>();


		public List<string> Prefabs { get; set; } = new List<string>();


		public List<string> PrefabAny { get; set; } = new List<string>();


		public List<string> NameAny { get; set; } = new List<string>();


		public List<string> AmmoTypes { get; set; } = new List<string>();


		public int? MaxStackGreaterThan { get; set; }

		public int? ValueGreaterThan { get; set; }

		public bool? HasFood { get; set; }

		public bool? HasStatusEffect { get; set; }
	}
	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);
		}
	}
	[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 enum SlotKind
	{
		BuiltIn,
		CustomEquipment,
		Quick
	}
	internal enum PendingSlotUnequipDestination
	{
		PlayerInventory,
		Container,
		DropOutside
	}
	internal enum InventoryCellKind
	{
		Outside,
		RegularUnlocked,
		RegularLocked,
		Hotbar,
		ExternalReserved,
		Equipment,
		CustomEquipment,
		Quick,
		QuickLocked
	}
	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 ItemData Item { get; }

		public SlotDefinition Slot { get; }

		public Vector2i SourcePos { get; }

		public float CreatedAt { get; }

		public PendingSlotEquip(ItemData item, SlotDefinition slot, Vector2i sourcePos, float createdAt)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Item = item;
			Slot = slot;
			SourcePos = sourcePos;
			CreatedAt = createdAt;
		}
	}
	internal sealed class PendingSlotUnequip
	{
		public ItemData Item { get; }

		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(ItemData item, SlotDefinition sourceSlot, PendingSlotUnequipDestination destination, Inventory? targetInventory, Vector2i targetPos, int amount, float createdAt)
		{
			//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)
			Item = item;
			SourceSlot = sourceSlot;
			Destination = destination;
			TargetInventory = targetInventory;
			TargetPos = targetPos;
			Amount = amount;
			CreatedAt = createdAt;
		}
	}
	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 sealed class InventoryPanelDragMarker : MonoBehaviour
	{
		public string PanelName { get; set; } = "";


		public bool Initialized { get; set; }
	}
	internal sealed class PlayerInventoryRowsHandleMarker : MonoBehaviour
	{
		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 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; }
	}
	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 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 JewelcraftingSourceRowUiCache : MonoBehaviour
	{
		public string ChildSignature { get; set; } = "";


		public TMP_Text? Text { get; set; }

		public Image? BorderImage { get; set; }

		public Image? GemImage { get; set; }
	}
	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 GameObject? 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).gameObject : 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 string LastTextSignature { get; set; } = "";


		public string LastColorSignature { 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 string Signature { 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 CraftingRecipeViewEntry(int originalIndex, RecipeDataPair pair, bool isFavorite, SortKey sortKey)
		{
			//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;
		}
	}
	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 Func<InventoryGui, Color>? _colorGetter;

		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, Func<InventoryGui, Color>? colorGetter = null)
		{
			Id = id;
			Category = category;
			Tooltip = tooltip;
			_matches = matches;
			_iconPrefab = iconPrefab;
			_skillIcon = skillIcon;
			_iconGetter = iconGetter;
			_colorGetter = colorGetter;
		}

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

		public Color GetColor(InventoryGui gui)
		{
			//IL_0011: 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)
			return _colorGetter?.Invoke(gui) ?? Color.white;
		}
	}
	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 sealed class CraftingRecipeScrollbarMarker : MonoBehaviour
	{
		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 bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All(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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return "";
			}
			if (!((KeyboardShortcut)(ref shortcut)).Modifiers.Any())
			{
				return GetKeyDisplayText(((KeyboardShortcut)(ref shortcut)).MainKey);
			}
			return string.Join("+", ((KeyboardShortcut)(ref shortcut)).Modifiers.Select(GetKeyDisplayText).Concat(new string[1] { GetKeyDisplayText(((KeyboardShortcut)(ref shortcut)).MainKey) }));
		}

		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 static string GetKeyDisplayText(KeyCode key)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//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_0059: Expected I4, but got Unknown
			//IL_0059: 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_0081: Expected I4, but got Unknown
			string text = ((object)(KeyCode)(ref key)).ToString();
			if (text.StartsWith("Alpha", StringComparison.Ordinal))
			{
				return text.Substring("Alpha".Length);
			}
			if ((int)key != 96)
			{
				switch (key - 303)
				{
				default:
					return (key - 323) switch
					{
						0 => "Mouse-1", 
						1 => "Mouse-2", 
						2 => "Mouse-3", 
						3 => "Mouse-4", 
						4 => "Mouse-5", 
						5 => "Mouse-6", 
						6 => "Mouse-7", 
						_ => text, 
					};
				case 4:
				case 5:
					return "Alt";
				case 2:
				case 3:
					return "Ctrl";
				case 0:
				case 1:
					return "Shift";
				}
			}
			return "`";
		}
	}
	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 static class InventorySlotsConfigCore
	{
		public static YamlRoot ParseYaml(string yaml)
		{
			if (string.IsNullOrWhiteSpace(yaml))
			{
				return new YamlRoot();
			}
			return new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build().Deserialize<YamlRoot>(yaml) ?? new YamlRoot();
		}

		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> BuildResourceTierMap(YamlRoot config)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			List<YamlResourceTier> list = config.ResourceMap ?? new List<YamlResourceTier>();
			for (int i = 0; i < list.Count; i++)
			{
				YamlResourceTier yamlResourceTier = list[i];
				if (yamlResourceTier == null)
				{
					continue;
				}
				foreach (string item in yamlResourceTier.Materials ?? new List<string>())
				{
					string text = NormalizeResourceToken(item);
					if (!string.IsNullOrWhiteSpace(text) && !dictionary.ContainsKey(text))
					{
						dictionary[text] = i;
					}
				}
			}
			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 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 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;
		}
	}
	internal sealed class MyLittleUICraftingObjectMarker : MonoBehaviour
	{
	}
	[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(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(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), "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(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
	{
		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, Vector2i pos, Modifier mod)
		{
			//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_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)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			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), "OnDropOutside")]
	internal static class InventoryGuiDropSlotItemOutsidePatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			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(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 void Postfix(Inventory __instance, ItemData item, int stack, ref bool __result)
		{
			InventorySlotsPlugin.OnInventoryCanAddItem(__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 = 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, ref int x, ref int y)
		{
			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)
		{
			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)
		{
			return InventorySlotsPlugin.TryValidatePlayerInventoryMoveItemToThis(__instance, ref __result, item, ref x, ref y);
		}

		private static void Postfix(Inventory __instance, bool __result, ItemData item, int x, int y)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			InventorySlotsPlugin.OnPlayerInventoryItemPlaced(__instance, item, new Vector2i(x, y), __result);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "DropItem")]
	internal static class InventoryGridDropItemPatch
	{
		private static bool Prefix(InventoryGrid __instance, Inventory fromInventory, ItemData item, Vector2i pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return InventorySlotsPlugin.ShouldAllowInventoryGridDropItem(__instance, item, pos);
		}
	}
	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;
		}
	}
	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();
		}
	}
	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);
		}
	}
	[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(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 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);
		}
	}
	[HarmonyPatch]
	internal static class RecycleNReclaimNativePanelUpdatedInventorySlotsPatch
	{
		private static MethodBase? TargetMethod()
		{
			return AccessTools.Method("Recycle_N_Reclaim.GamePatches.UI.StationRecyclingTabHolder:UpdateCraftingPanel", (Type[])null, (Type[])null);
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static void Postfix()
		{
			InventorySlotsPlugin.OnRecycleNReclaimNativePanelUpdated();
		}
	}
	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 readonly struct SortKeyComponents
	{
		public int ResourceTier { get; }

		public int GroupRank { get; }

		public int BigGroupRank { get; }

		public string SetKey { get; }

		public int EquipmentSlotOrder { get; }

		public string LocalizedName { get; }

		public SortKeyComponents(int resourceTier, int groupRank, int bigGroupRank, string setKey, int equipmentSlotOrder, string localizedName)
		{
			ResourceTier = resourceTier;
			GroupRank = groupRank;
			BigGroupRank = bigGroupRank;
			SetKey = setKey;
			EquipmentSlotOrder = equipmentSlotOrder;
			LocalizedName = localizedName;
		}

		public SortKey ToSortKey()
		{
			return new SortKey(ResourceTier, GroupRank, BigGroupRank, SetKey, EquipmentSlotOrder, LocalizedName);
		}
	}
	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 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) ? 1 : 0);
			}
			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;
		}
	}
	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 sealed class RectTransformLayoutMarker : MonoBehaviour
	{
		public string Signature { get; set; } = "";

	}
	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;
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		private static void Prefix(ZNetPeer peer)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			peer.m_rpc.Register<ZPackage>("InventorySlots_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_InventorySlots_Version);
			ZPackage val = new ZPackage();
			val.Write("1.0.4");
			peer.m_rpc.Invoke("InventorySlots_VersionCheck", new object[1] { val });
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			InventorySlotsPlugin.Log.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent InventorySlots version, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ZNet __instance)
		{
			if (__instance.IsServer())
			{
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public static class ShowConnectionError
	{
		private static bool Prepare()
		{
			return !InventorySlotsPlugin.IsDedicatedServer;
		}

		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf && !string.IsNullOrWhiteSpace(InventorySlotsPlugin.ConnectionError))
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + InventorySlotsPlugin.ConnectionError;
			}
		}
	}
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_InventorySlots_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			if (text != "1.0.4")
			{
				InventorySlotsPlugin.ConnectionError = "InventorySlots Installed: 1.0.4\nNeeded: " + text;
				if (ZNet.instance.IsServer())
				{
					InventorySlotsPlugin.Log.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible InventorySlots version, disconnecting"));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (ZNet.instance.IsServer())
			{
				ValidatedPeers.Add(rpc);
			}
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

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

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

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

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	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)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[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(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).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.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_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 & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

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

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != 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)
		{
			ZNetPeer peer2 = peer;
			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 (peer2.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)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						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)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.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());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).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)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

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

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

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

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

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

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_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]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

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

		public override object? GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class Polyfills
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Contains(this string source, char c)
		{
			return source.IndexOf(c) != -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly Func<PropertyInfo, bool> IsInstance = (PropertyInfo property) => !(property.GetMethod ?? property.SetMethod).IsStatic;

		private static readonly Func<PropertyInfo, bool> IsInstancePublic = (PropertyInfo property) => IsInstance(property) && (property.GetMethod ?? property.SetMethod).IsPublic;

		public static Type? BaseType(this Type type)
		{
			return type.GetTypeInfo().BaseType;
		}

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

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

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

		public static Type? GetImplementationOfOpenGenericInterface(this Type type, Type openGenericType)
		{
			if (!openGenericType.IsGenericType || !openGenericType.IsInterface)
			{
				throw new ArgumentException("The type must be a generic type definition and an interface", "openGenericType");
			}
			if (IsGenericDefinitionOfType(type, openGenericType))
			{
				return type;
			}
			return type.FindInterfaces((Type t, object context) => IsGenericDefinitionOfType(t, context), openGenericType).FirstOrDefault();
			static bool IsGenericDefinitionOfType(Type t, object? context)
			{
				if (t.IsGenericType)
				{
					return t.GetGenericTypeDefinition() == (Type)context;
				}
				return false;
			}
		}

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

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

		public static bool IsRequired(this MemberInfo member)
		{
			return member.GetCustomAttributes(inherit: true).Any((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.RequiredMemberAttribute");
		}

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

		public static bool IsAssignableFrom(this Type type, Type source)
		{
			return type.IsAssignableFrom(source.GetTypeInfo());
		}

		public static bool IsAssignableFrom(this Type type, TypeInfo source)
		{
			return type.GetTypeInfo().IsAssignableFrom(source);
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			if (type.IsEnum())
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (type == typeof(bool))
			{
				return TypeCode.Boolean;
			}
			if (type == typeof(char))
			{
				return TypeCode.Char;
			}
			if (type == typeof(sbyte))
			{
				return TypeCode.SByte;
			}
			if (type == typeof(byte))
			{
				return TypeCode.Byte;
			}
			if (type == typeof(short))
			{
				return TypeCode.Int16;
			}
			if (type == typeof(ushort))
			{
				return TypeCode.UInt16;
			}
			if (type == typeof(int))
			{
				return TypeCode.Int32;
			}
			if (type == typeof(uint))
			{
				return TypeCode.UInt32;
			}
			if (type == typeof(long))
			{
				return TypeCode.Int64;
			}
			if (type == typeof(ulong))
			{
				return TypeCode.UInt64;
			}
			if (type == typeof(float))
			{
				return TypeCode.Single;
			}
			if (type == typeof(double))
			{
				return TypeCode.Double;
			}
			if (type == typeof(decimal))
			{
				return TypeCode.Decimal;
			}
			if (type == typeof(DateTime))
			{
				return TypeCode.DateTime;
			}
			if (type == typeof(string))
			{
				return TypeCode.String;
			}
			return TypeCode.Object;
		}

		public static bool IsDbNull(this object value)
		{
			return value?.GetType()?.FullName == "System.DBNull";
		}

		public static Type[] GetGenericArguments(this Type type)
		{
			return type.GetTypeInfo().GenericTypeArguments;
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			string name2 = name;
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name2);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetRuntimeField(name);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			Func<PropertyInfo, bool> predicate = (includeNonPublic ? IsInstance : IsInstancePublic);
			if (!type.IsInterface())
			{
				return type.GetRuntimeProperties().Where(predicate);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetRuntimeProperties().Where(predicate));
		}

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

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return from f in type.GetRuntimeFields()
				where !f.IsStatic && f.IsPublic
				select f;
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return from m in type.GetRuntimeMethods()
				where m.IsPublic && m.IsStatic
				select m;
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name2)) ?? throw new MissingMethodException("Expected to find a method named '" + name2 + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			string name2 = name;
			Type[] parameterTypes2 = parameterTypes;
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name2))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes2.Length)
					{
						return parameters.Zip(parameterTypes2, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name2));
		}

		public static MethodInfo? GetGetMethod(this PropertyInfo property, bool nonPublic)
		{
			MethodInfo methodInfo = property.GetMethod;
			if (!nonPublic && !methodInfo.IsPublic)
			{
				methodInfo = null;
			}
			return methodInfo;
		}

		public static MethodInfo? GetSetMethod(this PropertyInfo property)
		{
			return property.SetMethod;
		}

		public static IEnumerable<Type> GetInterfaces(this Type type)
		{
			return type.GetTypeInfo().ImplementedInterfaces;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			if (!(o.GetType() == type))
			{
				return o.GetType().GetTypeInfo().IsSubclassOf(type);
			}
			return true;
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo member)
		{
			return Attribute.GetCustomAttributes(member, typeof(TAttribute), inherit: true);
		}

		public static bool AcceptsNull(this MemberInfo member)
		{
			object[] customAttributes = member.DeclaringType.GetCustomAttributes(inherit: true);
			object obj = customAttributes.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
			int num = 0;
			if (obj != null)
			{
				Type type = obj.GetType();
				PropertyInfo property = type.GetProperty("Flag");
				num = (byte)property.GetValue(obj);
			}
			object[] customAttributes2 = member.GetCustomAttributes(inherit: true);
			object obj2 = customAttributes2.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
			PropertyInfo propertyInfo = (obj2?.GetType())?.GetProperty("NullableFlags");
			byte[] source = (byte[])propertyInfo.GetValue(obj2);
			return source.Any((byte x) => x == 2) || num == 2;
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	internal abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

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

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

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

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

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

		public TBuilder WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			return Self;
		}

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

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

		public TBuilder WithAttributeOverride<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

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

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

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

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

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

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

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

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	internal sealed class Deserializer : IDeserializer
	{
		private readonly IValueDeserializer valueDeserializer;

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

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

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

		public T Deserialize<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize<object>(parser);
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public object? Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
	{
		private Lazy<IObjectFactory> objectFactory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		protected override DeserializerBuilder Self => this;

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

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

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

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

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

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

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

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

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

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

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

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

		public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public DeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

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

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

		public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (!DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			return this;
		}

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

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

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

		public IDeserializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;

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

		public IEventEmitter EventEmitter { get; private set; }

		public ObjectSerializer NestedObjectSerializer { get; private set; }

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

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

		public T GetPreProcessingPhaseObjectGraphVisitor<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

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

		public bool NeedsExpansion { get; set; }

		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

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

		public MappingStyle Style { get; set; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	internal interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(IParser parser, Type type);
	}
	internal interface IEventEmitter
	{
		void Emit(AliasEventInfo eventInfo, IEmitter emitter);

		void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
	}
	internal interface INamingConvention
	{
		string Apply(string value);

		string Reverse(string value);
	}
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer);
	}
	internal interface INodeTypeResolver
	{
		bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
	}
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		object? Read(string name, object target);
	}
	internal interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		public static object NonNullValue(this IObjectDescriptor objectDescriptor)
		{
			return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
		}
	}
	internal interface IObjectFactory
	{
		object Create(Type type);

		object? CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer);
	}
	internal interface IObjectGraphVisitor<TContext>
	{
		bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

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

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

		void VisitScalar(IObjectDescriptor scalar, TContext context, ObjectSerializer serializer);

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

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context, ObjectSerializer serializer);

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

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context, ObjectSerializer serializer);
	}
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

		T? GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	internal interface ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

		void Serialize(TextWriter writer, object? graph, Type type);

		void Serialize(IEmitter emitter, object? graph);

		void Serialize(IEmitter emitter, object? graph, Type type);
	}
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching);

		string GetEnumName(Type enumType, string name);

		string GetEnumValue(object enumValue);
	}
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	internal interface IValueDeserializer
	{
		object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	internal interface IValueSerializer
	{
		void SerializeValue(IEmitter emitter, object? value, Type? type);
	}
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	internal delegate object? ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer);

		void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

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

		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

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

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

		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

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

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

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

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

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

		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
				registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

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

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

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

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

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

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

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

		public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
		{
			return entries.Select((LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

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

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

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

		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			Func<TComponent, TArgument> argumentBuilder2 = argumentBuilder;
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder2(inner)));
		}

		public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			TArgument argument2 = argument;
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument2)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public Type? ConverterType => baseDescriptor.ConverterType;

		public int Order { get; set; }

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

		public bool CanWrite => baseDescriptor.CanWrite;

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

		public void Write(object target, object? value)
		{
			baseDescriptor.Write(target, value);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	internal sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

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

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

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

		public string Serialize(object? graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public string Serialize(object? graph, Type type)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph, type);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, object? graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, object? graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, object? graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, object? graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		private void EmitDocument(IEmitter emitter, object? graph, Type? type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

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

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

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

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

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

		private readonly IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private ScalarStyle defaultScalarStyle;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override SerializerBuilder Self => this;

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

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

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

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

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

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

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

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

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

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

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

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

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

		public ISerializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

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

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

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

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

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

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

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

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

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

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

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

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

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

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

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

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

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		protected override StaticDeserializerBuilder Self => this;

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

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

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

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

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

		public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public StaticDeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

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

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

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

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

		public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

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

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

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			typeMappings[typeFromHandle] = typeFromHandle2;
			return this;
		}

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

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

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

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

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

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

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

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

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

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

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private ScalarStyle defaultScalarStyle;

		protected override StaticSerializerBuilder Self => this;

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

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

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

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

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

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

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

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

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

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, ScalarStyle.Plain, YamlFormatter.Default, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

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

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

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

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

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

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

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

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

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal sealed class StreamFragment : IYamlConvertible
	{
		private readonly List<ParsingEvent> events = new List<ParsingEvent>();

		public IList<ParsingEvent> Events => events;

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

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			foreach (ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	internal sealed class TagMappings
	{
		private readonly Dictionary<string, Type> mappings;

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

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

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

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

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

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

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

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

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

		[return: MaybeNull]
		public T GetAttribute<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

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

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

		public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	internal sealed class YamlAttributeOverridesInspector : ReflectionTypeInspector
	{
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public Type? ConverterType => GetCustomAttribute<YamlConverterAttribute>()?.ConverterType ?? baseDescriptor.ConverterType;

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

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

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

			public void Write(object target, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				T attribute = overrides.GetAttribute<T>(classType, Name);
				return attribute ?? baseDescriptor.GetCustomAttribute<T>();
			}

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

		private readonly ITypeInspector innerTypeDescriptor;

		private readonly YamlAttributeOverrides overrides;

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type2, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type2)));
			}
			return enumerable;
		}
	}
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

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

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(IPropertyDescriptor p)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
					YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
						}
						propertyDescriptor.Order = customAttribute.Order;
						propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							propertyDescriptor.Name = customAttribute.Alias;
						}
					}
					return propertyDescriptor;
				})
				orderby p.Order
				select p;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	internal sealed class YamlConverterAttribute : Attribute
	{
		public Type ConverterType { get; }

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	internal class YamlFormatter
	{
		public static YamlFormatter Default { get; } = new YamlFormatter();


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


		public virtual Func<object, ITypeInspector, INamingConvention, string> FormatEnum { get; set; } = delegate(object value, ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			string empty = string.Empty;
			empty = ((value != null) ? typeInspector.GetEnumValue(value) : string.Empty);
			return enumNamingConvention.Apply(empty);
		};


		public virtual Func<object, bool> PotentiallyQuoteEnums { get; set; } = (object _) => true;


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

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

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

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

		public string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlMemberAttribute : Attribute
	{
		private DefaultValuesHandling? defaultValuesHandling;

		public string? Description { get; set; }

		public Type? SerializeAs { get; set; }

		public int Order { get; set; }

		public string? Alias { get; set; }

		public bool ApplyNamingConventions { get; set; }

		public ScalarStyle ScalarStyle { get; set; }

		public DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public YamlMemberAttribute()
		{
			ScalarStyle = ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						Mark start = alias.Start;
						Mark end = alias.End;
						throw new AnchorNotFoundException(in start, in end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		private sealed class ValuePromise : IValuePromise
		{
			private object? value;

			public readonly YamlDotNet.Core.Events.AnchorAlias? Alias;

			public bool HasValue { get; private set; }

			public object? Value
			{
				get
				{
					if (!HasValue)
					{
						throw new InvalidOperationException("Value not set");
					}
					return value;
				}
				set
				{
					if (HasValue)
					{
						throw new InvalidOperationException("Value already set");
					}
					HasValue = true;
					this.value = value;
					this.ValueAvailable?.Invoke(value);
				}
			}

			public event Action<object?>? ValueAvailable;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object? value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		private readonly IValueDeserializer innerDeserializer;

		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise value))
				{
					Mark start = @event.Start;
					Mark end = @event.End;
					throw new AnchorNotFoundException(in start, in end, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(anchorName))
				{
					aliasState2[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(anchorName, out ValuePromise value2))
				{
					aliasState3.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.typeInspector = typeInspector;
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			IParser parser2 = parser;
			SerializerState state2 = state;
			IValueDeserializer nestedObjectDeserializer2 = nestedObjectDeserializer;
			parser2.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser2, x, state2, nestedObjectDeserializer2);
			Mark start;
			Mark end;
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser2, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer2.DeserializeValue(r, t, state2, nestedObjectDeserializer2), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				start = @event?.Start ?? Mark.Empty;
				end = @event?.End ?? Mark.Empty;
				throw new YamlException(in start, in end, "Exception during deserialization", innerException);
			}
			start = @event?.Start ?? Mark.Empty;
			end = @event?.End ?? Mark.Empty;
			throw new YamlException(in start, in end, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
		{
			foreach (INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	internal interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly Dictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out object value))
				{
					return value;
				}
				throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
			}
		}

		public void Add(string anchor, object @object)
		{
			objectsByAnchor.Add(anchor, @object);
			if (@object != null)
			{
				anchorsByObject.Add(@object, anchor);
			}
		}

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			string separator2 = separator;
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator2 + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class TypeConverter
	{
		public static T ChangeType<T>(object? value, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture, enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			if (value == null || value.IsDbNull())
			{
				if (!destinationType.IsValueType())
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (destinationType.IsGenericType())
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (destinationType.IsEnum())
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods())
				{
					if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
					{
						continue;
					}
					ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
					{
						try
						{
							return publicStaticMethod2.Invoke(null, new object[1] { value });
						}
						catch (TargetInvocationException ex)
						{
							throw ex.InnerException;
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ex2.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [NotNullWhen(true)] out IYamlTypeConverter? typeConverter)
		{
			(bool, IYamlTypeConverter) orAdd = DictionaryExtensions.GetOrAdd(cache, type, (Type t, IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public IYamlTypeConverter GetConverterByType(Type converter)
		{
			IYamlTypeConverter[] array = typeConverters;
			foreach (IYamlTypeConverter yamlTypeConverter in array)
			{
				if (yamlTypeConverter.GetType() == converter)
				{
					return yamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, IYamlTypeConverter[] typeConverters)
		{
			foreach (IYamlTypeConverter yamlTypeConverter in typeConverters)
			{
				if (yamlTypeConverter.Accepts(type))
				{
					return (true, yamlTypeConverter);
				}
			}
			return (false, null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class StaticTypeResolver : ITypeResolver
	{
		public virtual Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (actualValue.GetType().GetTypeCode())
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	internal class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return 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)
		{
			Type type2 = type;
			object container2 = container;
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type2, container2));
		}
	}
	internal class NamingConventionTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly INamingConvention namingConvention;

		public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	internal class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal class ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(T), inherit: true);
				return (T)customAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		public ReadableFieldsTypeInspector(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal class ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanRead)
			{
				return property.GetGetMethod(nonPublic: true).GetParameters().Length == 0;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class ReflectionTypeInspector : TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching)
		{
			string name2 = name;
			IEnumerable<IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name2
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name2, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name2 + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name2 + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	internal class WritablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanWrite)
			{
				return property.GetSetMethod(nonPublic: true).GetParameters().Length == 1;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class FailsafeSchema
	{
		public static class Tags
		{
			public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

			public static readonly TagName Seq = new TagName("tag:yaml.org,2002:seq");

			public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class JsonSchema
	{
		public static class Tags
		{
			public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

			public static readonly TagName Bool = new TagName("tag:yaml.org,2002:bool");

			public static readonly TagName Int = new TagName("tag:yaml.org,2002:int");

			public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly Dictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value, ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer)
		{
		}

		private void VisitObject(IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		AnchorName IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	internal sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEventEmitter eventEmitter;

		private readonly IAliasProvider aliasProvider;

		private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

		public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (value.Value != null)
			{
				AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					AliasEventInfo aliasEventInfo = new AliasEventInfo(value, alias);
					eventEmitter.Emit(aliasEventInfo, context);
					return aliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (value.Value is IYamlConvertible yamlConvertible)
			{
				yamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is IYamlSerializable yamlSerializable)
			{
				yamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}
	}
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		private static object? GetDefault(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}
	}
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		private readonly IObjectFactory factory;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValuesHandling defaultValuesHandling = handling;
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitNull) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != 0 && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != 0)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>()));
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context, ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer);

		protected abstract void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		protected readonly struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly IObjectDescriptor Value;

			public ObjectPathSegment(object name, IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly ITypeInspector typeDescriptor;

		private readonly ITypeResolver typeResolver;

		private readonly INamingConvention namingConvention;

		private readonly IObjectFactory objectFactory;

		public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, IObjectFactory objectFactory)
		{
			if (maxRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
			}
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.maxRecursion = maxRecursion;
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		void IObjectGraphTraversalStrategy.Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(IPropertyDescriptor? propertyDescriptor, object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(propertyDescriptor, value, context, serializer))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = value.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
				case TypeCode.Char:
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
				case TypeCode.DateTime:
				case TypeCode.String:
					visitor.VisitScalar(value, context, serializer);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (value.IsDbNull())
				{
					visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(IPropertyDescriptor propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache converters;

		private readonly Settings settings;

		public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, Settings settings, IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	internal class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			}
		};

		private readonly Dictionary<Type, Type> defaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> defaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				defaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (type.IsInterface())
			{
				Type value2;
				if (type.IsGenericType())
				{
					if (defaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out Type value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (defaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			Type attributeType2 = attributeType;
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType2];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType2, inherit: true).Length != 0).ToArray();
			});
		}
	}
	internal sealed class LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	internal abstract class StaticObjectFactory : IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	internal class MappingNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> mappings;

		public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Mark start = nodeEvent.Start;
				Mark end = nodeEvent.End;
				throw new YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	internal sealed class TagNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<TagName, Type> tagMappings;

		public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public ArrayNodeDeserializer(INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	internal abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			IList result2 = result;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public CollectionNodeDeserializer(IObjectFactory objectFactory, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != null;
					list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, INamingConvention enumNamingConvention, ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			Action<int, object?> promiseResolvedHandler2 = promiseResolvedHandler;
			IList result2 = result;
			Type tItem2 = tItem;
			INamingConvention enumNamingConvention2 = enumNamingConvention;
			ITypeInspector typeInspector2 = typeInspector;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem2);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(tItem2.IsValueType() ? Activator.CreateInstance(tItem2) : null);
					if (promiseResolvedHandler2 != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler2(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result2[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem2, enumNamingConvention2, typeInspector2);
						};
					}
				}
				else
				{
					result2.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem2, enumNamingConvention2, typeInspector2));
				}
			}
		}
	}
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			IDictionary result2 = result;
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += delegate(object? v)
						{
							result2[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result2, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result2[key] = v;
				};
			}
		}
	}
	internal class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary, rootDeserializer);
			return true;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class FsharpListNodeDeserializer : INodeDeserializer
	{
		private readonly ITypeInspector typeInspector;

		private readonly INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static bool NodeIsNull(NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.Scalar scalar && scalar.Style == ScalarStyle.Plain && !scalar.IsKey)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Mark start = Mark.Empty;
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
					goto IL_0267;
				}
				catch (SerializationException ex)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Exception during deserialization", innerException);
				}
				IL_0267:
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, IPropertyDescriptor property, YamlDotNet.Core.Events.Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	internal sealed class ScalarNodeDeserializer : INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		private readonly ITypeInspector typeInspector;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, ITypeInspector typeInspector, YamlFormatter formatter, INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				value = DeserializeBooleanHelper(@event.Value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				value = DeserializeIntegerHelper(typeCode, @event.Value);
				break;
			case TypeCode.Single:
				value = float.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""), CultureInfo.InvariantCulture);
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		private object? AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.Scalar value)
		{
			if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal sealed class StaticCollectionNodeDeserializer : INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			IList result2 = result;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					int index = result2.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (objectFactory.IsDictionary(expectedType))
			{
				if (!(objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = objectFactory.GetKeyType(expectedType);
				Type valueType = objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Func<IParser, Type, object?> nestedObjectDeserializer2 = nestedObjectDeserializer;
			IParser parser2 = parser;
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser2, expectedType, (Type type) => nestedObjectDeserializer2(parser2, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToPascalCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	internal abstract class ChainedEventEmitter : IEventEmitter
	{
		protected readonly IEventEmitter nextEmitter;

		protected ChainedEventEmitter(IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum())
					{
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? ScalarStyle.Plain : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		private readonly Regex? isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN|\\s.*)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		private readonly ScalarStyle defaultScalarStyle;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			ScalarStyle style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	internal sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	internal class DateTime8601Converter : IYamlTypeConverter
	{
		private readonly ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, doubleQuotes ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}

		private static DateTime EnsureDateTimeKind(DateTime dt, DateTimeKind kind)
		{
			if (dt.Kind == DateTimeKind.Local && kind == DateTimeKind.Utc)
			{
				return dt.ToUniversalTime();
			}
			if (dt.Kind == DateTimeKind.Utc && kind == DateTimeKind.Local)
			{
				return dt.ToLocalTime();
			}
			return dt;
		}
	}
	internal class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(IFormatProvider? provider = null, ScalarStyle style = ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTimeOffset);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class GuidConverter : IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		private readonly LinkedList<ParsingEvent> buffer;

		private LinkedListNode<ParsingEvent>? current;

		public ParsingEvent? Current => current?.Value;

		public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<MappingStart>());
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
				buffer.AddLast(parsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	internal class TypeDiscriminatingNodeDeserializer : INodeDeserializer
	{
		private readonly IList<INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type expectedType2 = expectedType;
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType2));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType3 = expectedType2;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType3 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType3, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, out Type? suggestedType);
	}
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => targetKey == scalar.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar2 && typeMapping.TryGetValue(scalar2.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.Scalar key, out ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class DocumentLoadingState
	{
		private readonly Dictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly List<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();

		public void AddAnchor(YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			anchors[node.Anchor] = node;
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	internal class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private static void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class YamlDocument
	{
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			AnchorAssigningVisitor anchorAssigningVisitor = new AnchorAssigningVisitor();
			anchorAssigningVisitor.AssignAnchors(this);
		}

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly OrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();

		public IOrderedDictionary<YamlNode, YamlNode> Children => children;

		public MappingStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Mapping;

		internal YamlMappingNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			MappingStart mappingStart = parser.Consume<MappingStart>();
			Load(mappingStart, state);
			Style = mappingStart.Style;
			bool flag = false;
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
				if (!children.TryAdd(yamlNode, yamlNode2))
				{
					Mark start = yamlNode.Start;
					Mark end = yamlNode.End;
					throw new YamlException(in start, in end, $"Duplicate key {yamlNode}");
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = (child.Value.Anchor.IsEmpty ? YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value) : YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			return num;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				foreach (YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<YamlNode, YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}

		public static YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			YamlMappingNode yamlMappingNode = new YamlMappingNode();
			foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						yamlNode = text ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	internal abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;


		public Mark End { get; private set; } = Mark.Empty;


		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out YamlNode node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			string text = scalar.Value;
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		public YamlScalarNode(string? value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (forceImplicitPlain && Style == ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == ScalarStyle.Plain || Style == ScalarStyle.Any))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
			{
				return object.Equals(Value, yamlScalarNode.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		public static explicit operator string?(YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly List<YamlNode> children = new List<YamlNode>();

		public IList<YamlNode> Children => children;

		public SequenceStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Sequence;

		internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			SequenceStart sequenceStart = parser.Consume<SequenceStart>();
			Load(sequenceStart, state);
			Style = sequenceStart.Style;
			bool flag = false;
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				children.Add(yamlNode);
				flag = flag || yamlNode is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlSequenceNode()
		{
		}

		public YamlSequenceNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlSequenceNode(IEnumerable<YamlNode> children)
		{
			foreach (YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new YamlScalarNode(child));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new SequenceEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], yamlSequenceNode.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (YamlNode child in children)
			{
				h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
			}
			return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (YamlNode child in children)
			{
				foreach (YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly List<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class YamlVisitor : IYamlVisitor
	{
		protected virtual void Visit(YamlStream stream)
		{
		}

		protected virtual void Visited(YamlStream stream)
		{
		}

		protected virtual void Visit(YamlDocument document)
		{
		}

		protected virtual void Visited(YamlDocument document)
		{
		}

		protected virtual void Visit(YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void IYamlVisitor.Visit(YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void IYamlVisitor.Visit(YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void IYamlVisitor.Visit(YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void IYamlVisitor.Visit(YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void IYamlVisitor.Visit(YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	internal abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	internal class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	internal static class ExpressionExtensions
	{
		public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
		{
			PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
			if (propertyInfo == null)
			{
				throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
			}
			return propertyInfo;
		}

		[return: MaybeNull]
		private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	internal static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object? value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

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

		public bool Contains(object? value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object? value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, object? value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.ContainsKey(item);
			}

			public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Key;
				}
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.ContainsValue(item);
			}

			public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Value;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

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

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				TKey key2 = key;
				if (dictionary.ContainsKey(key2))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
					dictionary[key2] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key2, value);
				}
				else
				{
					Add(key2, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			TKey key2 = key;
			if (dictionary.ContainsKey(key2))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
				list.RemoveAt(index);
				if (!dictionary.Remove(key2))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	internal readonly struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

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

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

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

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

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct CharacterAnalyzer<TBuffer> where TBuffer : ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = buffer;
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	internal static class Constants
	{
		public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
		{
			new TagDirective("!", "!"),
			new TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class Cursor
	{
		public long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1L;
		}

		public Cursor(Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public Mark Mark()
		{
			return new Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	internal class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] NewLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private EmitterState state;

		private readonly Stack<EmitterState> states = new Stack<EmitterState>();

		private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly bool useUtf16SurrogatePair;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public Emitter(TextWriter output)
			: this(output, EmitterSettings.Default)
		{
		}

		public Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public Emitter(TextWriter output, EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				ParsingEvent evt = events.Peek();
				try
				{
					AnalyzeEvent(evt);
					StateMachine(evt);
				}
				finally
				{
					events.Dequeue();
				}
			}
		}

		private bool NeedMoreEvents()
		{
			if (events.Count == 0)
			{
				return true;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.DocumentStart:
				num = 1;
				break;
			case EventType.SequenceStart:
				num = 2;
				break;
			case EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			foreach (ParsingEvent @event in events)
			{
				switch (@event.Type)
				{
				case EventType.DocumentStart:
				case EventType.SequenceStart:
				case EventType.MappingStart:
					num2++;
					break;
				case EventType.DocumentEnd:
				case EventType.SequenceEnd:
				case EventType.MappingEnd:
					num2--;
					break;
				}
				if (num2 == 0)
				{
					return false;
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				bool flag3 = true;
				bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
				bool flag5 = false;
				bool flag6 = false;
				bool flag7 = false;
				bool flag8 = false;
				bool flag9 = false;
				bool flag10 = false;
				bool flag11 = false;
				bool flag12 = false;
				bool flag13 = false;
				bool flag14 = false;
				bool flag15 = false;
				bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
				bool flag17 = false;
				bool flag18 = false;
				bool flag19 = true;
				while (!characterAnalyzer.EndOfInput)
				{
					if (flag19)
					{
						if (characterAnalyzer.Check("#,[]{}&*!|>\"%@`'"))
						{
							flag = true;
							flag2 = true;
							flag9 = characterAnalyzer.Check('\'');
							flag17 |= characterAnalyzer.Check('\'');
						}
						if (characterAnalyzer.Check("?:"))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('-') && flag4)
						{
							flag = true;
							flag2 = true;
						}
					}
					else
					{
						if (characterAnalyzer.Check(",?[]{}"))
						{
							flag = true;
						}
						if (characterAnalyzer.Check(':'))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('#') && flag3)
						{
							flag = true;
							flag2 = true;
						}
						flag17 |= characterAnalyzer.Check('\'');
					}
					if (!flag16 && !characterAnalyzer.IsPrintable())
					{
						flag16 = true;
					}
					if (characterAnalyzer.IsBreak())
					{
						flag15 = true;
					}
					if (characterAnalyzer.IsSpace())
					{
						if (flag19)
						{
							flag5 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag7 = true;
						}
						if (flag13)
						{
							flag10 = true;
							flag14 = true;
						}
						flag12 = true;
						flag13 = false;
					}
					else if (characterAnalyzer.IsBreak())
					{
						if (flag19)
						{
							flag6 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag8 = true;
						}
						if (flag12)
						{
							flag11 = true;
						}
						if (flag14)
						{
							flag18 = true;
						}
						flag12 = false;
						flag13 = true;
					}
					else
					{
						flag12 = false;
						flag13 = false;
						flag14 = false;
					}
					flag3 = characterAnalyzer.IsWhiteBreakOrZero();
					characterAnalyzer.Skip(1);
					if (!characterAnalyzer.EndOfInput)
					{
						flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
					}
					flag19 = false;
				}
				scalarData.IsFlowPlainAllowed = true;
				scalarData.IsBlockPlainAllowed = true;
				scalarData.IsSingleQuotedAllowed = true;
				scalarData.IsBlockAllowed = true;
				if (flag5 || flag6 || flag7 || flag8 || flag9)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag7)
				{
					scalarData.IsBlockAllowed = false;
				}
				if (flag10)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag11 || flag16)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag18)
				{
					scalarData.IsBlockAllowed = false;
				}
				scalarData.IsMultiline = flag15;
				if (flag15)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag)
				{
					scalarData.IsFlowPlainAllowed = false;
				}
				if (flag2)
				{
					scalarData.IsBlockPlainAllowed = false;
				}
				scalarData.HasSingleQuotes = flag17;
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string @string = output.Encoding.GetString(bytes, 0, bytes.Length);
				return @string.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (TagDirective tagDirective in tagDirectives)
			{
				if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
				{
					tagData.Handle = tagDirective.Handle;
					tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
					break;
				}
			}
		}

		private void StateMachine(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case EmitterState.StreamEnd:
				throw new YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.Comment comment)
		{
			if (flowLevel > 0 || state == EmitterState.FlowMappingFirstKey || state == EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(NewLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == EmitterState.BlockMappingFirstKey;
				if (flag)
				{
					IncreaseIndent(isFlow: false, isIndentless: false);
				}
				string[] array2 = array;
				foreach (string value in array2)
				{
					WriteIndent();
					Write("# ");
					Write(value);
					WriteBreak();
				}
				if (flag)
				{
					indent = indents.Pop();
				}
			}
			isIndentation = true;
		}

		private void EmitStreamStart(ParsingEvent evt)
		{
			if (!(evt is YamlDotNet.Core.Events.StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(ParsingEvent evt, bool isFirst)
		{
			if (evt is YamlDotNet.Core.Events.DocumentStart documentStart)
			{
				bool flag = documentStart.IsImplicit && isFirst && !isCanonical;
				TagDirectiveCollection tagDirectiveCollection = NonDefaultTagsAmong(documentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (documentStart.Version != null || tagDirectiveCollection.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (documentStart.Version != null)
				{
					AnalyzeVersionDirective(documentStart.Version);
					Version version = documentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (TagDirective item in tagDirectiveCollection)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
				foreach (TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					TagDirective[] defaultTagDirectives2 = Constants.DefaultTagDirectives;
					foreach (TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, allowDuplicates: true, tagDirectiveCollection);
					}
					foreach (TagDirective item2 in tagDirectiveCollection)
					{
						WriteIndicator("%TAG", needWhitespace: true, whitespace: false, indentation: false);
						WriteTagHandle(item2.Handle);
						WriteTagContent(item2.Prefix, needsWhitespace: true);
						WriteIndent();
					}
				}
				if (CheckEmptyDocument())
				{
					flag = false;
				}
				if (!flag)
				{
					WriteIndent();
					WriteIndicator("---", needWhitespace: true, whitespace: false, indentation: false);
					if (isCanonical)
					{
						WriteIndent();
					}
				}
				state = EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is YamlDotNet.Core.Events.StreamEnd))
				{
					throw new YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = EmitterState.StreamEnd;
			}
		}

		private static TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<TagDirective>? tagCollection)
		{
			TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
			if (tagCollection == null)
			{
				return tagDirectiveCollection;
			}
			foreach (TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			foreach (TagDirective item in defaultTagDirectives)
			{
				tagDirectiveCollection.Remove(item);
			}
			return tagDirectiveCollection;
		}

		private static void AnalyzeVersionDirective(VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(TagDirective value, bool allowDuplicates, TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(ParsingEvent evt)
		{
			states.Push(EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case EventType.Alias:
				EmitAlias();
				break;
			case EventType.Scalar:
				EmitScalar(evt);
				break;
			case EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(ParsingEvent evt)
		{
			YamlDotNet.Core.Events.Scalar scalar = (YamlDotNet.Core.Events.Scalar)evt;
			ScalarStyle scalarStyle = scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !scalar.IsPlainImplicit && !scalar.IsQuotedImplicit)
			{
				throw new YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (scalarStyle == ScalarStyle.Any)
			{
				scalarStyle = ((!scalarData.IsMultiline) ? ScalarStyle.Plain : ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					scalarStyle = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
				if (flag && !scalar.IsPlainImplicit)
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
			}
			if (scalarStyle == ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if ((scalarStyle == ScalarStyle.Literal || scalarStyle == ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.ForcePlain)
			{
				scalarStyle = ScalarStyle.Plain;
			}
			scalarData.Style = scalarStyle;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case ScalarStyle.Folded:
				WriteFoldedScalar(scalarData.Value);
				break;
			default:
				throw new InvalidOperationException();
			}
		}

		private void WritePlainScalar(string value, bool allowBreaks)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsSpace(c))
				{
					if (allowBreaks && !flag && column > bestWidth && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteSingleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("'", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == ' ')
				{
					if (allowBreaks && !flag && column > bestWidth && i != 0 && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				if (c == '\'')
				{
					Write(c);
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			WriteIndicator("'", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteDoubleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("\"", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsPrintable(c) && !IsBreak(c, out var _))
				{
					switch (c)
					{
					case '"':
					case '\\':
						break;
					case ' ':
						if (allowBreaks && !flag && column > bestWidth && i > 0 && i + 1 < value.Length)
						{
							WriteIndent();
							if (value[i + 1] == ' ')
							{
								Write('\\');
							}
						}
						else
						{
							Write(c);
						}
						flag = true;
						continue;
					default:
						Write(c);
						flag = false;
						continue;
					}
				}
				Write('\\');
				switch (c)
				{
				case '\0':
					Write('0');
					break;
				case '\a':
					Write('a');
					break;
				case '\b':
					Write('b');
					break;
				case '\t':
					Write('t');
					break;
				case '\n':
					Write('n');
					break;
				case '\v':
					Write('v');
					break;
				case '\f':
					Write('f');
					break;
				case '\r':
					Write('r');
					break;
				case '\u001b':
					Write('e');
					break;
				case '"':
					Write('"');
					break;
				case '\\':
					Write('\\');
					break;
				case '\u0085':
					Write('N');
					break;
				case '\u00a0':
					Write('_');
					break;
				case '\u2028':
					Write('L');
					break;
				case '\u2029':
					Write('P');
					break;
				default:
				{
					ushort num = c;
					if (num <= 255)
					{
						Write('x');
						Write(num.ToString("X02", CultureInfo.InvariantCulture));
					}
					else if (IsHighSurrogate(c))
					{
						if (i + 1 >= value.Length || !IsLowSurrogate(value[i + 1]))
						{
							throw new SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							Write('U');
							Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						}
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			SequenceStart sequenceStart = (SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
			{
				state = EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			MappingStart mappingStart = (MappingStart)evt;
			if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
			{
				state = EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = EmitterState.BlockMappingFirstKey;
			}
		}

		private void ProcessAnchor()
		{
			if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
			{
				WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
				WriteAnchor(anchorData.Anchor);
			}
		}

		private void ProcessTag()
		{
			if (tagData.Handle == null && tagData.Suffix == null)
			{
				return;
			}
			if (tagData.Handle != null)
			{
				WriteTagHandle(tagData.Handle);
				if (tagData.Suffix != null)
				{
					WriteTagContent(tagData.Suffix, needsWhitespace: false);
				}
			}
			else
			{
				WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
				WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void EmitDocumentEnd(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
			{
				WriteIndent();
				if (!documentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is SequenceEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
			}
			else
			{
				if (!isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				}
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				states.Push(EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is MappingEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
				return;
			}
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			if (!isCanonical && CheckSimpleKey())
			{
				states.Push(EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
			}
			states.Push(EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private static int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				if (characterAnalyzer.IsSpace() || characterAnalyzer.IsBreak())
				{
					int num = bestIndent;
					string indicator = num.ToString(CultureInfo.InvariantCulture);
					WriteIndicator(indicator, needWhitespace: false, whitespace: false, indentation: false);
				}
				string text = null;
				if (value.Length == 0 || !characterAnalyzer.IsBreak(value.Length - 1))
				{
					text = "-";
				}
				else if (value.Length >= 2 && characterAnalyzer.IsBreak(value.Length - 2))
				{
					text = "+";
				}
				if (text != null)
				{
					WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, delegate(Match match)
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat(CultureInfo.InvariantCulture, "%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	internal sealed class EmitterSettings
	{
		public static readonly EmitterSettings Default = new EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public string NewLine { get; } = Environment.NewLine;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public bool UseUtf16SurrogatePairs { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings Canonical()
		{
			return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithoutAnchorName()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithUtf16SurrogatePairs()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal static class HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object? o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object? obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!initialCapacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The initial capacity must be a power of 2.", "initialCapacity");
			}
			items = new T[initialCapacity];
			readPtr = initialCapacity / 2;
			writePtr = initialCapacity / 2;
			mask = initialCapacity - 1;
		}

		public void Enqueue(T item)
		{
			ResizeIfNeeded();
			items[writePtr] = item;
			writePtr = (writePtr - 1) & mask;
			count++;
		}

		public T Dequeue()
		{
			if (count == 0)
			{
				throw new InvalidOperationException("The queue is empty");
			}
			T result = items[readPtr];
			readPtr = (readPtr - 1) & mask;
			count--;
			return result;
		}

		public void Insert(int index, T item)
		{
			if (index > count)
			{
				throw new InvalidOperationException("Cannot insert outside of the bounds of the queue");
			}
			ResizeIfNeeded();
			CalculateInsertionParameters(mask, count, index, ref readPtr, ref writePtr, out var insertPtr, out var copyIndex, out var copyOffset, out var copyLength);
			if (copyLength != 0)
			{
				Array.Copy(items, copyIndex, items, copyIndex + copyOffset, copyLength);
			}
			items[insertPtr] = item;
			count++;
		}

		private void ResizeIfNeeded()
		{
			int num = items.Length;
			if (count == num)
			{
				T[] destinationArray = new T[num * 2];
				int num2 = readPtr + 1;
				if (num2 > 0)
				{
					Array.Copy(items, 0, destinationArray, 0, num2);
				}
				writePtr += num;
				int num3 = num - num2;
				if (num3 > 0)
				{
					Array.Copy(items, readPtr + 1, destinationArray, writePtr + 1, num3);
				}
				items = destinationArray;
				mask = mask * 2 + 1;
			}
		}

		internal static void CalculateInsertionParameters(int mask, int count, int index, ref int readPtr, ref int writePtr, out int insertPtr, out int copyIndex, out int copyOffset, out int copyLength)
		{
			int num = (readPtr + 1) & mask;
			if (index == 0)
			{
				insertPtr = (readPtr = num);
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			insertPtr = (readPtr - index) & mask;
			if (index == count)
			{
				writePtr = (writePtr - 1) & mask;
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			int num2 = ((num >= insertPtr) ? (readPtr - insertPtr) : int.MaxValue);
			int num3 = ((writePtr <= insertPtr) ? (insertPtr - writePtr) : int.MaxValue);
			if (num2 <= num3)
			{
				insertPtr++;
				readPtr++;
				copyIndex = insertPtr;
				copyOffset = 1;
				copyLength = num2;
			}
			else
			{
				copyIndex = writePtr + 1;
				copyOffset = -1;
				copyLength = num3;
				writePtr = (writePtr - 1) & mask;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			int ptr = readPtr;
			for (int i = 0; i < Count; i++)
			{
				yield return items[ptr];
				ptr = (ptr - 1) & mask;
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[DebuggerStepThrough]
	internal sealed class LookAheadBuffer : ILookAheadBuffer
	{
		private readonly TextReader input;

		private readonly char[] buffer;

		private readonly int blockSize;

		private readonly int mask;

		private int firstIndex;

		private int writeOffset;

		private int count;

		private bool endOfInput;

		public bool EndOfInput
		{
			get
			{
				if (endOfInput)
				{
					return count == 0;
				}
				return false;
			}
		}

		public LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!capacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The capacity must be a power of 2.", "capacity");
			}
			this.input = input ?? throw new ArgumentNullException("input");
			blockSize = capacity;
			buffer = new char[capacity * 2];
			mask = capacity * 2 - 1;
		}

		private int GetIndexForOffset(int offset)
		{
			return (firstIndex + offset) & mask;
		}

		public char Peek(int offset)
		{
			if (offset >= count)
			{
				FillBuffer();
			}
			if (offset < count)
			{
				return buffer[(firstIndex + offset) & mask];
			}
			return '\0';
		}

		public void Cache(int length)
		{
			if (length >= count)
			{
				FillBuffer();
			}
		}

		private void FillBuffer()
		{
			if (endOfInput)
			{
				return;
			}
			int num = blockSize;
			do
			{
				int num2 = input.Read(buffer, writeOffset, num);
				if (num2 == 0)
				{
					endOfInput = true;
					return;
				}
				num -= num2;
				writeOffset += num2;
				count += num2;
			}
			while (num > 0);
			if (writeOffset == buffer.Length)
			{
				writeOffset = 0;
			}
		}

		public void Skip(int length)
		{
			if (length < 1 || length > blockSize)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
			}
			firstIndex = GetIndexForOffset(length);
			count -= length;
		}
	}
	internal readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object? obj)
		{
			return Equals((Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object? obj)
		{
			return CompareTo((Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}

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

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

		public static bool operator <(Mark left, Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(Mark left, Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(Mark left, Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(Mark left, Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	internal sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class MergingParser : IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private static IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart mappingStart)
				{
					AnchorName anchor = mappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new SequenceEnd(in start, in end);
			}

			void IParsingEventVisitor.Visit(MappingStart e)
			{
				clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new MappingEnd(in start, in end);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly IParser innerParser;

		private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

		private bool merged;

		public ParsingEvent? Current => iterator.Current?.Value;

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						Mark start = @event.Value.Start;
						Mark end = @event.Value.End;
						throw new SemanticErrorException(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private static bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner @object = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(@object.Clone);
		}
	}
	internal class Parser : IParser
	{
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		private 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();
			Mark start;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				start = token?.Start ?? Mark.Empty;
				end = token?.End ?? Mark.Empty;
				throw new SemanticErrorException(in start, in end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			start = streamStart.Start;
			end = streamStart.End;
			return new YamlDotNet.Core.Events.StreamStart(in start, in end);
		}

		private ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is VersionDirective)
			{
				throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			Token token = GetCurrentToken();
			if (!isImplicit)
			{
				while (token is YamlDotNet.Core.Tokens.DocumentEnd)
				{
					Skip();
					token = GetCurrentToken();
				}
			}
			if (token == null)
			{
				throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
			{
				TagDirectiveCollection tags = new TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(ParserState.DocumentEnd);
				state = ParserState.BlockNode;
				return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
			}
			Mark start2;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
			{
				Mark start = token.Start;
				TagDirectiveCollection tags2 = new TagDirectiveCollection();
				VersionDirective versionDirective = ProcessDirectives(tags2);
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
				{
					start2 = token.Start;
					end = token.End;
					throw new SemanticErrorException(in start2, in end, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end2 = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end2);
			}
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
			}
			state = ParserState.StreamEnd;
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			start2 = token.Start;
			end = token.End;
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(in start2, in end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		private VersionDirective? ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(in start, in end, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(in start, in end, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						Mark start = tagDirective.Start;
						Mark end = tagDirective.End;
						throw new SemanticErrorException(in start, in end, "Found duplicate %TAG directive.");
					}
					tags.Add(tagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
				{
					version = new VersionDirective(new Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
		{
			foreach (TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
			{
				state = states.Pop();
				Mark position = scanner.CurrentPosition;
				return ProcessEmptyScalar(in position);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static YamlDotNet.Core.Events.Scalar ProcessEmptyScalar(in Mark position)
		{
			return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, string.Empty, ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			Mark start;
			Mark end;
			if (GetCurrentToken() is Error error)
			{
				start = error.Start;
				end = error.End;
				throw new SemanticErrorException(in start, in end, error.Value);
			}
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				state = states.Pop();
				ParsingEvent result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
				Skip();
				return result;
			}
			Mark start2 = token.Start;
			AnchorName anchor = AnchorName.Empty;
			TagName tag = TagName.Empty;
			Anchor anchor2 = null;
			Tag tag2 = null;
			while (true)
			{
				if (anchor.IsEmpty && token is Anchor anchor3)
				{
					anchor2 = anchor3;
					anchor = anchor3.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(token is Tag tag3))
					{
						if (token is Anchor anchor4)
						{
							start = anchor4.Start;
							end = anchor4.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias2)
						{
							start = anchorAlias2.Start;
							end = anchorAlias2.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, did not find expected token.");
						}
						if (!(token is Error error2))
						{
							break;
						}
						if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
						}
						start = error2.Start;
						end = error2.End;
						throw new SemanticErrorException(in start, in end, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							start = tag3.Start;
							end = tag3.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, found undefined tag handle.");
						}
						tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
					}
					Skip();
				}
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
			{
				state = ParserState.IndentlessSequenceEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				ParsingEvent result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start2, scalar.End, scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is Error)
					{
						Error error3 = currentToken as Error;
						start = error3.Start;
						end = error3.End;
						throw new SemanticErrorException(in start, in end, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && !(scanner.Current is FlowMappingEnd) && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new SemanticErrorException(in start, in end, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (token is FlowSequenceStart flowSequenceStart)
			{
				state = ParserState.FlowSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
			}
			start = token.Start;
			end = token.End;
			throw new SemanticErrorException(in start, in end, "While parsing a node, did not find expected node content.");
		}

		private YamlDotNet.Core.Events.DocumentEnd ParseDocumentEnd()
		{
			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 blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			Mark start;
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				start = blockEnd.Start;
				end = blockEnd.End;
				ParsingEvent result = new SequenceEnd(in start, in end);
				Skip();
				return result;
			}
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in start, in end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new SequenceEnd(in start, in end);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key key)
			{
				Mark position = key.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			Mark position2;
			if (token is Value value)
			{
				Skip();
				position2 = value.End;
				return ProcessEmptyScalar(in position2);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				position2 = blockEnd.Start;
				end = blockEnd.End;
				ParsingEvent result = new MappingEnd(in position2, in end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error error)
			{
				position2 = error.Start;
				end = error.End;
				throw new SyntaxErrorException(in position2, in end, error.Value);
			}
			position2 = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in position2, in end, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value value)
			{
				Mark position = value.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			Mark start;
			if (token is Error error)
			{
				start = error.Start;
				Mark end = error.End;
				throw new SemanticErrorException(in start, in end, error.Value);
			}
			state = ParserState.BlockMappingKey;
			start = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in start);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			ParsingEvent result;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					result = new MappingStart(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			result = new SequenceEnd(in start, in end);
			Skip();
			return result;
		}

		private ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			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;
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in position);
		}

		private MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (token is Key)
				{
					Skip();
					token = GetCurrentToken();
					if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
					{
						states.Push(ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = ParserState.FlowMappingValue;
					start = token?.Start ?? Mark.Empty;
					return ProcessEmptyScalar(in start);
				}
				if (token is YamlDotNet.Core.Tokens.Scalar)
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (!isEmpty && token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowMappingKey;
			if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
			}
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in position);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				Mark start = current.Start;
				Mark end = current.End;
				throw new YamlException(in start, in end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [MaybeNullWhen(false)] out YamlDotNet.Core.Events.Scalar? key, [MaybeNullWhen(false)] out ParsingEvent? value)
		{
			if (parser.TryConsume<MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.Scalar scalar))
					{
						if (current is MappingStart || current is SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool flag = selector(scalar);
					parser.MoveNext();
					if (flag)
					{
						value = parser.Current;
						key = scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum ParserState
	{
		StreamStart,
		StreamEnd,
		ImplicitDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		BlockNode,
		BlockNodeOrIndentlessSequence,
		FlowNode,
		BlockSequenceFirstEntry,
		BlockSequenceEntry,
		IndentlessSequenceEntry,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingValue,
		FlowSequenceFirstEntry,
		FlowSequenceEntry,
		FlowSequenceEntryMappingKey,
		FlowSequenceEntryMappingValue,
		FlowSequenceEntryMappingEnd,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingValue,
		FlowMappingEmptyValue
	}
	internal sealed class RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	internal enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded,
		ForcePlain
	}
	internal class Scanner : IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<long> indents = new Stack<long>();

		private readonly InsertionQueue<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();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamStart(in start, in start));
		}

		private void UnrollIndent(long column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark start = cursor.Mark();
					tokens.Enqueue(new BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			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))
				{
					Mark end = cursor.Mark();
					throw new SemanticErrorException(in start, in end, "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				Mark end2 = cursor.Mark();
				insertionQueue.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in end, in end2));
				return;
			}
			Token token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					token = new Error("While scanning a document end, found invalid content after '...' marker.", end, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(in end, in end));
			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()
		{
			Mark start;
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						start = previousAnchor.Start;
						Mark end = previousAnchor.End;
						throw new SemanticErrorException(in start, in end, "Anchor before sequence entry on same line is not allowed.");
					}
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			start = cursor.Mark();
			insertionQueue.Enqueue(new BlockEntry(in start2, in start));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			Mark end = cursor.Mark();
			insertionQueue.Enqueue(new Key(in start2, in end));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			Mark start;
			if (simpleKey.IsPossible)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				int index = simpleKey.TokenNumber - tokensParsed;
				start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				insertionQueue.Insert(index, new Key(in start, in end));
				RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
				simpleKey.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0L && simpleKey.LineOffset == 0L)
					{
						InsertionQueue<Token> insertionQueue2 = tokens;
						int count = tokens.Count;
						start = simpleKey.Mark;
						Mark end = simpleKey.Mark;
						insertionQueue2.Insert(count, new Key(in start, in end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue3 = tokens;
			start = cursor.Mark();
			insertionQueue3.Enqueue(new Value(in start2, in start));
		}

		private void RollIndent(long column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				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("?:,]}%@`")))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private Tag ScanTag()
		{
			Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private YamlDotNet.Core.Tokens.Scalar ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						long currentIndent = 0L;
						bool flag = false;
						bool? isFirstLine = null;
						Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								Mark end = cursor.Mark();
								throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine.GetValueOrDefault())
							{
								isFirstLine = false;
							}
						}
						Mark end2 = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end2);
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine.GetValueOrDefault())
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine.GetValueOrDefault())
			{
				long num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", mark, mark));
			}
		}

		private YamlDotNet.Core.Tokens.Scalar ScanFlowScalar(bool isSingleQuoted)
		{
			Mark start = cursor.Mark();
			Skip();
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							while (true)
							{
								if (IsDocumentIndicator())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											Mark end = cursor.Mark();
											throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													Mark end = cursor.Mark();
													throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private YamlDotNet.Core.Tokens.Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							long num = indent + 1;
							Mark start = cursor.Mark();
							Mark end = start;
							SimpleKey simpleKey = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!simpleKey.IsPossible || !simpleKey.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !simpleKey.IsPossible)
										{
											tokens.Enqueue(new Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new InvalidOperationException();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											Mark end2 = cursor.Mark();
											throw new SyntaxErrorException(in start, in end2, "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				Mark start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				throw new SyntaxErrorException(in start, in end, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(in Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private VersionDirective ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private TagDirective ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(string? head, Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					Mark start2 = cursor.Mark();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start2, in end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private string ScanUriEscapes(in Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						Mark end = cursor.Mark();
						throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string @string = Encoding.UTF8.GetString(array, 0, count);
			if (@string.Length == 0 || @string.Length > 2)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	internal class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long LineOffset => cursor.LineOffset;

		public Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public SimpleKey()
		{
			cursor = new Cursor();
		}

		public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new Cursor(cursor);
		}
	}
	internal sealed class StringLookAheadBuffer : ILookAheadBuffer, IResettable
	{
		public string Value { get; set; } = string.Empty;


		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return Value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= Value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	internal sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
	{
		public TagDirectiveCollection()
		{
		}

		public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
		{
			foreach (TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	internal readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

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

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

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

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

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

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

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

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

		public static implicit operator TagName(string? value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		public override bool Equals(object? obj)
		{
			if (obj is Version version && Major == version.Major)
			{
				return Minor == version.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(in Mark.Empty, in Mark.Empty, message)
		{
		}

		public YamlException(in Mark start, in Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(in Mark.Empty, in Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class Anchor : Token
	{
		public AnchorName Value { get; }

		public Anchor(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public Anchor(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class AnchorAlias : Token
	{
		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Comment : Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	internal sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Key(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Scalar : Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public ScalarStyle Style { get; }

		public Scalar(string value)
			: this(value, ScalarStyle.Any)
		{
		}

		public Scalar(string value, ScalarStyle style)
			: this(value, style, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value, ScalarStyle style, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Tag : Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public Tag(string handle, string suffix)
			: this(handle, suffix, Mark.Empty, Mark.Empty)
		{
		}

		public Tag(string handle, string suffix, Mark start, Mark end)
			: base(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	internal class TagDirective : Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public TagDirective(string handle, string prefix)
			: this(handle, prefix, Mark.Empty, Mark.Empty)
		{
		}

		public TagDirective(string handle, string prefix, Mark start, Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	internal abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Value : Token
	{
		public Value()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Value(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class VersionDirective : Token
	{
		public Version Version { get; }

		public VersionDirective(Version version)
			: this(version, Mark.Empty, Mark.Empty)
		{
		}

		public VersionDirective(Version version, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		public override bool Equals(object? obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;


		public int MaximumRetainedCapacity { get; set; } = 4096;


		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly StringLookAheadBuffer Buffer;

			private readonly ObjectPool<StringLookAheadBuffer> pool;

			public BufferWrapper(StringLookAheadBuffer buffer, ObjectPool<StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Buffer.ToString();
			}

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			StringLookAheadBuffer stringLookAheadBuffer = Pool.Get();
			stringLookAheadBuffer.Value = value;
			return new BufferWrapper(stringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class Comment : ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override EventType Type => EventType.Comment;

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	internal sealed class DocumentEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public DocumentEnd(bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			IsImplicit = isImplicit;
		}

		public DocumentEnd(bool isImplicit)
			: this(isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class DocumentStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.DocumentStart;

		public TagDirectiveCollection? Tags { get; }

		public VersionDirective? Version { get; }

		public bool IsImplicit { get; }

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	internal interface IParsingEventVisitor
	{
		void Visit(AnchorAlias e);

		void Visit(StreamStart e);

		void Visit(StreamEnd e);

		void Visit(DocumentStart e);

		void Visit(DocumentEnd e);

		void Visit(Scalar e);

		void Visit(SequenceStart e);

		void Visit(SequenceEnd e);

		void Visit(MappingStart e);

		void Visit(MappingEnd e);

		void Visit(Comment e);
	}
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public MappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class MappingStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public MappingStyle Style { get; }

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public MappingStart()
			: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	internal abstract class ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract EventType Type { get; }

		public Mark Start { get; }

		public Mark End { get; }

		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Scalar : NodeEvent
	{
		internal override EventType Type => EventType.Scalar;

		public string Value { get; }

		public ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public bool IsKey { get; }

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value)
			: this(AnchorName.Empty, TagName.Empty, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(TagName tag, string value)
			: this(AnchorName.Empty, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(AnchorName anchor, TagName tag, string value)
			: this(anchor, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Scalar [anchor = {base.Anchor}, tag = {base.Tag}, value = {Value}, style = {Style}, isPlainImplicit = {IsPlainImplicit}, isQuotedImplicit = {IsQuotedImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public SequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

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

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}